From 3d6483e8fd59d2e77149aa5d78ec32448be7338c Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 21 Jul 2020 22:46:49 +0300
Subject: Move tests to module

* test/unittest/: Move to wqflask/tests/
---
 wqflask/tests/__init__.py                 |  0
 wqflask/tests/base/__init__.py            |  0
 wqflask/tests/base/test_general_object.py | 21 +++++++++++++++++++++
 3 files changed, 21 insertions(+)
 create mode 100644 wqflask/tests/__init__.py
 create mode 100644 wqflask/tests/base/__init__.py
 create mode 100644 wqflask/tests/base/test_general_object.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/__init__.py b/wqflask/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/base/__init__.py b/wqflask/tests/base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/base/test_general_object.py b/wqflask/tests/base/test_general_object.py
new file mode 100644
index 00000000..699cb079
--- /dev/null
+++ b/wqflask/tests/base/test_general_object.py
@@ -0,0 +1,21 @@
+import unittest
+
+from base.GeneralObject import GeneralObject
+
+
+class TestGeneralObjectTests(unittest.TestCase):
+    """
+    Test the GeneralObject base class
+    """
+
+    def test_object_contents(self):
+        """Test whether base contents are stored properly"""
+        test_obj = GeneralObject("a", "b", "c")
+        self.assertEqual("abc", ''.join(test_obj.contents))
+
+    def test_object_dict(self):
+        """Test whether the base class is printed properly"""
+        test_obj = GeneralObject("a", name="test", value=1)
+        self.assertEqual(str(test_obj), "value = 1\nname = test\n")
+        self.assertEqual(
+            repr(test_obj), "value = 1\nname = test\ncontents = ['a']\n")
-- 
cgit v1.2.3


From b4d35b413df6ac11648030afd9ceb76e05e0e0f5 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 21 Jul 2020 23:36:48 +0300
Subject: Test utility methods for chunking

* wqflask/tests/utility/test_chunks.py: New test
---
 wqflask/tests/utility/__init__.py    |  0
 wqflask/tests/utility/test_chunks.py | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 wqflask/tests/utility/__init__.py
 create mode 100644 wqflask/tests/utility/test_chunks.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/__init__.py b/wqflask/tests/utility/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/utility/test_chunks.py b/wqflask/tests/utility/test_chunks.py
new file mode 100644
index 00000000..8d90a1ec
--- /dev/null
+++ b/wqflask/tests/utility/test_chunks.py
@@ -0,0 +1,19 @@
+"""Test chunking"""
+
+import unittest
+
+from utility.chunks import divide_into_chunks
+
+
+class TestChunks(unittest.TestCase):
+    "Test Utility method for chunking"
+    def test_divide_into_chunks(self):
+        "Check that a list is chunked correctly"
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3),
+                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 4),
+                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 5),
+                         [[1, 2], [7, 3], [22, 8], [5, 22], [333]])
+        self.assertEqual(divide_into_chunks([], 5),
+                         [[]])
-- 
cgit v1.2.3


From 539e6ac3f211391cf241f2f2b70ed7dbd327fc28 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 22 Jul 2020 00:43:12 +0300
Subject: Add unittests for *utility/corestats*

---
 wqflask/tests/utility/test_corestats.py | 55 +++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 wqflask/tests/utility/test_corestats.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_corestats.py b/wqflask/tests/utility/test_corestats.py
new file mode 100644
index 00000000..cf91a248
--- /dev/null
+++ b/wqflask/tests/utility/test_corestats.py
@@ -0,0 +1,55 @@
+"""Test Core Stats"""
+
+import unittest
+
+from utility.corestats import Stats
+
+
+class TestChunks(unittest.TestCase):
+    "Test Utility method for chunking"
+
+    def setUp(self):
+        self.stat_test = Stats((x for x in range(1, 11)))
+
+    def test_stats_sum(self):
+        """ Test sequence sum """
+        self.assertEqual(self.stat_test.sum(), 55)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.sum(), None)
+
+    def test_stats_count(self):
+        """ Test sequence count """
+        self.assertEqual(self.stat_test.count(), 10)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.count(), 0)
+
+    def test_stats_min(self):
+        """ Test min value in sequence"""
+        self.assertEqual(self.stat_test.min(), 1)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.min(), None)
+
+    def test_stats_max(self):
+        """ Test max value in sequence """
+        self.assertEqual(self.stat_test.max(), 10)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.max(), None)
+
+    def test_stats_avg(self):
+        """ Test avg of sequence """
+        self.assertEqual(self.stat_test.avg(), 5.5)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.avg(), None)
+
+    def test_stats_stdev(self):
+        """ Test standard deviation of sequence """
+        self.assertEqual(self.stat_test.stdev(), 3.0276503540974917)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.stdev(), None)
+
+    def test_stats_percentile(self):
+        """ Test percentile of sequence """
+        self.assertEqual(self.stat_test.percentile(20), 3.0)
+        self.assertEqual(self.stat_test.percentile(101), None)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.percentile(20), None)
-- 
cgit v1.2.3


From 01bbbc1ee82b43505e65446e4657ca7790453fdf Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 22 Jul 2020 01:33:10 +0300
Subject: Add unittests for *utility/corr_result_helper*

---
 wqflask/tests/utility/test_corr_result_helpers.py | 32 +++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 wqflask/tests/utility/test_corr_result_helpers.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_corr_result_helpers.py b/wqflask/tests/utility/test_corr_result_helpers.py
new file mode 100644
index 00000000..e196fbdf
--- /dev/null
+++ b/wqflask/tests/utility/test_corr_result_helpers.py
@@ -0,0 +1,32 @@
+""" Test correlation helper methods """
+
+import unittest
+from utility.corr_result_helpers import normalize_values, common_keys, normalize_values_with_samples
+
+
+class TestCorrelationHelpers(unittest.TestCase):
+    """Test methods for normalising lists"""
+
+    def test_normalize_values(self):
+        """Test that a list is normalised correctly"""
+        self.assertEqual(
+            normalize_values([2.3, None, None, 3.2, 4.1, 5], [
+                             3.4, 7.2, 1.3, None, 6.2, 4.1]),
+            ([2.3, 4.1, 5], [3.4, 6.2, 4.1], 3)
+        )
+
+    def test_common_keys(self):
+        """Test that common keys are returned as a list"""
+        a = dict(BXD1=9.113, BXD2=9.825, BXD14=8.985, BXD15=9.300)
+        b = dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)
+        self.assertEqual(sorted(common_keys(a, b)), ['BXD1', 'BXD14'])
+
+    def test_normalize_values_with_samples(self):
+        """Test that a sample(dict) is normalised correctly"""
+        self.assertEqual(
+            normalize_values_with_samples(
+                dict(BXD1=9.113, BXD2=9.825, BXD14=8.985,
+                     BXD15=9.300, BXD20=9.300),
+                dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)),
+            (({'BXD1': 9.113, 'BXD14': 8.985}, {'BXD1': 9.723, 'BXD14': 9.124}, 2))
+        )
-- 
cgit v1.2.3


From 87fd995209aba0df1f95c1d5d5dd7eefd60d0906 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 22 Jul 2020 17:22:14 +0300
Subject: Add unittests for *utility/test_numify*

---
 wqflask/tests/utility/test_numify.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 wqflask/tests/utility/test_numify.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_numify.py b/wqflask/tests/utility/test_numify.py
new file mode 100644
index 00000000..9d3033d1
--- /dev/null
+++ b/wqflask/tests/utility/test_numify.py
@@ -0,0 +1,33 @@
+import unittest
+from utility.formatting import numify, commify
+
+
+class TestFormatting(unittest.TestCase):
+    """Test formatting numbers by numifying or commifying"""
+
+    def test_numify(self):
+        "Test that a number is correctly converted to a English readable string"
+        self.assertEqual(numify(1, 'item', 'items'),
+                         'one item')
+        self.assertEqual(numify(2, 'book'), 'two')
+        self.assertEqual(numify(2, 'book', 'books'), 'two books')
+        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
+        self.assertEqual(numify(0), 'zero')
+        self.assertEqual(numify(5), 'five')
+        self.assertEqual(numify(14, 'book', 'books'), '14 books')
+        self.assertEqual(numify(999, 'book', 'books'), '999 books')
+        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
+        self.assertEqual(numify(1956), '1956')
+
+    def test_commify(self):
+        "Test that commas are added correctly"
+        self.assertEqual(commify(1), '1')
+        self.assertEqual(commify(123), '123')
+        self.assertEqual(commify(1234), '1234')
+        self.assertEqual(commify(12345), '12,345')
+        self.assertEqual(commify(1234567890), '1,234,567,890')
+        self.assertEqual(commify(123.0), '123.0')
+        self.assertEqual(commify(1234.5), '1234.5')
+        self.assertEqual(commify(1234.56789), '1234.56789')
+        self.assertEqual(commify(123456.789), '123,456.789')
+        self.assertEqual(commify(None), None)
-- 
cgit v1.2.3


From 16aaf9885971993863b5e2e8a1b99f8479e2bbb9 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 23 Jul 2020 02:52:41 +0300
Subject: Add unittests for *base/data_set*

---
 wqflask/tests/base/test_data_set.py | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 wqflask/tests/base/test_data_set.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
new file mode 100644
index 00000000..44a54c7e
--- /dev/null
+++ b/wqflask/tests/base/test_data_set.py
@@ -0,0 +1,35 @@
+import unittest
+import mock
+
+from wqflask import app
+
+from base.data_set import DatasetType
+
+    
+class TestDataSetTypes(unittest.TestCase):
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch('base.data_set.g')
+    def test_data_set_type(self, db_mock):
+        with app.app_context():
+            db_mock.get = mock.Mock()
+            r = mock.Mock()
+            r.get.return_value = """
+            {
+                "AD-cases-controls-MyersGeno": "Geno",
+                "AD-cases-controls-MyersPublish": "Publish",
+                "AKXDGeno": "Geno",
+                "AXBXAGeno": "Geno",
+                "AXBXAPublish": "Publish",
+                "Aging-Brain-UCIPublish": "Publish",
+                "All Phenotypes": "Publish",
+                "B139_K_1206_M": "ProbeSet",
+                "B139_K_1206_R": "ProbeSet"
+            }
+            """
+            self.assertEqual(DatasetType(r)("All Phenotypes"), "Publish")
-- 
cgit v1.2.3


From a6075ce879c338532de39e100f09d92c17b566e7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 23 Jul 2020 02:54:59 +0300
Subject: Rename test_numify.py to test_formatting.py

---
 wqflask/tests/utility/test_formatting.py | 33 ++++++++++++++++++++++++++++++++
 wqflask/tests/utility/test_numify.py     | 33 --------------------------------
 2 files changed, 33 insertions(+), 33 deletions(-)
 create mode 100644 wqflask/tests/utility/test_formatting.py
 delete mode 100644 wqflask/tests/utility/test_numify.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_formatting.py b/wqflask/tests/utility/test_formatting.py
new file mode 100644
index 00000000..9d3033d1
--- /dev/null
+++ b/wqflask/tests/utility/test_formatting.py
@@ -0,0 +1,33 @@
+import unittest
+from utility.formatting import numify, commify
+
+
+class TestFormatting(unittest.TestCase):
+    """Test formatting numbers by numifying or commifying"""
+
+    def test_numify(self):
+        "Test that a number is correctly converted to a English readable string"
+        self.assertEqual(numify(1, 'item', 'items'),
+                         'one item')
+        self.assertEqual(numify(2, 'book'), 'two')
+        self.assertEqual(numify(2, 'book', 'books'), 'two books')
+        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
+        self.assertEqual(numify(0), 'zero')
+        self.assertEqual(numify(5), 'five')
+        self.assertEqual(numify(14, 'book', 'books'), '14 books')
+        self.assertEqual(numify(999, 'book', 'books'), '999 books')
+        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
+        self.assertEqual(numify(1956), '1956')
+
+    def test_commify(self):
+        "Test that commas are added correctly"
+        self.assertEqual(commify(1), '1')
+        self.assertEqual(commify(123), '123')
+        self.assertEqual(commify(1234), '1234')
+        self.assertEqual(commify(12345), '12,345')
+        self.assertEqual(commify(1234567890), '1,234,567,890')
+        self.assertEqual(commify(123.0), '123.0')
+        self.assertEqual(commify(1234.5), '1234.5')
+        self.assertEqual(commify(1234.56789), '1234.56789')
+        self.assertEqual(commify(123456.789), '123,456.789')
+        self.assertEqual(commify(None), None)
diff --git a/wqflask/tests/utility/test_numify.py b/wqflask/tests/utility/test_numify.py
deleted file mode 100644
index 9d3033d1..00000000
--- a/wqflask/tests/utility/test_numify.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import unittest
-from utility.formatting import numify, commify
-
-
-class TestFormatting(unittest.TestCase):
-    """Test formatting numbers by numifying or commifying"""
-
-    def test_numify(self):
-        "Test that a number is correctly converted to a English readable string"
-        self.assertEqual(numify(1, 'item', 'items'),
-                         'one item')
-        self.assertEqual(numify(2, 'book'), 'two')
-        self.assertEqual(numify(2, 'book', 'books'), 'two books')
-        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
-        self.assertEqual(numify(0), 'zero')
-        self.assertEqual(numify(5), 'five')
-        self.assertEqual(numify(14, 'book', 'books'), '14 books')
-        self.assertEqual(numify(999, 'book', 'books'), '999 books')
-        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
-        self.assertEqual(numify(1956), '1956')
-
-    def test_commify(self):
-        "Test that commas are added correctly"
-        self.assertEqual(commify(1), '1')
-        self.assertEqual(commify(123), '123')
-        self.assertEqual(commify(1234), '1234')
-        self.assertEqual(commify(12345), '12,345')
-        self.assertEqual(commify(1234567890), '1,234,567,890')
-        self.assertEqual(commify(123.0), '123.0')
-        self.assertEqual(commify(1234.5), '1234.5')
-        self.assertEqual(commify(1234.56789), '1234.56789')
-        self.assertEqual(commify(123456.789), '123,456.789')
-        self.assertEqual(commify(None), None)
-- 
cgit v1.2.3


From f95a42b0a9445a58e68fc83e9b1411bedef67904 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 24 Jul 2020 01:43:26 +0300
Subject: Add more tests for GeneralObject

* wqflask/tests/base/test_general_object.py: test object's magic methods
---
 wqflask/tests/base/test_general_object.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_general_object.py b/wqflask/tests/base/test_general_object.py
index 699cb079..df5791e0 100644
--- a/wqflask/tests/base/test_general_object.py
+++ b/wqflask/tests/base/test_general_object.py
@@ -12,6 +12,7 @@ class TestGeneralObjectTests(unittest.TestCase):
         """Test whether base contents are stored properly"""
         test_obj = GeneralObject("a", "b", "c")
         self.assertEqual("abc", ''.join(test_obj.contents))
+        self.assertEqual(len(test_obj), 0)
 
     def test_object_dict(self):
         """Test whether the base class is printed properly"""
@@ -19,3 +20,8 @@ class TestGeneralObjectTests(unittest.TestCase):
         self.assertEqual(str(test_obj), "value = 1\nname = test\n")
         self.assertEqual(
             repr(test_obj), "value = 1\nname = test\ncontents = ['a']\n")
+        self.assertEqual(len(test_obj), 2)
+        self.assertEqual(getattr(test_obj, "value"), 1)
+        self.assertEqual(test_obj["value"], 1)
+        test_obj["test"] = 1
+        self.assertEqual(test_obj["test"], 1)
-- 
cgit v1.2.3


From 09bc3137328fbefe41044b5124f3c6a7abaa8982 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 24 Jul 2020 02:14:50 +0300
Subject: Add more tests for general_object

* wqflask/tests/base/test_general_object.py: test getattr() and `==`
---
 wqflask/tests/base/test_general_object.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_general_object.py b/wqflask/tests/base/test_general_object.py
index df5791e0..c7701021 100644
--- a/wqflask/tests/base/test_general_object.py
+++ b/wqflask/tests/base/test_general_object.py
@@ -21,7 +21,21 @@ class TestGeneralObjectTests(unittest.TestCase):
         self.assertEqual(
             repr(test_obj), "value = 1\nname = test\ncontents = ['a']\n")
         self.assertEqual(len(test_obj), 2)
-        self.assertEqual(getattr(test_obj, "value"), 1)
         self.assertEqual(test_obj["value"], 1)
         test_obj["test"] = 1
         self.assertEqual(test_obj["test"], 1)
+
+    def test_get_attribute(self):
+        "Test that getattr works"
+        test_obj = GeneralObject("a", name="test", value=1)
+        self.assertEqual(getattr(test_obj, "value", None), 1)
+        self.assertEqual(getattr(test_obj, "non-existent", None), None)
+
+    def test_object_comparisons(self):
+        "Test that 2 objects of the same length are equal"
+        test_obj1 = GeneralObject("a", name="test", value=1)
+        test_obj2 = GeneralObject("b", name="test2", value=2)
+        test_obj3 = GeneralObject("a", name="test", x=1, y=2)
+        self.assertTrue(test_obj1 == test_obj2 )
+        self.assertFalse(test_obj1 == test_obj3 )
+
-- 
cgit v1.2.3


From 70a8b445df32b7ed15612ffa745269959eb9159b Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 22 Jul 2020 17:22:14 +0300
Subject: Add unittests for *utility/test_numify*

---
 wqflask/tests/utility/test_numify.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 wqflask/tests/utility/test_numify.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_numify.py b/wqflask/tests/utility/test_numify.py
new file mode 100644
index 00000000..9d3033d1
--- /dev/null
+++ b/wqflask/tests/utility/test_numify.py
@@ -0,0 +1,33 @@
+import unittest
+from utility.formatting import numify, commify
+
+
+class TestFormatting(unittest.TestCase):
+    """Test formatting numbers by numifying or commifying"""
+
+    def test_numify(self):
+        "Test that a number is correctly converted to a English readable string"
+        self.assertEqual(numify(1, 'item', 'items'),
+                         'one item')
+        self.assertEqual(numify(2, 'book'), 'two')
+        self.assertEqual(numify(2, 'book', 'books'), 'two books')
+        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
+        self.assertEqual(numify(0), 'zero')
+        self.assertEqual(numify(5), 'five')
+        self.assertEqual(numify(14, 'book', 'books'), '14 books')
+        self.assertEqual(numify(999, 'book', 'books'), '999 books')
+        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
+        self.assertEqual(numify(1956), '1956')
+
+    def test_commify(self):
+        "Test that commas are added correctly"
+        self.assertEqual(commify(1), '1')
+        self.assertEqual(commify(123), '123')
+        self.assertEqual(commify(1234), '1234')
+        self.assertEqual(commify(12345), '12,345')
+        self.assertEqual(commify(1234567890), '1,234,567,890')
+        self.assertEqual(commify(123.0), '123.0')
+        self.assertEqual(commify(1234.5), '1234.5')
+        self.assertEqual(commify(1234.56789), '1234.56789')
+        self.assertEqual(commify(123456.789), '123,456.789')
+        self.assertEqual(commify(None), None)
-- 
cgit v1.2.3


From bcf98cc6c1f0208cc8f9a21d36196627e1d6e6b6 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 23 Jul 2020 02:54:59 +0300
Subject: Rename test_numify.py to test_formatting.py

---
 wqflask/tests/utility/test_numify.py | 33 ---------------------------------
 1 file changed, 33 deletions(-)
 delete mode 100644 wqflask/tests/utility/test_numify.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_numify.py b/wqflask/tests/utility/test_numify.py
deleted file mode 100644
index 9d3033d1..00000000
--- a/wqflask/tests/utility/test_numify.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import unittest
-from utility.formatting import numify, commify
-
-
-class TestFormatting(unittest.TestCase):
-    """Test formatting numbers by numifying or commifying"""
-
-    def test_numify(self):
-        "Test that a number is correctly converted to a English readable string"
-        self.assertEqual(numify(1, 'item', 'items'),
-                         'one item')
-        self.assertEqual(numify(2, 'book'), 'two')
-        self.assertEqual(numify(2, 'book', 'books'), 'two books')
-        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
-        self.assertEqual(numify(0), 'zero')
-        self.assertEqual(numify(5), 'five')
-        self.assertEqual(numify(14, 'book', 'books'), '14 books')
-        self.assertEqual(numify(999, 'book', 'books'), '999 books')
-        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
-        self.assertEqual(numify(1956), '1956')
-
-    def test_commify(self):
-        "Test that commas are added correctly"
-        self.assertEqual(commify(1), '1')
-        self.assertEqual(commify(123), '123')
-        self.assertEqual(commify(1234), '1234')
-        self.assertEqual(commify(12345), '12,345')
-        self.assertEqual(commify(1234567890), '1,234,567,890')
-        self.assertEqual(commify(123.0), '123.0')
-        self.assertEqual(commify(1234.5), '1234.5')
-        self.assertEqual(commify(1234.56789), '1234.56789')
-        self.assertEqual(commify(123456.789), '123,456.789')
-        self.assertEqual(commify(None), None)
-- 
cgit v1.2.3


From d63e7554d6dfce4e80c2570667a0fa371235beb7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 27 Jul 2020 14:31:31 +0300
Subject: Apply py-lint

* wqflask/tests/base/test_data_set.py: Apply pylint
---
 wqflask/tests/base/test_data_set.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 44a54c7e..74799e49 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -1,3 +1,5 @@
+"""Tests for wqflask/base/data_set.py"""
+
 import unittest
 import mock
 
@@ -5,8 +7,10 @@ from wqflask import app
 
 from base.data_set import DatasetType
 
-    
+
 class TestDataSetTypes(unittest.TestCase):
+    """Tests for the DataSetType class"""
+
     def setUp(self):
         self.app_context = app.app_context()
         self.app_context.push()
@@ -16,10 +20,14 @@ class TestDataSetTypes(unittest.TestCase):
 
     @mock.patch('base.data_set.g')
     def test_data_set_type(self, db_mock):
+        """Test that DatasetType returns correctly if the Redis Instance is not empty
+        and the name variable exists in the dictionary
+
+        """
         with app.app_context():
             db_mock.get = mock.Mock()
-            r = mock.Mock()
-            r.get.return_value = """
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = """
             {
                 "AD-cases-controls-MyersGeno": "Geno",
                 "AD-cases-controls-MyersPublish": "Publish",
@@ -32,4 +40,6 @@ class TestDataSetTypes(unittest.TestCase):
                 "B139_K_1206_R": "ProbeSet"
             }
             """
-            self.assertEqual(DatasetType(r)("All Phenotypes"), "Publish")
+            self.assertEqual(DatasetType(redis_mock)
+                             ("All Phenotypes"), "Publish")
+
-- 
cgit v1.2.3


From 5cad720187b3c53b6d64c64d45be4bc020eed52d Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 27 Jul 2020 14:32:26 +0300
Subject: Add test case for empty redis instance for DatasetType

* wqflask/tests/base/test_data_set.py(tests): Check correct results are returned
when Redis is empty
* wqflask/tests/base/data.py(tests): New file. Adds json test data.
---
 wqflask/tests/base/data.py          | 110 ++++++++++++++++++++++++++++++++++++
 wqflask/tests/base/test_data_set.py |  16 +++++-
 2 files changed, 125 insertions(+), 1 deletion(-)
 create mode 100644 wqflask/tests/base/data.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/data.py b/wqflask/tests/base/data.py
new file mode 100644
index 00000000..06a5a989
--- /dev/null
+++ b/wqflask/tests/base/data.py
@@ -0,0 +1,110 @@
+gen_menu_json = """
+{
+  "datasets": {
+    "human": {
+      "HLC": {
+        "Liver mRNA": [
+          [
+            "320",
+            "HLC_0311",
+            "GSE9588 Human Liver Normal (Mar11) Both Sexes"
+          ]
+        ],
+        "Phenotypes": [
+          [
+            "635",
+            "HLCPublish",
+            "HLC Published Phenotypes"
+          ]
+        ]
+      }
+    },
+    "mouse": {
+      "BXD": {
+        "Genotypes": [
+          [
+            "600",
+            "BXDGeno",
+            "BXD Genotypes"
+          ]
+        ],
+        "Hippocampus mRNA": [
+          [
+            "112",
+            "HC_M2_0606_P",
+            "Hippocampus Consortium M430v2 (Jun06) PDNN"
+          ]
+        ],
+        "Phenotypes": [
+          [
+            "602",
+            "BXDPublish",
+            "BXD Published Phenotypes"
+          ]
+        ]
+      }
+    }
+  },
+  "groups": {
+    "human": [
+      [
+        "HLC",
+        "Liver: Normal Gene Expression with Genotypes (Merck)",
+        "Family:None"
+      ]
+    ],
+    "mouse": [
+      [
+        "BXD",
+        "BXD",
+        "Family:None"
+      ]
+    ]
+  },
+  "species": [
+    [
+      "human",
+      "Human"
+    ],
+    [
+      "mouse",
+      "Mouse"
+    ]
+  ],
+  "types": {
+    "human": {
+      "HLC": [
+        [
+          "Phenotypes",
+          "Traits and Cofactors",
+          "Phenotypes"
+        ],
+        [
+          "Liver mRNA",
+          "Liver mRNA",
+          "Molecular Trait Datasets"
+        ]
+      ]
+    },
+    "mouse": {
+      "BXD": [
+        [
+          "Phenotypes",
+          "Traits and Cofactors",
+          "Phenotypes"
+        ],
+        [
+          "Genotypes",
+          "DNA Markers and SNPs",
+          "Genotypes"
+        ],
+        [
+          "Hippocampus mRNA",
+          "Hippocampus mRNA",
+          "Molecular Trait Datasets"
+        ]
+      ]
+    }
+  }
+}
+"""
diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 74799e49..835d786a 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -4,7 +4,7 @@ import unittest
 import mock
 
 from wqflask import app
-
+from data import gen_menu_json
 from base.data_set import DatasetType
 
 
@@ -43,3 +43,17 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(DatasetType(redis_mock)
                              ("All Phenotypes"), "Publish")
 
+    @mock.patch('base.data_set.requests.get')
+    def test_data_set_type_with_empty_redis(self, request_mock):
+        """Test that DatasetType returns correctly if the Redis Instance is empty and
+        the name variable exists in the dictionary
+
+        """
+        with app.app_context():
+            request_mock.return_value.content = gen_menu_json
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = None
+            data_set = DatasetType(redis_mock)
+            self.assertEqual(data_set("BXDGeno"), "Geno")
+            self.assertEqual(data_set("BXDPublish"), "Publish")
+            self.assertEqual(data_set("HLC_0311"), "ProbeSet")
-- 
cgit v1.2.3


From 957e05d33eb423df99181a99e7c25891810a21f7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 27 Jul 2020 15:06:02 +0300
Subject: Check that Redis is called correctly

* wqflask/tests/base/test_data_set.py: assert that `set` and `get` are called
correctly
---
 wqflask/tests/base/test_data_set.py | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 835d786a..3ac1b6d6 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -42,6 +42,7 @@ class TestDataSetTypes(unittest.TestCase):
             """
             self.assertEqual(DatasetType(redis_mock)
                              ("All Phenotypes"), "Publish")
+            redis_mock.get.assert_called_once_with("dataset_structure")
 
     @mock.patch('base.data_set.requests.get')
     def test_data_set_type_with_empty_redis(self, request_mock):
@@ -57,3 +58,6 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(data_set("BXDGeno"), "Geno")
             self.assertEqual(data_set("BXDPublish"), "Publish")
             self.assertEqual(data_set("HLC_0311"), "ProbeSet")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                '{"BXDGeno": "Geno", "BXDPublish": "Publish", "HLCPublish": "Publish", "HLC_0311": "ProbeSet", "HC_M2_0606_P": "ProbeSet"}')
-- 
cgit v1.2.3


From 79b8cf45c1c40b9c20278762b6e8f587a2820b43 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 27 Jul 2020 19:10:36 +0300
Subject: Test that non-existent keys in Dataset are set correctly

* wqflask/tests/base/test_data_set.py: Add more tests.
---
 wqflask/tests/base/test_data_set.py | 103 +++++++++++++++++++++++++++++++-----
 1 file changed, 90 insertions(+), 13 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 3ac1b6d6..94780a5d 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -12,6 +12,19 @@ class TestDataSetTypes(unittest.TestCase):
     """Tests for the DataSetType class"""
 
     def setUp(self):
+        self.test_dataset = """
+            {
+                "AD-cases-controls-MyersGeno": "Geno",
+                "AD-cases-controls-MyersPublish": "Publish",
+                "AKXDGeno": "Geno",
+                "AXBXAGeno": "Geno",
+                "AXBXAPublish": "Publish",
+                "Aging-Brain-UCIPublish": "Publish",
+                "All Phenotypes": "Publish",
+                "B139_K_1206_M": "ProbeSet",
+                "B139_K_1206_R": "ProbeSet"
+            }
+            """
         self.app_context = app.app_context()
         self.app_context.push()
 
@@ -27,19 +40,7 @@ class TestDataSetTypes(unittest.TestCase):
         with app.app_context():
             db_mock.get = mock.Mock()
             redis_mock = mock.Mock()
-            redis_mock.get.return_value = """
-            {
-                "AD-cases-controls-MyersGeno": "Geno",
-                "AD-cases-controls-MyersPublish": "Publish",
-                "AKXDGeno": "Geno",
-                "AXBXAGeno": "Geno",
-                "AXBXAPublish": "Publish",
-                "Aging-Brain-UCIPublish": "Publish",
-                "All Phenotypes": "Publish",
-                "B139_K_1206_M": "ProbeSet",
-                "B139_K_1206_R": "ProbeSet"
-            }
-            """
+            redis_mock.get.return_value = self.test_dataset
             self.assertEqual(DatasetType(redis_mock)
                              ("All Phenotypes"), "Publish")
             redis_mock.get.assert_called_once_with("dataset_structure")
@@ -61,3 +62,79 @@ class TestDataSetTypes(unittest.TestCase):
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
                 '{"BXDGeno": "Geno", "BXDPublish": "Publish", "HLCPublish": "Publish", "HLC_0311": "ProbeSet", "HC_M2_0606_P": "ProbeSet"}')
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_key_mrna(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("mrna_expr", "Test")
+            self.assertEqual(data_set("Test"), "ProbeSet")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "ProbeSet", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
+            expected_db_call = """"""
+            db_mock.db.execute.assert_called_with(
+                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
+                 "WHERE ProbeSetFreeze.Name = \"Test\" ")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_key_pheno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("pheno", "Test")
+            self.assertEqual(data_set("Test"), "Publish")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
+            expected_db_call = """"""
+            db_mock.db.execute.assert_called_with(
+                ("SELECT InfoFiles.GN_AccesionId " +
+                 "FROM InfoFiles, PublishFreeze, InbredSet " +
+                 "WHERE InbredSet.Name = 'Test' AND "
+                 "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+                 "InfoFiles.InfoPageName = PublishFreeze.Name")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_other_pheno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("other_pheno", "Test")
+            self.assertEqual(data_set("Test"), "Publish")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
+            expected_db_call = """"""
+            db_mock.db.execute.assert_called_with(
+                ("SELECT PublishFreeze.Name " +
+                 "FROM PublishFreeze, InbredSet " +
+                 "WHERE InbredSet.Name = 'Test' AND "
+                 "PublishFreeze.InbredSetId = InbredSet.Id")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_geno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("geno", "Test")
+            self.assertEqual(data_set("Test"), "Geno")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Geno", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
+            expected_db_call = """"""
+            db_mock.db.execute.assert_called_with(
+                ("SELECT GenoFreeze.Id FROM GenoFreeze WHERE GenoFreeze.Name = \"Test\" ")
+            )
-- 
cgit v1.2.3


From 7732204662bf395eb8ed55b6d26fd208998c1067 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 27 Jul 2020 19:48:16 +0300
Subject: Add unittests for WebqtlCaseData

* wqflask/tests/base/test_webqtl_case_data.py: Add it
---
 wqflask/tests/base/test_webqtl_case_data.py | 39 +++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 wqflask/tests/base/test_webqtl_case_data.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_webqtl_case_data.py b/wqflask/tests/base/test_webqtl_case_data.py
new file mode 100644
index 00000000..8e8ba482
--- /dev/null
+++ b/wqflask/tests/base/test_webqtl_case_data.py
@@ -0,0 +1,39 @@
+"""Tests for wqflask/base/webqtlCaseData.py"""
+import unittest
+
+from wqflask import app  # Required because of utility.tools in webqtlCaseData.py
+from base.webqtlCaseData import webqtlCaseData
+
+class TestWebqtlCaseData(unittest.TestCase):
+    """Tests for WebqtlCaseData class"""
+
+    def setUp(self):
+        self.w = webqtlCaseData(name="Test",
+                           value=0,
+                           variance=0.0,
+                           num_cases=10,
+                           name2="Test2")
+
+    def test_webqtl_case_data_repr(self):
+        self.assertEqual(
+            repr(self.w),
+            "<webqtlCaseData> value=0.000 variance=0.000 ndata=10 name=Test name2=Test2"
+        )
+
+    def test_class_outlier(self):
+        self.assertEqual(self.w.class_outlier, "")
+
+    def test_display_value(self):
+        self.assertEqual(self.w.display_value, "0.000")
+        self.w.value = None
+        self.assertEqual(self.w.display_value, "x")
+
+    def test_display_variance(self):
+        self.assertEqual(self.w.display_variance, "0.000")
+        self.w.variance = None
+        self.assertEqual(self.w.display_variance, "x")
+
+    def test_display_num_cases(self):
+        self.assertEqual(self.w.display_num_cases, "10")
+        self.w.num_cases = None
+        self.assertEqual(self.w.display_num_cases, "x")
-- 
cgit v1.2.3


From b55792f2daf648affe52d78c7f3a480f6550dfc8 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:09:21 +0300
Subject: Add initial gen_menu test

* wqflask/tests/api/__init__.py: Add it
* wqflask/tests/api/test_gen_menu.py: Add test for get_species
---
 wqflask/tests/api/__init__.py      |  0
 wqflask/tests/api/test_gen_menu.py | 19 +++++++++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 wqflask/tests/api/__init__.py
 create mode 100644 wqflask/tests/api/test_gen_menu.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/__init__.py b/wqflask/tests/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
new file mode 100644
index 00000000..81908129
--- /dev/null
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -0,0 +1,19 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+import mock
+
+from wqflask.api.gen_menu import get_species
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for the gen_menu module"""
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_species(self, db_mock):
+        """Test that assertion is raised when dataset and dataset_name are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (('human', 'Human'),
+                                                                 ('mouse', 'Mouse'))
+        self.assertEqual(get_species(),
+                         [['human', 'Human'], ['mouse', 'Mouse']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
+        )
-- 
cgit v1.2.3


From 3425e7a5dbf5a6983424659c05c258e7a132edf3 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:19:13 +0300
Subject: Add test for "get_groups"

* wqflask/tests/api/test_gen_menu.py: test that "get_groups" uses the correct
sql query and returns the correct group data structure.
---
 wqflask/tests/api/test_gen_menu.py | 45 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 81908129..a2a93da7 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -3,10 +3,28 @@ import unittest
 import mock
 
 from wqflask.api.gen_menu import get_species
+from wqflask.api.gen_menu import get_groups
+
 
 class TestGenMenu(unittest.TestCase):
     """Tests for the gen_menu module"""
 
+    def setUp(self):
+        self.test_group = {
+            'mouse': [
+                ['H_T1',
+                 'H_T',
+                 'Family:DescriptionA'
+                 ],
+                ['H_T2', "H_T'", 'Family:None']
+            ],
+            'human': [
+                ['BXD', 'BXD', 'Family:None'],
+                ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+                 'Family:Test']
+            ]
+        }
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
         """Test that assertion is raised when dataset and dataset_name are defined"""
@@ -17,3 +35,30 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.assert_called_once_with(
             "SELECT Name, MenuName FROM Species ORDER BY OrderId"
         )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_groups(self, db_mock):
+        """Test that species groups are grouped correctly"""
+        db_mock.db.execute.return_value.fetchall.side_effect = [
+            # Mouse
+            (('BXD', 'BXD', None),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)', 'Test')),
+            # Human
+            (('H_T1', "H_T", "DescriptionA"),
+             ('H_T2', "H_T'", None))
+        ]
+
+        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
+                         self.test_group)
+
+        for name in ["mouse", "human"]:
+            db_mock.db.execute.assert_any_call(
+                ("SELECT InbredSet.Name, InbredSet.FullName, " +
+                 "IFNULL(InbredSet.Family, 'None') " +
+                 "FROM InbredSet, Species WHERE Species.Name " +
+                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
+                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
+                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
+                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
+                 "InbredSet.MenuOrderId ASC").format(name)
+            )
-- 
cgit v1.2.3


From d50f72869b8d0a7078f0481aad2b04346cd56e3f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 29 Jul 2020 22:28:38 +0300
Subject: Add tests for "phenotypes_exist" and "genotypes_exist"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index a2a93da7..be66a4c6 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -4,6 +4,8 @@ import mock
 
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import phenotypes_exist
+from wqflask.api.gen_menu import genotypes_exist
 
 
 class TestGenMenu(unittest.TestCase):
@@ -62,3 +64,50 @@ class TestGenMenu(unittest.TestCase):
                  "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
                  "InbredSet.MenuOrderId ASC").format(name)
             )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that phenotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        phenotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM PublishFreeze WHERE PublishFreeze.Name = 'testPublish'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_falsy_values(self, db_mock):
+        """Test that phenotype check returns correctly when given a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_truthy_value(self, db_mock):
+        """Test that phenotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that genotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        genotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_falsy_values(self, db_mock):
+        """Test that genotype check returns correctly when given a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(genotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_truthy_value(self, db_mock):
+        """Test that genotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
-- 
cgit v1.2.3


From 99fae55d98e7042e0caf29c34fb77ee17efaafa2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 30 Jul 2020 16:13:39 +0300
Subject: Add tests for "build_datasets"

* wqflask/tests/api/test_gen_menu.py: Add new tests for "build_datasets"
function
---
 wqflask/tests/api/test_gen_menu.py | 66 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index be66a4c6..ec380b6f 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -6,6 +6,7 @@ from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
+from wqflask.api.gen_menu import build_datasets
 
 
 class TestGenMenu(unittest.TestCase):
@@ -111,3 +112,68 @@ class TestGenMenu(unittest.TestCase):
             db_mock.db.execute.return_value.fetchone.return_value = (x)
             self.assertTrue(phenotypes_exist("test"))
 
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (602, "BXDPublish", "BXD Published Phenotypes"),
+        )
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
+            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
+            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
+            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = PublishFreeze.Name " +
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [['602', "BXDPublish", "Mouse Phenome Database"]])
+
+        db_mock.db.execute.return_value.fetchall.return_value = ()
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            "BXDPublish", "Mouse Phenome Database"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [["None", "BXDPublish", "Mouse Phenome Database"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_genotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            635, "HLCPublish", "HLC Published Genotypes"
+        )
+
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["635", "HLCGeno", "HLC Genotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, GenoFreeze, InbredSet " +
+            "WHERE InbredSet.Name = 'HLC' AND GenoFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
+            "ORDER BY GenoFreeze.CreateTime DESC"
+        )
+        db_mock.db.execute.return_value.fetchone.return_value = ()
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["None", "HLCGeno", "HLC Genotypes"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_mrna(self, db_mock):
+        """Test that correct dataset is returned for a mRNA expression/ Probeset"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (112, "HC_M2_0606_P",
+             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
+            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
+        ]])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
+            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
+            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
+            "Species.Name = 'Mouse' AND Species.Id = " +
+            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
+            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
+            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
+            "ORDER BY ProbeSetFreeze.CreateTime DESC")
-- 
cgit v1.2.3


From 61634e932f8e03f5f53a94a56ff23f50dba891d2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 11:24:40 +0300
Subject: Add test for "build_types"

* wqflask/tests/api/test_gen_menu.py: New test
---
 wqflask/tests/api/test_gen_menu.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index ec380b6f..24899765 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -7,6 +7,7 @@ from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
 from wqflask.api.gen_menu import build_datasets
+from wqflask.api.gen_menu import build_types
 
 
 class TestGenMenu(unittest.TestCase):
@@ -177,3 +178,29 @@ class TestGenMenu(unittest.TestCase):
             "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
             "ORDER BY ProbeSetFreeze.CreateTime DESC")
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_types(self, db_mock, datasets_mock):
+        """Test that correct tissue metadata is returned"""
+        datasets_mock.return_value = [
+            ["112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+        ]
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+        )
+        self.assertEqual(build_types('mouse', 'random group'),
+                         [['M', 'M', 'Molecular Trait Datasets'],
+                          ['H', 'H', 'Molecular Trait Datasets'],
+                          ['R', 'R', 'Molecular Trait Datasets']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT DISTINCT Tissue.Name " +
+            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
+            "Tissue, Species WHERE Species.Name = 'mouse' " +
+            "AND Species.Id = InbredSet.SpeciesId AND " +
+            "InbredSet.Name = 'random group' AND " +
+            "ProbeFreeze.TissueId = Tissue.Id AND " +
+            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+            "ORDER BY Tissue.Name"
+        )
-- 
cgit v1.2.3


From bde13316e67bb56eb4a00b365ebb343ab6d00274 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 13:10:31 +0300
Subject: Add tests for "get_types"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 105 +++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 24899765..0379e297 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -4,6 +4,7 @@ import mock
 
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import get_types
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
 from wqflask.api.gen_menu import build_datasets
@@ -204,3 +205,107 @@ class TestGenMenu(unittest.TestCase):
             "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
             "ORDER BY Tissue.Name"
         )
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_existing_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes and genotypes
+        exist
+
+        """
+        phenotypes_exist_mock.return_value = True
+        genotypes_exist_mock.return_value = True
+
+        expected_result = {
+            'mouse': {
+                'H_T2': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']]
+            },
+            'human': {
+                'HLC': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']]
+            }
+        }
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        self.assertEqual(get_types(self.test_group), expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist and
+        genotypes_exist are false but build_type is falsy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = []
+        self.assertEqual(get_types(self.test_group), {
+            'mouse': {},
+            'human': {}
+        })
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist,
+        genotypes_exist and build_types are truthy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        expected_result = {
+            'mouse': {
+                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
+            'human': {
+                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
+        self.assertEqual(get_types(self.test_group),
+                         expected_result)
-- 
cgit v1.2.3


From 899cf35a1dce7ad18645d00238fb39917f8e6e4f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 15:55:32 +0300
Subject: Add tests for "get_datasets"

* wqflask/tests/api/test_gen_menu.py: Add new tests
---
 wqflask/tests/api/test_gen_menu.py | 74 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 0379e297..a606a300 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -5,6 +5,7 @@ import mock
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import get_types
+from wqflask.api.gen_menu import get_datasets
 from wqflask.api.gen_menu import phenotypes_exist
 from wqflask.api.gen_menu import genotypes_exist
 from wqflask.api.gen_menu import build_datasets
@@ -30,6 +31,41 @@ class TestGenMenu(unittest.TestCase):
             ]
         }
 
+        self.test_type = {
+            'mouse': {
+                'H_T2': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']]
+            },
+            'human': {
+                'HLC': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']]
+            }
+        }
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
         """Test that assertion is raised when dataset and dataset_name are defined"""
@@ -309,3 +345,41 @@ class TestGenMenu(unittest.TestCase):
                 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
         self.assertEqual(get_types(self.test_group),
                          expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_existent_datasets(self,
+                                                 build_datasets_mock):
+        """Test correct dataset is returned with existent build_datasets"""
+        build_datasets_mock.return_value = "Test"
+        expected_result = {
+            'mouse': {
+                'H_T2': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'},
+                'H_T1': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'}},
+            'human': {'HLC': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'},
+                      'BXD': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'}}}
+        self.maxDiff = None
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_non_existent_datasets(self,
+                                                     build_datasets_mock):
+        """Test correct dataset is returned with non-existent build_datasets"""
+        build_datasets_mock.return_value = None
+        expected_result = {
+            'mouse': {
+                'H_T2': {},
+                'H_T1': {}},
+            'human': {'HLC': {},
+                      'BXD': {}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
-- 
cgit v1.2.3


From 452f5442fec13afce07997494adc46fb4bbee9d7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:07:08 +0300
Subject: Add test for "gen_dropdown_json"

* wqflask/tests/api/test_gen_menu.py: Add new test
---
 wqflask/tests/api/test_gen_menu.py | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index a606a300..92485d38 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -2,6 +2,7 @@
 import unittest
 import mock
 
+from wqflask.api.gen_menu import gen_dropdown_json
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import get_types
@@ -383,3 +384,31 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(get_datasets(self.test_type),
                          expected_result)
 
+    @mock.patch('wqflask.api.gen_menu.get_datasets')
+    @mock.patch('wqflask.api.gen_menu.get_types')
+    @mock.patch('wqflask.api.gen_menu.get_groups')
+    @mock.patch('wqflask.api.gen_menu.get_species')
+    def test_gen_dropdown_json(self,
+                               species_mock,
+                               groups_mock,
+                               types_mock,
+                               datasets_mock):
+        "Test that the correct dictionary is constructed properly"
+        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
+                                     .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+        groups_mock.return_value = ("groupA groupB groupC groupD"
+                                    .split(" "))
+        types_mock.return_value = ("typeA typeB typeC typeD"
+                                   .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+
+        expected_result = {
+            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
+            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
+            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
+            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
+
+        self.assertEqual(gen_dropdown_json(), expected_result)
-- 
cgit v1.2.3


From 30341891c22e2161c1217f808ed05748c91036e2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:46:33 +0300
Subject: Move variable to setUp

* wqflask/tests/api/test_gen_menu.py: Move variable
---
 wqflask/tests/api/test_gen_menu.py | 35 +----------------------------------
 1 file changed, 1 insertion(+), 34 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 92485d38..ca841708 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -258,40 +258,7 @@ class TestGenMenu(unittest.TestCase):
         phenotypes_exist_mock.return_value = True
         genotypes_exist_mock.return_value = True
 
-        expected_result = {
-            'mouse': {
-                'H_T2': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']],
-                'H_T1': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']]
-            },
-            'human': {
-                'HLC': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']],
-                'BXD': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']]
-            }
-        }
+        expected_result = self.test_type
 
         build_types_mock.return_value = [
             ['M', 'M', 'Molecular Trait Datasets']
-- 
cgit v1.2.3


From 77a55f3cfe70dfbe319c28380eb16a4f9516366c Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:47:42 +0300
Subject: Add extra test for "build_datasets"

* wqflask/tests/api/test_gen_menu.py: Add test.
---
 wqflask/tests/api/test_gen_menu.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index ca841708..4a928d12 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -178,6 +178,25 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
                          [["None", "BXDPublish", "Mouse Phenome Database"]])
 
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type with no
+        results
+
+        """
+        db_mock.db.execute.return_value.fetchall.return_value = None
+        db_mock.db.execute.return_value.fetchone.return_value = (121,
+                                                                 "text value")
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [["None", "121", "text value"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+            "FROM PublishFreeze, InbredSet "
+            "WHERE InbredSet.Name = 'BXD' AND "
+            "PublishFreeze.InbredSetId = InbredSet.Id "
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_genotypes(self, db_mock):
         """Test that correct dataset is returned for a phenotype type"""
-- 
cgit v1.2.3


From 8fa2d7cc9d3d6599d1c44a6f5e76decf932b2cbd Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 3 Aug 2020 16:54:57 +0300
Subject: Fix some errors generated by running pylint

* wqflask/wqflask/api/gen_menu.py: Apply pylint.
* wqflask/tests/api/test_gen_menu.py: Apply pylint.
---
 wqflask/tests/api/test_gen_menu.py | 33 +++++++++------
 wqflask/wqflask/api/gen_menu.py    | 83 +++++++++++++++++++++-----------------
 2 files changed, 66 insertions(+), 50 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
index 4a928d12..79c77fec 100644
--- a/wqflask/tests/api/test_gen_menu.py
+++ b/wqflask/tests/api/test_gen_menu.py
@@ -69,9 +69,11 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
-        """Test that assertion is raised when dataset and dataset_name are defined"""
-        db_mock.db.execute.return_value.fetchall.return_value = (('human', 'Human'),
-                                                                 ('mouse', 'Mouse'))
+        """Test that assertion is raised when dataset and dataset_name
+        are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('human', 'Human'),
+            ('mouse', 'Mouse'))
         self.assertEqual(get_species(),
                          [['human', 'Human'], ['mouse', 'Mouse']])
         db_mock.db.execute.assert_called_once_with(
@@ -84,7 +86,8 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.return_value.fetchall.side_effect = [
             # Mouse
             (('BXD', 'BXD', None),
-             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)', 'Test')),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+              'Test')),
             # Human
             (('H_T1', "H_T", "DescriptionA"),
              ('H_T2', "H_T'", None))
@@ -111,12 +114,14 @@ class TestGenMenu(unittest.TestCase):
         db_mock.db.execute.return_value.fetchone.return_value = None
         phenotypes_exist("test")
         db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM PublishFreeze WHERE PublishFreeze.Name = 'testPublish'"
+            "SELECT Name FROM PublishFreeze "
+            "WHERE PublishFreeze.Name = 'testPublish'"
         )
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_phenotypes_exist_with_falsy_values(self, db_mock):
-        """Test that phenotype check returns correctly when given a None value"""
+        """Test that phenotype check returns correctly when given
+        a None value"""
         for x in [None, False, (), [], ""]:
             db_mock.db.execute.return_value.fetchone.return_value = x
             self.assertFalse(phenotypes_exist("test"))
@@ -139,7 +144,8 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_genotypes_exist_with_falsy_values(self, db_mock):
-        """Test that genotype check returns correctly when given a None value"""
+        """Test that genotype check returns correctly when given
+        a None value"""
         for x in [None, False, (), [], ""]:
             db_mock.db.execute.return_value.fetchone.return_value = x
             self.assertFalse(genotypes_exist("test"))
@@ -151,7 +157,6 @@ class TestGenMenu(unittest.TestCase):
             db_mock.db.execute.return_value.fetchone.return_value = (x)
             self.assertTrue(phenotypes_exist("test"))
 
-
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_phenotypes(self, db_mock):
         """Test that correct dataset is returned for a phenotype type"""
@@ -207,8 +212,9 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
                          [["635", "HLCGeno", "HLC Genotypes"]])
         db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, GenoFreeze, InbredSet " +
-            "WHERE InbredSet.Name = 'HLC' AND GenoFreeze.InbredSetId = InbredSet.Id AND " +
+            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
+            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
+            "GenoFreeze.InbredSetId = InbredSet.Id AND "
             "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
             "ORDER BY GenoFreeze.CreateTime DESC"
         )
@@ -218,7 +224,8 @@ class TestGenMenu(unittest.TestCase):
 
     @mock.patch('wqflask.api.gen_menu.g')
     def test_build_datasets_with_type_mrna(self, db_mock):
-        """Test that correct dataset is returned for a mRNA expression/ Probeset"""
+        """Test that correct dataset is returned for a mRNA
+        expression/ Probeset"""
         db_mock.db.execute.return_value.fetchall.return_value = (
             (112, "HC_M2_0606_P",
              "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
@@ -241,7 +248,8 @@ class TestGenMenu(unittest.TestCase):
     def test_build_types(self, db_mock, datasets_mock):
         """Test that correct tissue metadata is returned"""
         datasets_mock.return_value = [
-            ["112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+            ["112", 'HC_M2_0606_P',
+                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
         ]
         db_mock.db.execute.return_value.fetchall.return_value = (
             ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
@@ -352,7 +360,6 @@ class TestGenMenu(unittest.TestCase):
                       'BXD': {'Genotypes': 'Test',
                               'M': 'Test',
                               'Phenotypes': 'Test'}}}
-        self.maxDiff = None
         self.assertEqual(get_datasets(self.test_type),
                          expected_result)
 
diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 82c5d9be..45814ed9 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -1,21 +1,12 @@
 from __future__ import print_function, division
 
-import sys
-
 from flask import g
 
-from utility.tools import locate, locate_ignore_error, TEMPDIR, SQL_URI
-from utility.benchmark import Bench
-
-import MySQLdb
-
-import urlparse
-
-import utility.logger
-logger = utility.logger.getLogger(__name__ )
 
 def gen_dropdown_json():
-    """Generates and outputs (as json file) the data for the main dropdown menus on the home page"""
+    """Generates and outputs (as json file) the data for the main dropdown menus on
+    the home page
+    """
 
     species = get_species()
     groups = get_groups(species)
@@ -29,9 +20,11 @@ def gen_dropdown_json():
 
     return data
 
+
 def get_species():
     """Build species list"""
-    results = g.db.execute("SELECT Name, MenuName FROM Species ORDER BY OrderId").fetchall()
+    results = g.db.execute(
+        "SELECT Name, MenuName FROM Species ORDER BY OrderId").fetchall()
 
     species = []
     for result in results:
@@ -39,6 +32,7 @@ def get_species():
 
     return species
 
+
 def get_groups(species):
     """Build groups list"""
     groups = {}
@@ -46,18 +40,23 @@ def get_groups(species):
         groups[species_name] = []
 
         results = g.db.execute(
-            ("SELECT InbredSet.Name, InbredSet.FullName, IFNULL(InbredSet.Family, 'None') " +
-             "FROM InbredSet, Species WHERE Species.Name = '{}' AND InbredSet.SpeciesId = " +
-             "Species.Id GROUP by InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
-             "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, InbredSet.FullName) ASC, " +
-             "InbredSet.FullName ASC, InbredSet.MenuOrderId ASC").format(species_name)).fetchall()
+            ("SELECT InbredSet.Name, InbredSet.FullName, "
+             "IFNULL(InbredSet.Family, 'None') "
+             "FROM InbredSet, Species WHERE Species.Name = '{}' "
+             "AND InbredSet.SpeciesId = Species.Id GROUP by InbredSet.Name "
+             "ORDER BY IFNULL(InbredSet.FamilyOrder, InbredSet.FullName) "
+             "ASC, IFNULL(InbredSet.Family, InbredSet.FullName) ASC, "
+             "InbredSet.FullName ASC, InbredSet.MenuOrderId ASC")
+            .format(species_name)).fetchall()
 
         for result in results:
             family_name = "Family:" + str(result[2])
-            groups[species_name].append([str(result[0]), str(result[1]), family_name])
+            groups[species_name].append(
+                [str(result[0]), str(result[1]), family_name])
 
     return groups
 
+
 def get_types(groups):
     """Build types list"""
     types = {}
@@ -66,12 +65,15 @@ def get_types(groups):
         types[species] = {}
         for group_name, _group_full_name, _family_name in group_dict:
             if phenotypes_exist(group_name):
-                types[species][group_name] = [("Phenotypes", "Traits and Cofactors", "Phenotypes")]
+                types[species][group_name] = [
+                    ("Phenotypes", "Traits and Cofactors", "Phenotypes")]
             if genotypes_exist(group_name):
                 if group_name in types[species]:
-                    types[species][group_name] += [("Genotypes", "DNA Markers and SNPs", "Genotypes")]
+                    types[species][group_name] += [
+                        ("Genotypes", "DNA Markers and SNPs", "Genotypes")]
                 else:
-                    types[species][group_name] = [("Genotypes", "DNA Markers and SNPs", "Genotypes")]
+                    types[species][group_name] = [
+                        ("Genotypes", "DNA Markers and SNPs", "Genotypes")]
             if group_name in types[species]:
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
@@ -82,13 +84,17 @@ def get_types(groups):
                     types[species][group_name] = types_list
                 else:
                     types[species].pop(group_name, None)
-                    groups[species] = list(group for group in groups[species] if group[0] != group_name)
+                    groups[species] = list(
+                        group for group in groups[species]
+                        if group[0] != group_name)
     return types
 
+
 def phenotypes_exist(group_name):
     results = g.db.execute(
-        ("SELECT Name FROM PublishFreeze " +
-         "WHERE PublishFreeze.Name = '{}'").format(group_name+"Publish")).fetchone()
+        ("SELECT Name FROM PublishFreeze "
+         "WHERE PublishFreeze.Name = "
+         "'{}'").format(group_name+"Publish")).fetchone()
     return bool(results)
 
 
@@ -118,13 +124,15 @@ def build_types(species, group):
 
     results = []
     for result in g.db.execute(query).fetchall():
-        if len(result):
+        if bool(result):
             these_datasets = build_datasets(species, group, result[0])
             if len(these_datasets) > 0:
-                results.append([str(result[0]), str(result[0]), "Molecular Trait Datasets"])
+                results.append([str(result[0]), str(result[0]),
+                                "Molecular Trait Datasets"])
 
     return results
 
+
 def get_datasets(types):
     """Build datasets list"""
     datasets = {}
@@ -192,17 +200,18 @@ def build_datasets(species, group, type_name):
         dataset_text = "%s Genotypes" % group
         datasets.append([dataset_id, dataset_value, dataset_text])
 
-    else: # for mRNA expression/ProbeSet
+    else:  # for mRNA expression/ProbeSet
         results = g.db.execute(
-            ("SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
-             "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
-             "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
-             "Species.Name = '{0}' AND Species.Id = " +
-             "InbredSet.SpeciesId AND InbredSet.Name = '{1}' " +
-             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
-             "and Tissue.Name = '{2}' AND ProbeFreeze.TissueId = " +
-             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-             "ORDER BY ProbeSetFreeze.CreateTime DESC").format(species, group, type_name)).fetchall()
+            ("SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
+             "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
+             "ProbeFreeze, InbredSet, Tissue, Species WHERE "
+             "Species.Name = '{0}' AND Species.Id = "
+             "InbredSet.SpeciesId AND InbredSet.Name = '{1}' "
+             "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
+             "and Tissue.Name = '{2}' AND ProbeFreeze.TissueId = "
+             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id "
+             "ORDER BY ProbeSetFreeze.CreateTime "
+             "DESC").format(species, group, type_name)).fetchall()
 
         datasets = []
         for dataset_info in results:
-- 
cgit v1.2.3


From abbceb6cde72282b8b85e9452d45e3d6ecc41da5 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 7 Aug 2020 15:07:52 +0300
Subject: Move wqflask/tests/api to wqflask/tests/wqflask

* wqflask/tests(api): Move all the files here to tests/wqflask. The test dir
should mirror the actual module structure
---
 wqflask/tests/api/__init__.py              |   0
 wqflask/tests/api/test_gen_menu.py         | 407 -----------------------------
 wqflask/tests/wqflask/__init__.py          |   0
 wqflask/tests/wqflask/api/__init__.py      |   0
 wqflask/tests/wqflask/api/test_gen_menu.py | 407 +++++++++++++++++++++++++++++
 5 files changed, 407 insertions(+), 407 deletions(-)
 delete mode 100644 wqflask/tests/api/__init__.py
 delete mode 100644 wqflask/tests/api/test_gen_menu.py
 create mode 100644 wqflask/tests/wqflask/__init__.py
 create mode 100644 wqflask/tests/wqflask/api/__init__.py
 create mode 100644 wqflask/tests/wqflask/api/test_gen_menu.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/api/__init__.py b/wqflask/tests/api/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/api/test_gen_menu.py b/wqflask/tests/api/test_gen_menu.py
deleted file mode 100644
index 79c77fec..00000000
--- a/wqflask/tests/api/test_gen_menu.py
+++ /dev/null
@@ -1,407 +0,0 @@
-"""Test cases for wqflask.api.gen_menu"""
-import unittest
-import mock
-
-from wqflask.api.gen_menu import gen_dropdown_json
-from wqflask.api.gen_menu import get_species
-from wqflask.api.gen_menu import get_groups
-from wqflask.api.gen_menu import get_types
-from wqflask.api.gen_menu import get_datasets
-from wqflask.api.gen_menu import phenotypes_exist
-from wqflask.api.gen_menu import genotypes_exist
-from wqflask.api.gen_menu import build_datasets
-from wqflask.api.gen_menu import build_types
-
-
-class TestGenMenu(unittest.TestCase):
-    """Tests for the gen_menu module"""
-
-    def setUp(self):
-        self.test_group = {
-            'mouse': [
-                ['H_T1',
-                 'H_T',
-                 'Family:DescriptionA'
-                 ],
-                ['H_T2', "H_T'", 'Family:None']
-            ],
-            'human': [
-                ['BXD', 'BXD', 'Family:None'],
-                ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
-                 'Family:Test']
-            ]
-        }
-
-        self.test_type = {
-            'mouse': {
-                'H_T2': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']],
-                'H_T1': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']]
-            },
-            'human': {
-                'HLC': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']],
-                'BXD': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']]
-            }
-        }
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_species(self, db_mock):
-        """Test that assertion is raised when dataset and dataset_name
-        are defined"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('human', 'Human'),
-            ('mouse', 'Mouse'))
-        self.assertEqual(get_species(),
-                         [['human', 'Human'], ['mouse', 'Mouse']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_groups(self, db_mock):
-        """Test that species groups are grouped correctly"""
-        db_mock.db.execute.return_value.fetchall.side_effect = [
-            # Mouse
-            (('BXD', 'BXD', None),
-             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
-              'Test')),
-            # Human
-            (('H_T1', "H_T", "DescriptionA"),
-             ('H_T2', "H_T'", None))
-        ]
-
-        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
-                         self.test_group)
-
-        for name in ["mouse", "human"]:
-            db_mock.db.execute.assert_any_call(
-                ("SELECT InbredSet.Name, InbredSet.FullName, " +
-                 "IFNULL(InbredSet.Family, 'None') " +
-                 "FROM InbredSet, Species WHERE Species.Name " +
-                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
-                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
-                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
-                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
-                 "InbredSet.MenuOrderId ASC").format(name)
-            )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
-        """Test that phenotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        phenotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM PublishFreeze "
-            "WHERE PublishFreeze.Name = 'testPublish'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_falsy_values(self, db_mock):
-        """Test that phenotype check returns correctly when given
-        a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_truthy_value(self, db_mock):
-        """Test that phenotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_called_with_correct_query(self, db_mock):
-        """Test that genotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        genotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_falsy_values(self, db_mock):
-        """Test that genotype check returns correctly when given
-        a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(genotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_truthy_value(self, db_mock):
-        """Test that genotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (602, "BXDPublish", "BXD Published Phenotypes"),
-        )
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
-            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
-            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
-            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
-            "InfoFiles.InfoPageName = PublishFreeze.Name " +
-            "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [['602', "BXDPublish", "Mouse Phenome Database"]])
-
-        db_mock.db.execute.return_value.fetchall.return_value = ()
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            "BXDPublish", "Mouse Phenome Database"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [["None", "BXDPublish", "Mouse Phenome Database"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type with no
-        results
-
-        """
-        db_mock.db.execute.return_value.fetchall.return_value = None
-        db_mock.db.execute.return_value.fetchone.return_value = (121,
-                                                                 "text value")
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [["None", "121", "text value"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
-            "FROM PublishFreeze, InbredSet "
-            "WHERE InbredSet.Name = 'BXD' AND "
-            "PublishFreeze.InbredSetId = InbredSet.Id "
-            "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_genotypes(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            635, "HLCPublish", "HLC Published Genotypes"
-        )
-
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["635", "HLCGeno", "HLC Genotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
-            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
-            "GenoFreeze.InbredSetId = InbredSet.Id AND "
-            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
-            "ORDER BY GenoFreeze.CreateTime DESC"
-        )
-        db_mock.db.execute.return_value.fetchone.return_value = ()
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["None", "HLCGeno", "HLC Genotypes"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_mrna(self, db_mock):
-        """Test that correct dataset is returned for a mRNA
-        expression/ Probeset"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (112, "HC_M2_0606_P",
-             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
-        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
-            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
-        ]])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
-            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
-            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
-            "Species.Name = 'Mouse' AND Species.Id = " +
-            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
-            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
-            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-            "ORDER BY ProbeSetFreeze.CreateTime DESC")
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_types(self, db_mock, datasets_mock):
-        """Test that correct tissue metadata is returned"""
-        datasets_mock.return_value = [
-            ["112", 'HC_M2_0606_P',
-                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
-        ]
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
-        )
-        self.assertEqual(build_types('mouse', 'random group'),
-                         [['M', 'M', 'Molecular Trait Datasets'],
-                          ['H', 'H', 'Molecular Trait Datasets'],
-                          ['R', 'R', 'Molecular Trait Datasets']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT DISTINCT Tissue.Name " +
-            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
-            "Tissue, Species WHERE Species.Name = 'mouse' " +
-            "AND Species.Id = InbredSet.SpeciesId AND " +
-            "InbredSet.Name = 'random group' AND " +
-            "ProbeFreeze.TissueId = Tissue.Id AND " +
-            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
-            "ORDER BY Tissue.Name"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_existing_genotype_and_phenotypes(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes and genotypes
-        exist
-
-        """
-        phenotypes_exist_mock.return_value = True
-        genotypes_exist_mock.return_value = True
-
-        expected_result = self.test_type
-
-        build_types_mock.return_value = [
-            ['M', 'M', 'Molecular Trait Datasets']
-        ]
-        self.assertEqual(get_types(self.test_group), expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes_exist and
-        genotypes_exist are false but build_type is falsy
-
-        """
-        phenotypes_exist_mock.return_value = False
-        genotypes_exist_mock.return_value = False
-
-        build_types_mock.return_value = []
-        self.assertEqual(get_types(self.test_group), {
-            'mouse': {},
-            'human': {}
-        })
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes_exist,
-        genotypes_exist and build_types are truthy
-
-        """
-        phenotypes_exist_mock.return_value = False
-        genotypes_exist_mock.return_value = False
-
-        build_types_mock.return_value = [
-            ['M', 'M', 'Molecular Trait Datasets']
-        ]
-        expected_result = {
-            'mouse': {
-                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
-                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
-            'human': {
-                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
-                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
-        self.assertEqual(get_types(self.test_group),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    def test_get_datasets_with_existent_datasets(self,
-                                                 build_datasets_mock):
-        """Test correct dataset is returned with existent build_datasets"""
-        build_datasets_mock.return_value = "Test"
-        expected_result = {
-            'mouse': {
-                'H_T2': {'Genotypes': 'Test',
-                         'M': 'Test',
-                         'Phenotypes': 'Test'},
-                'H_T1': {'Genotypes': 'Test',
-                         'M': 'Test',
-                         'Phenotypes': 'Test'}},
-            'human': {'HLC': {'Genotypes': 'Test',
-                              'M': 'Test',
-                              'Phenotypes': 'Test'},
-                      'BXD': {'Genotypes': 'Test',
-                              'M': 'Test',
-                              'Phenotypes': 'Test'}}}
-        self.assertEqual(get_datasets(self.test_type),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    def test_get_datasets_with_non_existent_datasets(self,
-                                                     build_datasets_mock):
-        """Test correct dataset is returned with non-existent build_datasets"""
-        build_datasets_mock.return_value = None
-        expected_result = {
-            'mouse': {
-                'H_T2': {},
-                'H_T1': {}},
-            'human': {'HLC': {},
-                      'BXD': {}}}
-        self.assertEqual(get_datasets(self.test_type),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.get_datasets')
-    @mock.patch('wqflask.api.gen_menu.get_types')
-    @mock.patch('wqflask.api.gen_menu.get_groups')
-    @mock.patch('wqflask.api.gen_menu.get_species')
-    def test_gen_dropdown_json(self,
-                               species_mock,
-                               groups_mock,
-                               types_mock,
-                               datasets_mock):
-        "Test that the correct dictionary is constructed properly"
-        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
-                                     .split(" "))
-        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
-                                      .split(" "))
-        groups_mock.return_value = ("groupA groupB groupC groupD"
-                                    .split(" "))
-        types_mock.return_value = ("typeA typeB typeC typeD"
-                                   .split(" "))
-        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
-                                      .split(" "))
-
-        expected_result = {
-            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
-            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
-            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
-            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
-
-        self.assertEqual(gen_dropdown_json(), expected_result)
diff --git a/wqflask/tests/wqflask/__init__.py b/wqflask/tests/wqflask/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/wqflask/api/__init__.py b/wqflask/tests/wqflask/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/wqflask/api/test_gen_menu.py b/wqflask/tests/wqflask/api/test_gen_menu.py
new file mode 100644
index 00000000..79c77fec
--- /dev/null
+++ b/wqflask/tests/wqflask/api/test_gen_menu.py
@@ -0,0 +1,407 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+import mock
+
+from wqflask.api.gen_menu import gen_dropdown_json
+from wqflask.api.gen_menu import get_species
+from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import get_types
+from wqflask.api.gen_menu import get_datasets
+from wqflask.api.gen_menu import phenotypes_exist
+from wqflask.api.gen_menu import genotypes_exist
+from wqflask.api.gen_menu import build_datasets
+from wqflask.api.gen_menu import build_types
+
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for the gen_menu module"""
+
+    def setUp(self):
+        self.test_group = {
+            'mouse': [
+                ['H_T1',
+                 'H_T',
+                 'Family:DescriptionA'
+                 ],
+                ['H_T2', "H_T'", 'Family:None']
+            ],
+            'human': [
+                ['BXD', 'BXD', 'Family:None'],
+                ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+                 'Family:Test']
+            ]
+        }
+
+        self.test_type = {
+            'mouse': {
+                'H_T2': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']]
+            },
+            'human': {
+                'HLC': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']]
+            }
+        }
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_species(self, db_mock):
+        """Test that assertion is raised when dataset and dataset_name
+        are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('human', 'Human'),
+            ('mouse', 'Mouse'))
+        self.assertEqual(get_species(),
+                         [['human', 'Human'], ['mouse', 'Mouse']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_groups(self, db_mock):
+        """Test that species groups are grouped correctly"""
+        db_mock.db.execute.return_value.fetchall.side_effect = [
+            # Mouse
+            (('BXD', 'BXD', None),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+              'Test')),
+            # Human
+            (('H_T1', "H_T", "DescriptionA"),
+             ('H_T2', "H_T'", None))
+        ]
+
+        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
+                         self.test_group)
+
+        for name in ["mouse", "human"]:
+            db_mock.db.execute.assert_any_call(
+                ("SELECT InbredSet.Name, InbredSet.FullName, " +
+                 "IFNULL(InbredSet.Family, 'None') " +
+                 "FROM InbredSet, Species WHERE Species.Name " +
+                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
+                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
+                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
+                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
+                 "InbredSet.MenuOrderId ASC").format(name)
+            )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that phenotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        phenotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM PublishFreeze "
+            "WHERE PublishFreeze.Name = 'testPublish'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_falsy_values(self, db_mock):
+        """Test that phenotype check returns correctly when given
+        a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_truthy_value(self, db_mock):
+        """Test that phenotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that genotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        genotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_falsy_values(self, db_mock):
+        """Test that genotype check returns correctly when given
+        a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(genotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_truthy_value(self, db_mock):
+        """Test that genotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (602, "BXDPublish", "BXD Published Phenotypes"),
+        )
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
+            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
+            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
+            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = PublishFreeze.Name " +
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [['602', "BXDPublish", "Mouse Phenome Database"]])
+
+        db_mock.db.execute.return_value.fetchall.return_value = ()
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            "BXDPublish", "Mouse Phenome Database"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [["None", "BXDPublish", "Mouse Phenome Database"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type with no
+        results
+
+        """
+        db_mock.db.execute.return_value.fetchall.return_value = None
+        db_mock.db.execute.return_value.fetchone.return_value = (121,
+                                                                 "text value")
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [["None", "121", "text value"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+            "FROM PublishFreeze, InbredSet "
+            "WHERE InbredSet.Name = 'BXD' AND "
+            "PublishFreeze.InbredSetId = InbredSet.Id "
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_genotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            635, "HLCPublish", "HLC Published Genotypes"
+        )
+
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["635", "HLCGeno", "HLC Genotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
+            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
+            "GenoFreeze.InbredSetId = InbredSet.Id AND "
+            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
+            "ORDER BY GenoFreeze.CreateTime DESC"
+        )
+        db_mock.db.execute.return_value.fetchone.return_value = ()
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["None", "HLCGeno", "HLC Genotypes"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_mrna(self, db_mock):
+        """Test that correct dataset is returned for a mRNA
+        expression/ Probeset"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (112, "HC_M2_0606_P",
+             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
+            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
+        ]])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
+            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
+            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
+            "Species.Name = 'Mouse' AND Species.Id = " +
+            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
+            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
+            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
+            "ORDER BY ProbeSetFreeze.CreateTime DESC")
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_types(self, db_mock, datasets_mock):
+        """Test that correct tissue metadata is returned"""
+        datasets_mock.return_value = [
+            ["112", 'HC_M2_0606_P',
+                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+        ]
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+        )
+        self.assertEqual(build_types('mouse', 'random group'),
+                         [['M', 'M', 'Molecular Trait Datasets'],
+                          ['H', 'H', 'Molecular Trait Datasets'],
+                          ['R', 'R', 'Molecular Trait Datasets']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT DISTINCT Tissue.Name " +
+            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
+            "Tissue, Species WHERE Species.Name = 'mouse' " +
+            "AND Species.Id = InbredSet.SpeciesId AND " +
+            "InbredSet.Name = 'random group' AND " +
+            "ProbeFreeze.TissueId = Tissue.Id AND " +
+            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+            "ORDER BY Tissue.Name"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_existing_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes and genotypes
+        exist
+
+        """
+        phenotypes_exist_mock.return_value = True
+        genotypes_exist_mock.return_value = True
+
+        expected_result = self.test_type
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        self.assertEqual(get_types(self.test_group), expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist and
+        genotypes_exist are false but build_type is falsy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = []
+        self.assertEqual(get_types(self.test_group), {
+            'mouse': {},
+            'human': {}
+        })
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist,
+        genotypes_exist and build_types are truthy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        expected_result = {
+            'mouse': {
+                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
+            'human': {
+                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
+        self.assertEqual(get_types(self.test_group),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_existent_datasets(self,
+                                                 build_datasets_mock):
+        """Test correct dataset is returned with existent build_datasets"""
+        build_datasets_mock.return_value = "Test"
+        expected_result = {
+            'mouse': {
+                'H_T2': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'},
+                'H_T1': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'}},
+            'human': {'HLC': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'},
+                      'BXD': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_non_existent_datasets(self,
+                                                     build_datasets_mock):
+        """Test correct dataset is returned with non-existent build_datasets"""
+        build_datasets_mock.return_value = None
+        expected_result = {
+            'mouse': {
+                'H_T2': {},
+                'H_T1': {}},
+            'human': {'HLC': {},
+                      'BXD': {}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.get_datasets')
+    @mock.patch('wqflask.api.gen_menu.get_types')
+    @mock.patch('wqflask.api.gen_menu.get_groups')
+    @mock.patch('wqflask.api.gen_menu.get_species')
+    def test_gen_dropdown_json(self,
+                               species_mock,
+                               groups_mock,
+                               types_mock,
+                               datasets_mock):
+        "Test that the correct dictionary is constructed properly"
+        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
+                                     .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+        groups_mock.return_value = ("groupA groupB groupC groupD"
+                                    .split(" "))
+        types_mock.return_value = ("typeA typeB typeC typeD"
+                                   .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+
+        expected_result = {
+            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
+            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
+            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
+            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
+
+        self.assertEqual(gen_dropdown_json(), expected_result)
-- 
cgit v1.2.3


From 3a8409757e2e095cd18c483de07af1eed8719c02 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 8 Aug 2020 03:36:31 +0300
Subject: Add a basic test for test_display_marking_results.py

* wqflask/tests/wqflask/marker_regression/__init__.py: Add it
* wqflask/tests/wqflask/marker_regression/test_display_marking_results.py: Check
that PIL colors are being used instead of the deprecated Piddle colors.
---
 wqflask/tests/wqflask/marker_regression/__init__.py              | 0
 .../wqflask/marker_regression/test_display_marking_results.py    | 9 +++++++++
 2 files changed, 9 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/__init__.py
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_display_marking_results.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/__init__.py b/wqflask/tests/wqflask/marker_regression/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py b/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py
new file mode 100644
index 00000000..67da508b
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py
@@ -0,0 +1,9 @@
+import unittest
+
+from wqflask.marker_regression.display_mapping_results import DisplayMappingResults
+
+class TestDisplayMappingResults(unittest.TestCase):
+    def test_pil_colors(self):
+        """Test that colors use PILLOW color format"""
+        self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
+                         (245, 211, 211))
-- 
cgit v1.2.3


From d8ba3a6fb10127506a3edd4b572797bb846da37c Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sun, 23 Aug 2020 22:30:16 +0300
Subject: Fix failing test

* wqflask/tests/wqflask/api/test_gen_menu.py: Update assertion. Result data
introduced in 092212df

Signed-off-by: BonfaceKilz <bonfacemunyoki@gmail.com>
---
 wqflask/tests/wqflask/api/test_gen_menu.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/api/test_gen_menu.py b/wqflask/tests/wqflask/api/test_gen_menu.py
index 79c77fec..239484aa 100644
--- a/wqflask/tests/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/wqflask/api/test_gen_menu.py
@@ -255,9 +255,9 @@ class TestGenMenu(unittest.TestCase):
             ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
         )
         self.assertEqual(build_types('mouse', 'random group'),
-                         [['M', 'M', 'Molecular Trait Datasets'],
-                          ['H', 'H', 'Molecular Trait Datasets'],
-                          ['R', 'R', 'Molecular Trait Datasets']])
+                         [['M', 'M', 'Molecular Traits'],
+                          ['H', 'H', 'Molecular Traits'],
+                          ['R', 'R', 'Molecular Traits']])
         db_mock.db.execute.assert_called_once_with(
             "SELECT DISTINCT Tissue.Name " +
             "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
-- 
cgit v1.2.3


From cbc44ad7661b2da1bd434e186127fa8fab166a93 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sun, 23 Aug 2020 23:53:37 +0300
Subject: Rename file

* wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py:
Rename test_display_marking_results.py to test_display_mapping_results.py
---
 .../wqflask/marker_regression/test_display_mapping_results.py    | 9 +++++++++
 .../wqflask/marker_regression/test_display_marking_results.py    | 9 ---------
 2 files changed, 9 insertions(+), 9 deletions(-)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_display_marking_results.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
new file mode 100644
index 00000000..67da508b
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
@@ -0,0 +1,9 @@
+import unittest
+
+from wqflask.marker_regression.display_mapping_results import DisplayMappingResults
+
+class TestDisplayMappingResults(unittest.TestCase):
+    def test_pil_colors(self):
+        """Test that colors use PILLOW color format"""
+        self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
+                         (245, 211, 211))
diff --git a/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py b/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py
deleted file mode 100644
index 67da508b..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_display_marking_results.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import unittest
-
-from wqflask.marker_regression.display_mapping_results import DisplayMappingResults
-
-class TestDisplayMappingResults(unittest.TestCase):
-    def test_pil_colors(self):
-        """Test that colors use PILLOW color format"""
-        self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
-                         (245, 211, 211))
-- 
cgit v1.2.3


From 7cafbbc2f13240c56ad31d47a7b429c9832c6df0 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 24 Aug 2020 18:11:11 +0300
Subject: Add tests for the HtmlGenWrapper class

* wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py: Add
new tests
---
 .../test_display_mapping_results.py                | 144 ++++++++++++++++++++-
 1 file changed, 143 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
index 67da508b..6f791df1 100644
--- a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
+++ b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
@@ -1,9 +1,151 @@
 import unittest
 
-from wqflask.marker_regression.display_mapping_results import DisplayMappingResults
+from htmlgen import HTMLgen2 as HT
+from wqflask.marker_regression.display_mapping_results import (
+    DisplayMappingResults,
+    HtmlGenWrapper
+)
+
 
 class TestDisplayMappingResults(unittest.TestCase):
+    """Basic Methods to test Mapping Results"""
     def test_pil_colors(self):
         """Test that colors use PILLOW color format"""
         self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
                          (245, 211, 211))
+
+
+class TestHtmlGenWrapper(unittest.TestCase):
+    """Test Wrapper around HTMLGen"""
+    def test_create_image(self):
+        """Test HT.Image method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_image_tag(src="test.png",
+                                                alt="random",
+                                                border="0",
+                                                width="10",
+                                                height="13",
+                                                usemap="#webqtlmap")),
+            ("""<IMG src="test.png" height="13" width="10" """
+             """alt="random" border="0" """
+             """usemap="#webqtlmap">""")
+        )
+
+    def test_create_form(self):
+        """Test HT.Form method"""
+        test_form = HtmlGenWrapper.create_form_tag(
+            cgi="/testing/",
+            enctype='multipart/form-data',
+            name="formName",
+            submit=HT.Input(type='hidden')
+        )
+        test_image = HtmlGenWrapper.create_image_tag(
+            src="test.png",
+            alt="random",
+            border="0",
+            width="10",
+            height="13",
+            usemap="#webqtlmap"
+        )
+        self.assertEqual(
+            str(test_form).replace("\n", ""),
+            ("""<FORM METHOD="POST" ACTION="/testing/" """
+             """ENCTYPE="multipart/form-data" """
+             """NAME="formName"><INPUT TYPE="hidden" """
+             """NAME="Default_Name"></FORM>"""))
+        hddn = {
+            'FormID': 'showDatabase',
+            'ProbeSetID': '_',
+            'database': "TestGeno",
+            'CellID': '_',
+            'RISet': "Test",
+            'incparentsf1': 'ON'
+        }
+        for key in hddn.keys():
+            test_form.append(HT.Input(name=key, value=hddn[key],
+                                      type='hidden'))
+        test_form.append(test_image)
+        self.assertEqual(str(test_form).replace("\n", ""), (
+            """<FORM METHOD="POST" ACTION="/testing/" """
+            """ENCTYPE="multipart/form-data" NAME="formName">"""
+            """<INPUT TYPE="hidden" NAME="database" VALUE="TestGeno">"""
+            """<INPUT TYPE="hidden" NAME="incparentsf1" VALUE="ON">"""
+            """<INPUT TYPE="hidden" NAME="FormID" VALUE="showDatabase">"""
+            """<INPUT TYPE="hidden" NAME="ProbeSetID" VALUE="_">"""
+            """<INPUT TYPE="hidden" NAME="RISet" VALUE="Test">"""
+            """<INPUT TYPE="hidden" NAME="CellID" VALUE="_">"""
+            """<IMG src="test.png" height="13" width="10" alt="random" """
+            """border="0" usemap="#webqtlmap">"""
+            """<INPUT TYPE="hidden" NAME="Default_Name"></FORM>"""))
+
+    def test_create_paragraph(self):
+        """Test HT.Paragraph method"""
+        test_p_element = HtmlGenWrapper.create_p_tag(id="smallSize")
+        par_text = (
+            "Mapping using genotype data as "
+            "a trait will result in infinity LRS at one locus. "
+            "In order to display the result properly, all LRSs "
+            "higher than 100 are capped at 100."
+        )
+        self.assertEqual(
+            str(test_p_element),
+            """<P id="smallSize"></P>"""
+        )
+        test_p_element.append(HT.BR())
+        test_p_element.append(par_text)
+        self.assertEqual(
+            str(test_p_element),
+            """<P id="smallSize"><BR>{}</P>""".format(par_text)
+        )
+
+    def test_create_br_tag(self):
+        """Test HT.BR() method"""
+        self.assertEqual(str(HtmlGenWrapper.create_br_tag()),
+                         "<BR>")
+
+    def test_create_input_tag(self):
+        """Test HT.Input method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_input_tag(
+                type="hidden",
+                name="name",
+                value="key",
+                Class="trait trait_")).replace("\n", ""),
+            ("""<INPUT TYPE="hidden" NAME="name" """
+             """class="trait trait_" VALUE="key">"""))
+
+    def test_create_map_tag(self):
+        """Test HT.Map method"""
+        self.assertEqual(str(HtmlGenWrapper.create_map_tag(
+            name="WebqTLImageMap")).replace("\n", ""),
+            """<MAP NAME="WebqTLImageMap"></MAP>""")
+        gifmap = HtmlGenWrapper.create_map_tag(areas=[])
+        gifmap.areas.append(HT.Area(shape="rect",
+                                    coords='1 2 3', href='#area1'))
+        gifmap.areas.append(HT.Area(shape="rect",
+                                    coords='1 2 3', href='#area2'))
+        self.assertEqual(
+            str(gifmap).replace("\n", ""),
+            ("""<MAP NAME="">"""
+             """<AREA coords="1 2 3" """
+             """href="#area1" shape="rect">"""
+             """<AREA coords="1 2 3" href="#area2" shape="rect">"""
+             """</MAP>"""))
+
+    def test_create_area_tag(self):
+        """Test HT.Area method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_area_tag(
+                shape="rect",
+                coords="1 2",
+                href="http://test.com",
+                title="Some Title")).replace("\n", ""),
+            ("""<AREA coords="1 2" href="http://test.com" """
+             """shape="rect" title="Some Title">"""))
+
+    def test_create_link_tag(self):
+        """Test HT.HREF method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_link_tag(
+                "www.test.com", "test", target="_blank")).replace("\n", ""),
+            """<A HREF="www.test.com" TARGET="_blank">test</A>""")
-- 
cgit v1.2.3


From 6486bc57651f074245ae0bf786f9e92460d73fef Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 26 Aug 2020 17:31:17 +0300
Subject: Fix failing tests that use python2-htmlgen

* wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py: Fix
tests.
---
 .../test_display_mapping_results.py                | 91 ++++++++++++----------
 1 file changed, 48 insertions(+), 43 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
index 6f791df1..8ae0f09f 100644
--- a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
+++ b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
@@ -1,6 +1,6 @@
 import unittest
 
-from htmlgen import HTMLgen2 as HT
+import htmlgen as HT
 from wqflask.marker_regression.display_mapping_results import (
     DisplayMappingResults,
     HtmlGenWrapper
@@ -26,9 +26,9 @@ class TestHtmlGenWrapper(unittest.TestCase):
                                                 width="10",
                                                 height="13",
                                                 usemap="#webqtlmap")),
-            ("""<IMG src="test.png" height="13" width="10" """
-             """alt="random" border="0" """
-             """usemap="#webqtlmap">""")
+            ("""<img alt="random" border="0" height="13" """
+             """src="test.png" usemap="#webqtlmap" """
+             """width="10"/>""")
         )
 
     def test_create_form(self):
@@ -37,7 +37,7 @@ class TestHtmlGenWrapper(unittest.TestCase):
             cgi="/testing/",
             enctype='multipart/form-data',
             name="formName",
-            submit=HT.Input(type='hidden')
+            submit=HtmlGenWrapper.create_input_tag(type_='hidden', name='Default_Name')
         )
         test_image = HtmlGenWrapper.create_image_tag(
             src="test.png",
@@ -49,10 +49,10 @@ class TestHtmlGenWrapper(unittest.TestCase):
         )
         self.assertEqual(
             str(test_form).replace("\n", ""),
-            ("""<FORM METHOD="POST" ACTION="/testing/" """
-             """ENCTYPE="multipart/form-data" """
-             """NAME="formName"><INPUT TYPE="hidden" """
-             """NAME="Default_Name"></FORM>"""))
+            ("""<form action="/testing/" enctype="multipart/form-data" """
+             """method="POST" """
+             """name="formName"><input name="Default_Name" """
+             """type="hidden"/></form>"""))
         hddn = {
             'FormID': 'showDatabase',
             'ProbeSetID': '_',
@@ -62,21 +62,26 @@ class TestHtmlGenWrapper(unittest.TestCase):
             'incparentsf1': 'ON'
         }
         for key in hddn.keys():
-            test_form.append(HT.Input(name=key, value=hddn[key],
-                                      type='hidden'))
+            test_form.append(
+                HtmlGenWrapper.create_input_tag(
+                    name=key,
+                    value=hddn[key],
+                    type_='hidden'))
         test_form.append(test_image)
+
         self.assertEqual(str(test_form).replace("\n", ""), (
-            """<FORM METHOD="POST" ACTION="/testing/" """
-            """ENCTYPE="multipart/form-data" NAME="formName">"""
-            """<INPUT TYPE="hidden" NAME="database" VALUE="TestGeno">"""
-            """<INPUT TYPE="hidden" NAME="incparentsf1" VALUE="ON">"""
-            """<INPUT TYPE="hidden" NAME="FormID" VALUE="showDatabase">"""
-            """<INPUT TYPE="hidden" NAME="ProbeSetID" VALUE="_">"""
-            """<INPUT TYPE="hidden" NAME="RISet" VALUE="Test">"""
-            """<INPUT TYPE="hidden" NAME="CellID" VALUE="_">"""
-            """<IMG src="test.png" height="13" width="10" alt="random" """
-            """border="0" usemap="#webqtlmap">"""
-            """<INPUT TYPE="hidden" NAME="Default_Name"></FORM>"""))
+            """<form action="/testing/" enctype="multipart/form-data" """
+            """method="POST" name="formName">"""
+            """<input name="Default_Name" type="hidden"/>"""
+            """<input name="FormID" type="hidden" value="showDatabase"/>"""
+            """<input name="ProbeSetID" type="hidden" value="_"/>"""
+            """<input name="database" type="hidden" value="TestGeno"/>"""
+            """<input name="CellID" type="hidden" value="_"/>"""
+            """<input name="RISet" type="hidden" value="Test"/>"""
+            """<input name="incparentsf1" type="hidden" value="ON"/>"""
+            """<img alt="random" border="0" height="13" src="test.png" """
+            """usemap="#webqtlmap" width="10"/>"""
+            """</form>"""))
 
     def test_create_paragraph(self):
         """Test HT.Paragraph method"""
@@ -89,48 +94,48 @@ class TestHtmlGenWrapper(unittest.TestCase):
         )
         self.assertEqual(
             str(test_p_element),
-            """<P id="smallSize"></P>"""
+            """<p id="smallSize"></p>"""
         )
-        test_p_element.append(HT.BR())
+        test_p_element.append(HtmlGenWrapper.create_br_tag())
         test_p_element.append(par_text)
         self.assertEqual(
             str(test_p_element),
-            """<P id="smallSize"><BR>{}</P>""".format(par_text)
+            """<p id="smallSize"><br/>{}</p>""".format(par_text)
         )
 
     def test_create_br_tag(self):
         """Test HT.BR() method"""
         self.assertEqual(str(HtmlGenWrapper.create_br_tag()),
-                         "<BR>")
+                         "<br/>")
 
     def test_create_input_tag(self):
         """Test HT.Input method"""
         self.assertEqual(
             str(HtmlGenWrapper.create_input_tag(
-                type="hidden",
+                type_="hidden",
                 name="name",
                 value="key",
                 Class="trait trait_")).replace("\n", ""),
-            ("""<INPUT TYPE="hidden" NAME="name" """
-             """class="trait trait_" VALUE="key">"""))
+            ("""<input class="trait trait_" name="name" """
+             """type="hidden" value="key"/>"""))
 
     def test_create_map_tag(self):
         """Test HT.Map method"""
         self.assertEqual(str(HtmlGenWrapper.create_map_tag(
             name="WebqTLImageMap")).replace("\n", ""),
-            """<MAP NAME="WebqTLImageMap"></MAP>""")
-        gifmap = HtmlGenWrapper.create_map_tag(areas=[])
-        gifmap.areas.append(HT.Area(shape="rect",
-                                    coords='1 2 3', href='#area1'))
-        gifmap.areas.append(HT.Area(shape="rect",
-                                    coords='1 2 3', href='#area2'))
+            """<map name="WebqTLImageMap"></map>""")
+        gifmap = HtmlGenWrapper.create_map_tag(name="test")
+        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
+                                                     coords='1 2 3', href='#area1'))
+        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
+                                                     coords='1 2 3', href='#area2'))
         self.assertEqual(
             str(gifmap).replace("\n", ""),
-            ("""<MAP NAME="">"""
-             """<AREA coords="1 2 3" """
-             """href="#area1" shape="rect">"""
-             """<AREA coords="1 2 3" href="#area2" shape="rect">"""
-             """</MAP>"""))
+            ("""<map name="test">"""
+             """<area coords="1 2 3" """
+             """href="#area1" shape="rect"/>"""
+             """<area coords="1 2 3" href="#area2" shape="rect"/>"""
+             """</map>"""))
 
     def test_create_area_tag(self):
         """Test HT.Area method"""
@@ -140,12 +145,12 @@ class TestHtmlGenWrapper(unittest.TestCase):
                 coords="1 2",
                 href="http://test.com",
                 title="Some Title")).replace("\n", ""),
-            ("""<AREA coords="1 2" href="http://test.com" """
-             """shape="rect" title="Some Title">"""))
+            ("""<area coords="1 2" href="http://test.com" """
+             """shape="rect" title="Some Title"/>"""))
 
     def test_create_link_tag(self):
         """Test HT.HREF method"""
         self.assertEqual(
             str(HtmlGenWrapper.create_link_tag(
                 "www.test.com", "test", target="_blank")).replace("\n", ""),
-            """<A HREF="www.test.com" TARGET="_blank">test</A>""")
+            """<a href="www.test.com" target="_blank">test</a>""")
-- 
cgit v1.2.3


From 869da13b92e70fa0769cd1a49e15b03e2c9d0550 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 27 Aug 2020 01:31:33 +0300
Subject: Fix failing tests

---
 wqflask/tests/base/test_data_set.py        | 71 +++++++++++++++++++++++-------
 wqflask/tests/base/test_general_object.py  |  9 ++--
 wqflask/tests/wqflask/api/test_gen_menu.py |  6 +++
 3 files changed, 66 insertions(+), 20 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 94780a5d..e6000e56 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -4,7 +4,7 @@ import unittest
 import mock
 
 from wqflask import app
-from data import gen_menu_json
+from .data import gen_menu_json
 from base.data_set import DatasetType
 
 
@@ -59,9 +59,14 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(data_set("BXDGeno"), "Geno")
             self.assertEqual(data_set("BXDPublish"), "Publish")
             self.assertEqual(data_set("HLC_0311"), "ProbeSet")
+
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
-                '{"BXDGeno": "Geno", "BXDPublish": "Publish", "HLCPublish": "Publish", "HLC_0311": "ProbeSet", "HC_M2_0606_P": "ProbeSet"}')
+                ('{"HLC_0311": "ProbeSet", '
+                 '"HLCPublish": "Publish", '
+                 '"BXDGeno": "Geno", '
+                 '"HC_M2_0606_P": "ProbeSet", '
+                 '"BXDPublish": "Publish"}'))
 
     @mock.patch('base.data_set.g')
     def test_set_dataset_key_mrna(self, db_mock):
@@ -74,8 +79,17 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(data_set("Test"), "ProbeSet")
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
-                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "ProbeSet", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "ProbeSet"}'))
+
             db_mock.db.execute.assert_called_with(
                 ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
                  "WHERE ProbeSetFreeze.Name = \"Test\" ")
@@ -92,13 +106,21 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(data_set("Test"), "Publish")
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
-                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Publish"}'))
             db_mock.db.execute.assert_called_with(
-                ("SELECT InfoFiles.GN_AccesionId " +
-                 "FROM InfoFiles, PublishFreeze, InbredSet " +
+                ("SELECT InfoFiles.GN_AccesionId "
+                 "FROM InfoFiles, PublishFreeze, InbredSet "
                  "WHERE InbredSet.Name = 'Test' AND "
-                 "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+                 "PublishFreeze.InbredSetId = InbredSet.Id AND "
                  "InfoFiles.InfoPageName = PublishFreeze.Name")
             )
 
@@ -111,10 +133,20 @@ class TestDataSetTypes(unittest.TestCase):
             data_set = DatasetType(redis_mock)
             data_set.set_dataset_key("other_pheno", "Test")
             self.assertEqual(data_set("Test"), "Publish")
+
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
-                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Publish"}'))
+
             db_mock.db.execute.assert_called_with(
                 ("SELECT PublishFreeze.Name " +
                  "FROM PublishFreeze, InbredSet " +
@@ -133,8 +165,17 @@ class TestDataSetTypes(unittest.TestCase):
             self.assertEqual(data_set("Test"), "Geno")
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
-                '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Geno", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Geno"}'))
+
             db_mock.db.execute.assert_called_with(
-                ("SELECT GenoFreeze.Id FROM GenoFreeze WHERE GenoFreeze.Name = \"Test\" ")
-            )
+                ("SELECT GenoFreeze.Id FROM "
+                 "GenoFreeze WHERE GenoFreeze.Name = \"Test\" "))
diff --git a/wqflask/tests/base/test_general_object.py b/wqflask/tests/base/test_general_object.py
index c7701021..00fd3c72 100644
--- a/wqflask/tests/base/test_general_object.py
+++ b/wqflask/tests/base/test_general_object.py
@@ -17,9 +17,9 @@ class TestGeneralObjectTests(unittest.TestCase):
     def test_object_dict(self):
         """Test whether the base class is printed properly"""
         test_obj = GeneralObject("a", name="test", value=1)
-        self.assertEqual(str(test_obj), "value = 1\nname = test\n")
+        self.assertEqual(str(test_obj), "name = test\nvalue = 1\n")
         self.assertEqual(
-            repr(test_obj), "value = 1\nname = test\ncontents = ['a']\n")
+            repr(test_obj), "contents = ['a']\nname = test\nvalue = 1\n")
         self.assertEqual(len(test_obj), 2)
         self.assertEqual(test_obj["value"], 1)
         test_obj["test"] = 1
@@ -36,6 +36,5 @@ class TestGeneralObjectTests(unittest.TestCase):
         test_obj1 = GeneralObject("a", name="test", value=1)
         test_obj2 = GeneralObject("b", name="test2", value=2)
         test_obj3 = GeneralObject("a", name="test", x=1, y=2)
-        self.assertTrue(test_obj1 == test_obj2 )
-        self.assertFalse(test_obj1 == test_obj3 )
-
+        self.assertTrue(test_obj1 == test_obj2)
+        self.assertFalse(test_obj1 == test_obj3)
diff --git a/wqflask/tests/wqflask/api/test_gen_menu.py b/wqflask/tests/wqflask/api/test_gen_menu.py
index 239484aa..bf41054d 100644
--- a/wqflask/tests/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/wqflask/api/test_gen_menu.py
@@ -2,6 +2,7 @@
 import unittest
 import mock
 
+from wqflask import app
 from wqflask.api.gen_menu import gen_dropdown_json
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
@@ -17,6 +18,8 @@ class TestGenMenu(unittest.TestCase):
     """Tests for the gen_menu module"""
 
     def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
         self.test_group = {
             'mouse': [
                 ['H_T1',
@@ -67,6 +70,9 @@ class TestGenMenu(unittest.TestCase):
             }
         }
 
+    def tearDown(self):
+        self.app_context.pop()
+
     @mock.patch('wqflask.api.gen_menu.g')
     def test_get_species(self, db_mock):
         """Test that assertion is raised when dataset and dataset_name
-- 
cgit v1.2.3


From 77d026e042a3eac9e3de4177ee374a37f2e24127 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 15 Sep 2020 20:53:11 +0300
Subject: Fix failing tests

* wqflask/tests/base/test_data_set.py: Update failing tests introduced
by the change in 301bdd2f4.
---
 wqflask/tests/base/test_data_set.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index 94780a5d..dd7f5051 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -66,7 +66,7 @@ class TestDataSetTypes(unittest.TestCase):
     @mock.patch('base.data_set.g')
     def test_set_dataset_key_mrna(self, db_mock):
         with app.app_context():
-            db_mock.db.execute.return_value = [1, 2, 3]
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             data_set = DatasetType(redis_mock)
@@ -84,7 +84,7 @@ class TestDataSetTypes(unittest.TestCase):
     @mock.patch('base.data_set.g')
     def test_set_dataset_key_pheno(self, db_mock):
         with app.app_context():
-            db_mock.db.execute.return_value = [1, 2, 3]
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             data_set = DatasetType(redis_mock)
@@ -93,7 +93,6 @@ class TestDataSetTypes(unittest.TestCase):
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
                 '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
             db_mock.db.execute.assert_called_with(
                 ("SELECT InfoFiles.GN_AccesionId " +
                  "FROM InfoFiles, PublishFreeze, InbredSet " +
@@ -105,7 +104,7 @@ class TestDataSetTypes(unittest.TestCase):
     @mock.patch('base.data_set.g')
     def test_set_dataset_other_pheno(self, db_mock):
         with app.app_context():
-            db_mock.db.execute.return_value = [1, 2, 3]
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             data_set = DatasetType(redis_mock)
@@ -114,7 +113,6 @@ class TestDataSetTypes(unittest.TestCase):
             redis_mock.set.assert_called_once_with(
                 "dataset_structure",
                 '{"Aging-Brain-UCIPublish": "Publish", "AKXDGeno": "Geno", "B139_K_1206_M": "ProbeSet", "AD-cases-controls-MyersGeno": "Geno", "AD-cases-controls-MyersPublish": "Publish", "All Phenotypes": "Publish", "Test": "Publish", "AXBXAPublish": "Publish", "B139_K_1206_R": "ProbeSet", "AXBXAGeno": "Geno"}')
-            expected_db_call = """"""
             db_mock.db.execute.assert_called_with(
                 ("SELECT PublishFreeze.Name " +
                  "FROM PublishFreeze, InbredSet " +
@@ -125,7 +123,7 @@ class TestDataSetTypes(unittest.TestCase):
     @mock.patch('base.data_set.g')
     def test_set_dataset_geno(self, db_mock):
         with app.app_context():
-            db_mock.db.execute.return_value = [1, 2, 3]
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             data_set = DatasetType(redis_mock)
-- 
cgit v1.2.3


From 6e776e94bdc2cea9923d70ff836ce1c02a1e1af9 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 15 Sep 2020 23:19:30 +0300
Subject: Add tests for authentication tools

Catches bugs in:
-
https://github.com/genenetwork/genenetwork2/pull/422/commits/70dbeeb5832711ed5271434e482c18bc7ea095b8

* wqflask/tests/utility/test_authentication_tools.py: New file. Add
tests for "check_resource_availability".
---
 wqflask/tests/utility/test_authentication_tools.py | 113 +++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 wqflask/tests/utility/test_authentication_tools.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_authentication_tools.py b/wqflask/tests/utility/test_authentication_tools.py
new file mode 100644
index 00000000..59c53879
--- /dev/null
+++ b/wqflask/tests/utility/test_authentication_tools.py
@@ -0,0 +1,113 @@
+"""Tests for authentication tools"""
+import unittest
+import mock
+
+from utility.authentication_tools import check_resource_availability
+
+
+class TestResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return '["foo"]'
+
+
+class TestUser:
+    """Mock user"""
+    @property
+    def user_id(self):
+        """Mockes user id. Used in Flask.g.user_session.user_id"""
+        return "Jane"
+
+
+class TestUserSession:
+    """Mock user session"""
+    @property
+    def user_session(self):
+        """Mock user session. Mocks Flask.g.user_session object"""
+        return TestUser()
+
+
+class TestCheckResourceAvailability(unittest.TestCase):
+    """Test methods related to checking the resource availability"""
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g')
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_default_mask(
+            self,
+            resource_id_mock,
+            g_mock,
+            redis_mock,
+            add_new_resource_mock):
+        """Test the resource availability with default mask"""
+        resource_id_mock.return_value = 1
+        g_mock.return_value = mock.Mock()
+        redis_mock.smembers.return_value = []
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        self.assertEqual(check_resource_availability(test_dataset), 2)
+
+    @mock.patch('utility.authentication_tools.requests.get')
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g')
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_non_default_mask(
+            self,
+            resource_id_mock,
+            g_mock,
+            redis_mock,
+            add_new_resource_mock,
+            requests_mock):
+        """Test the resource availability with default mask"""
+        resource_id_mock.return_value = 1
+        g_mock.return_value = mock.Mock()
+        redis_mock.smembers.return_value = []
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        requests_mock.return_value = TestResponse()
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         ['foo'])
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.SUPER_PRIVILEGES',
+                "SUPERUSER")
+    @mock.patch('utility.authentication_tools.requests.get')
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g', TestUserSession())
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_of_super_user(
+            self,
+            resource_id_mock,
+            redis_mock,
+            add_new_resource_mock,
+            requests_mock):
+        """Test the resource availability if the user is the super user"""
+        resource_id_mock.return_value = 1
+        redis_mock.smembers.return_value = ["Jane"]
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        requests_mock.return_value = TestResponse()
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         "SUPERUSER")
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    def test_check_resource_availability_string_dataset(self):
+        """Test the resource availability if the dataset is a string"""
+        self.assertEqual(check_resource_availability("Test"),
+                         "John Doe")
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    def test_check_resource_availability_temp(self):
+        """Test the resource availability if the dataset is a string"""
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Temp")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         "John Doe")
-- 
cgit v1.2.3


From cad9d0e4c913eba5ae3c74912b59051885833f90 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 16 Sep 2020 00:03:28 +0300
Subject: Add tests for "add_new_resource" method

* wqflask/tests/utility/test_authentication_tools.py: Add them.
---
 wqflask/tests/utility/test_authentication_tools.py | 80 ++++++++++++++++++++++
 1 file changed, 80 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_authentication_tools.py b/wqflask/tests/utility/test_authentication_tools.py
index 59c53879..99c74245 100644
--- a/wqflask/tests/utility/test_authentication_tools.py
+++ b/wqflask/tests/utility/test_authentication_tools.py
@@ -3,6 +3,7 @@ import unittest
 import mock
 
 from utility.authentication_tools import check_resource_availability
+from utility.authentication_tools import add_new_resource
 
 
 class TestResponse:
@@ -29,6 +30,10 @@ class TestUserSession:
         return TestUser()
 
 
+def mock_add_resource(resource_ob, update=False):
+    return resource_ob
+
+
 class TestCheckResourceAvailability(unittest.TestCase):
     """Test methods related to checking the resource availability"""
     @mock.patch('utility.authentication_tools.add_new_resource')
@@ -111,3 +116,78 @@ class TestCheckResourceAvailability(unittest.TestCase):
         type(test_dataset).type = mock.PropertyMock(return_value="Temp")
         self.assertEqual(check_resource_availability(test_dataset),
                          "John Doe")
+
+
+class TestAddNewResource(unittest.TestCase):
+    """Test cases for add_new_resource method"""
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_publish_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is 'publish'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Publish")
+        type(test_dataset).id = mock.PropertyMock(return_value=10)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Test_None",
+            "data": {
+                "dataset": 10,
+                "trait": None
+            },
+            "type": "dataset-publish"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_geno_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is 'geno'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).type = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).id = mock.PropertyMock(return_value=20)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Geno",
+            "data": {
+                "dataset": 20,
+            },
+            "type": "dataset-geno"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_other_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is not 'geno' or 'publish'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).type = mock.PropertyMock(return_value="other")
+        type(test_dataset).id = mock.PropertyMock(return_value=20)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Geno",
+            "data": {
+                "dataset": 20,
+            },
+            "type": "dataset-probeset"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
-- 
cgit v1.2.3


From 32f434e9f49583b731f1393328a3ff645c2f9af7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 16 Sep 2020 03:11:01 +0300
Subject: Add new tests for "base/trait.py"

* wqflask/tests/base/test_trait.py: New tests.
---
 wqflask/tests/base/test_trait.py | 101 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)
 create mode 100644 wqflask/tests/base/test_trait.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
new file mode 100644
index 00000000..53b0d440
--- /dev/null
+++ b/wqflask/tests/base/test_trait.py
@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""Tests wqflask/base/trait.py"""
+import unittest
+import mock
+
+from base.trait import GeneralTrait
+from base.trait import retrieve_trait_info
+
+
+class TestResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return "[1, 2, 3, 4]"
+
+
+class TestNilResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return "{}"
+
+
+class MockTrait(GeneralTrait):
+    @property
+    def wikidata_alias_fmt(self):
+        return "Mock alias"
+
+
+class TestRetrieveTraitInfo(unittest.TestCase):
+    """Tests for 'retrieve_trait_info'"""
+    def test_retrieve_trait_info_with_empty_dataset(self):
+        """Test that an exception is raised when dataset is empty"""
+        with self.assertRaises(AssertionError):
+            retrieve_trait_info(trait=mock.MagicMock(),
+                                dataset={})
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    def test_retrieve_trait_info_with_empty_trait_info(self,
+                                                       g_mock,
+                                                       requests_mock):
+        """Empty trait info"""
+        requests_mock.return_value = TestNilResponse()
+        with self.assertRaises(KeyError):
+            retrieve_trait_info(trait=mock.MagicMock(),
+                                dataset=mock.MagicMock())
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    def test_retrieve_trait_info_with_non_empty_trait_info(self,
+                                                           g_mock,
+                                                           requests_mock):
+        """Test that attributes are set"""
+        mock_dataset = mock.MagicMock()
+        requests_mock.return_value = TestResponse()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        test_trait = retrieve_trait_info(trait=MockTrait(dataset=mock_dataset),
+                                         dataset=mock_dataset)
+        self.assertEqual(test_trait.a, 1)
+        self.assertEqual(test_trait.b, 2)
+        self.assertEqual(test_trait.c, 3)
+        self.assertEqual(test_trait.d, 4)
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    def test_retrieve_trait_info_utf8_parsing(self,
+                                              g_mock,
+                                              requests_mock):
+        """Test that utf-8 strings are parsed correctly"""
+        utf_8_string = "test_string"
+        mock_dataset = mock.MagicMock()
+        requests_mock.return_value = TestResponse()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = 'Publish'
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description=utf_8_string
+        )
+        trait_attrs = {
+            "group_code": "test_code",
+            "pre_publication_description": "test_pre_pub",
+            "pre_publication_abbreviation": "ファイルを画面毎に見て行くには、次のコマンドを使います。",
+            "post_publication_description": None,
+            "pubmed_id": None,
+            'year': "2020",
+            "authors": "Jane Doe かいと",
+        }
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset)
+        self.assertEqual(test_trait.abbreviation,
+                         "ファイルを画面毎に見て行くには、次のコマンドを使います。")
+        self.assertEqual(test_trait.authors,
+                         "Jane Doe かいと")
-- 
cgit v1.2.3


From b13ca26da67855f9d32f3209176af052ed46617f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 17 Sep 2020 15:55:05 +0300
Subject: Add tests for hmac utility

* wqflask/tests/utility/test_hmac.py: New tests.
---
 wqflask/tests/utility/test_hmac.py | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 wqflask/tests/utility/test_hmac.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_hmac.py b/wqflask/tests/utility/test_hmac.py
new file mode 100644
index 00000000..c7927685
--- /dev/null
+++ b/wqflask/tests/utility/test_hmac.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""Test hmac utility functions"""
+
+import unittest
+import mock
+
+from utility.hmac import data_hmac
+from utility.hmac import url_for_hmac
+from utility.hmac import hmac_creation
+
+
+class TestHmacUtil(unittest.TestCase):
+    """Test Utility method for hmac creation"""
+
+    def test_hmac_creation(self):
+        """Test hmac creation with a utf-8 string"""
+        self.assertEqual(hmac_creation("ファイ"), "21fa1d935bbbb07a7875")
+
+    def test_data_hmac(self):
+        """Test data_hmac fn with a utf-8 string"""
+        self.assertEqual(data_hmac("ファイ"), "ファイ:21fa1d935bbbb07a7875")
+
+    @mock.patch("utility.hmac.url_for")
+    def test_url_for_hmac_with_plain_url(self, mock_url):
+        """Test url_for_hmac without params"""
+        mock_url.return_value = "https://mock_url.com/ファイ/"
+        self.assertEqual(url_for_hmac("ファイ"),
+                         "https://mock_url.com/ファイ/?hm=a62896a50d9ffcff7deb")
+
+    @mock.patch("utility.hmac.url_for")
+    def test_url_for_hmac_with_param_in_url(self, mock_url):
+        """Test url_for_hmac with params"""
+        mock_url.return_value = "https://mock_url.com/?ファイ=1"
+        self.assertEqual(url_for_hmac("ファイ"),
+                         "https://mock_url.com/?ファイ=1&hm=b2128fb28bc32da3b5b7")
-- 
cgit v1.2.3


From 16faa26e52b1f0191595e16550d553907d2f9d67 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 17 Sep 2020 17:21:30 +0300
Subject: Fix errors in tests

* wqflask/tests/utility/test_authentication_tools.py
test_check_resource_availability_non_default_mask): Mock flask's
global 'g' variable properly.
* wqflask/tests/base/test_trait.py: Ditto.
* wqflask/tests/utility/test_authentication_tools.py: Ditto.
---
 wqflask/tests/base/test_trait.py                   | 9 +++------
 wqflask/tests/utility/test_authentication_tools.py | 8 ++------
 2 files changed, 5 insertions(+), 12 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index 53b0d440..d333458a 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -38,9 +38,8 @@ class TestRetrieveTraitInfo(unittest.TestCase):
                                 dataset={})
 
     @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.g', mock.Mock())
     def test_retrieve_trait_info_with_empty_trait_info(self,
-                                                       g_mock,
                                                        requests_mock):
         """Empty trait info"""
         requests_mock.return_value = TestNilResponse()
@@ -49,9 +48,8 @@ class TestRetrieveTraitInfo(unittest.TestCase):
                                 dataset=mock.MagicMock())
 
     @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.g', mock.Mock())
     def test_retrieve_trait_info_with_non_empty_trait_info(self,
-                                                           g_mock,
                                                            requests_mock):
         """Test that attributes are set"""
         mock_dataset = mock.MagicMock()
@@ -66,9 +64,8 @@ class TestRetrieveTraitInfo(unittest.TestCase):
         self.assertEqual(test_trait.d, 4)
 
     @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.g', mock.Mock())
     def test_retrieve_trait_info_utf8_parsing(self,
-                                              g_mock,
                                               requests_mock):
         """Test that utf-8 strings are parsed correctly"""
         utf_8_string = "test_string"
diff --git a/wqflask/tests/utility/test_authentication_tools.py b/wqflask/tests/utility/test_authentication_tools.py
index 99c74245..ef94eabc 100644
--- a/wqflask/tests/utility/test_authentication_tools.py
+++ b/wqflask/tests/utility/test_authentication_tools.py
@@ -38,17 +38,15 @@ class TestCheckResourceAvailability(unittest.TestCase):
     """Test methods related to checking the resource availability"""
     @mock.patch('utility.authentication_tools.add_new_resource')
     @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g')
+    @mock.patch('utility.authentication_tools.g', mock.Mock())
     @mock.patch('utility.authentication_tools.get_resource_id')
     def test_check_resource_availability_default_mask(
             self,
             resource_id_mock,
-            g_mock,
             redis_mock,
             add_new_resource_mock):
         """Test the resource availability with default mask"""
         resource_id_mock.return_value = 1
-        g_mock.return_value = mock.Mock()
         redis_mock.smembers.return_value = []
         test_dataset = mock.MagicMock()
         type(test_dataset).type = mock.PropertyMock(return_value="Test")
@@ -58,18 +56,16 @@ class TestCheckResourceAvailability(unittest.TestCase):
     @mock.patch('utility.authentication_tools.requests.get')
     @mock.patch('utility.authentication_tools.add_new_resource')
     @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g')
+    @mock.patch('utility.authentication_tools.g', TestUserSession())
     @mock.patch('utility.authentication_tools.get_resource_id')
     def test_check_resource_availability_non_default_mask(
             self,
             resource_id_mock,
-            g_mock,
             redis_mock,
             add_new_resource_mock,
             requests_mock):
         """Test the resource availability with default mask"""
         resource_id_mock.return_value = 1
-        g_mock.return_value = mock.Mock()
         redis_mock.smembers.return_value = []
         add_new_resource_mock.return_value = {"default_mask": 2}
         requests_mock.return_value = TestResponse()
-- 
cgit v1.2.3


From 0fd23995fa21c32c2a6005b2fd70b0bd99d13214 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 17 Sep 2020 18:05:54 +0300
Subject: Mock "SECRET_HMAC_CODE"

* wqflask/tests/utility/test_hmac.py: Mock app.config's
"SECRET_HMAC_CODE" value.
---
 wqflask/tests/utility/test_hmac.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_hmac.py b/wqflask/tests/utility/test_hmac.py
index c7927685..16b50771 100644
--- a/wqflask/tests/utility/test_hmac.py
+++ b/wqflask/tests/utility/test_hmac.py
@@ -12,24 +12,28 @@ from utility.hmac import hmac_creation
 class TestHmacUtil(unittest.TestCase):
     """Test Utility method for hmac creation"""
 
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
     def test_hmac_creation(self):
         """Test hmac creation with a utf-8 string"""
-        self.assertEqual(hmac_creation("ファイ"), "21fa1d935bbbb07a7875")
+        self.assertEqual(hmac_creation("ファイ"), "7410466338cfe109e946")
 
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
     def test_data_hmac(self):
         """Test data_hmac fn with a utf-8 string"""
-        self.assertEqual(data_hmac("ファイ"), "ファイ:21fa1d935bbbb07a7875")
+        self.assertEqual(data_hmac("ファイ"), "ファイ:7410466338cfe109e946")
 
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
     @mock.patch("utility.hmac.url_for")
     def test_url_for_hmac_with_plain_url(self, mock_url):
         """Test url_for_hmac without params"""
         mock_url.return_value = "https://mock_url.com/ファイ/"
         self.assertEqual(url_for_hmac("ファイ"),
-                         "https://mock_url.com/ファイ/?hm=a62896a50d9ffcff7deb")
+                         "https://mock_url.com/ファイ/?hm=05bc39e659b1948f41e7")
 
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
     @mock.patch("utility.hmac.url_for")
     def test_url_for_hmac_with_param_in_url(self, mock_url):
         """Test url_for_hmac with params"""
         mock_url.return_value = "https://mock_url.com/?ファイ=1"
         self.assertEqual(url_for_hmac("ファイ"),
-                         "https://mock_url.com/?ファイ=1&hm=b2128fb28bc32da3b5b7")
+                         "https://mock_url.com/?ファイ=1&hm=4709c1708270644aed79")
-- 
cgit v1.2.3


From fd151ade1d9f12157bc0ae25570e982122be0c7d Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 23 Sep 2020 02:23:02 +0300
Subject: Fix failing tests

* wqflask/tests/base/test_trait.py: In python2 it's necessary to
decode the utf-8 string.
---
 wqflask/tests/base/test_trait.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index 53b0d440..960f2c81 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -96,6 +96,6 @@ class TestRetrieveTraitInfo(unittest.TestCase):
         test_trait = retrieve_trait_info(trait=mock_trait,
                                          dataset=mock_dataset)
         self.assertEqual(test_trait.abbreviation,
-                         "ファイルを画面毎に見て行くには、次のコマンドを使います。")
+                         "ファイルを画面毎に見て行くには、次のコマンドを使います。".decode('utf-8'))
         self.assertEqual(test_trait.authors,
-                         "Jane Doe かいと")
+                         "Jane Doe かいと".decode('utf-8'))
-- 
cgit v1.2.3


From f67b0c92af93e3153fe9375e98a139386a4f2fb0 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 26 Sep 2020 01:21:10 +0300
Subject: Fix failing tests

* wqflask/tests/base/test_trait.py: Remove decode function call which
is no longer supported in python3.
---
 wqflask/tests/base/test_trait.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index 9c3154f3..d333458a 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -93,6 +93,6 @@ class TestRetrieveTraitInfo(unittest.TestCase):
         test_trait = retrieve_trait_info(trait=mock_trait,
                                          dataset=mock_dataset)
         self.assertEqual(test_trait.abbreviation,
-                         "ファイルを画面毎に見て行くには、次のコマンドを使います。".decode('utf-8'))
+                         "ファイルを画面毎に見て行くには、次のコマンドを使います。")
         self.assertEqual(test_trait.authors,
-                         "Jane Doe かいと".decode('utf-8'))
+                         "Jane Doe かいと")
-- 
cgit v1.2.3


From bbcecf8e7d8389b8466fe51dde6538387fdce6b5 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 26 Sep 2020 01:33:52 +0300
Subject: Fix failing tests by replacing mock with unittest.mock

* wqflask/tests/base/test_data_set.py (imports): Run:
`find . -type f -name "*py" -print0 | xargs -0 sed -i \
"s|import mock|from unittest import mock|g"`
* wqflask/tests/base/test_trait.py(imports): Ditto.
* wqflask/tests/utility/test_authentication_tools.py(imports): Ditto.
* wqflask/tests/utility/test_hmac.py(imports). Ditto.
* wqflask/tests/wqflask/api/test_gen_menu.py: Ditto
---
 wqflask/tests/base/test_data_set.py                | 2 +-
 wqflask/tests/base/test_trait.py                   | 2 +-
 wqflask/tests/utility/test_authentication_tools.py | 2 +-
 wqflask/tests/utility/test_hmac.py                 | 2 +-
 wqflask/tests/wqflask/api/test_gen_menu.py         | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
index b1de4932..96563a16 100644
--- a/wqflask/tests/base/test_data_set.py
+++ b/wqflask/tests/base/test_data_set.py
@@ -1,7 +1,7 @@
 """Tests for wqflask/base/data_set.py"""
 
 import unittest
-import mock
+from unittest import mock
 
 from wqflask import app
 from .data import gen_menu_json
diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index d333458a..bf4e88e0 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 """Tests wqflask/base/trait.py"""
 import unittest
-import mock
+from unittest import mock
 
 from base.trait import GeneralTrait
 from base.trait import retrieve_trait_info
diff --git a/wqflask/tests/utility/test_authentication_tools.py b/wqflask/tests/utility/test_authentication_tools.py
index ef94eabc..5c391be5 100644
--- a/wqflask/tests/utility/test_authentication_tools.py
+++ b/wqflask/tests/utility/test_authentication_tools.py
@@ -1,6 +1,6 @@
 """Tests for authentication tools"""
 import unittest
-import mock
+from unittest import mock
 
 from utility.authentication_tools import check_resource_availability
 from utility.authentication_tools import add_new_resource
diff --git a/wqflask/tests/utility/test_hmac.py b/wqflask/tests/utility/test_hmac.py
index 16b50771..7c61c0a6 100644
--- a/wqflask/tests/utility/test_hmac.py
+++ b/wqflask/tests/utility/test_hmac.py
@@ -2,7 +2,7 @@
 """Test hmac utility functions"""
 
 import unittest
-import mock
+from unittest import mock
 
 from utility.hmac import data_hmac
 from utility.hmac import url_for_hmac
diff --git a/wqflask/tests/wqflask/api/test_gen_menu.py b/wqflask/tests/wqflask/api/test_gen_menu.py
index bf41054d..84898bd1 100644
--- a/wqflask/tests/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/wqflask/api/test_gen_menu.py
@@ -1,6 +1,6 @@
 """Test cases for wqflask.api.gen_menu"""
 import unittest
-import mock
+from unittest import mock
 
 from wqflask import app
 from wqflask.api.gen_menu import gen_dropdown_json
-- 
cgit v1.2.3


From e247f43bf9bc31164948760694ff796bb469ae4c Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 28 Sep 2020 02:25:58 +0300
Subject: Update trait tests

* wqflask/tests/base/test_trait.py
(test_retrieve_trait_info_with_non_empty_lrs): Check
trait.LRS_score_repr is set correctly if trait.lrs is None.
(test_retrieve_trait_info_with_empty_lrs_field): Check
trait.LRS_score_repr and test_trait.LRS_location_repr is set correctly
if trait.lrs is None.
(test_retrieve_trait_info_with_empty_chr_field): Check
test_trait.LRS_score_repr and test_trait.LRS_location_repr is set
correctly if trait.locus is None.
---
 wqflask/tests/base/test_trait.py | 134 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index 960f2c81..1a3820f2 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -99,3 +99,137 @@ class TestRetrieveTraitInfo(unittest.TestCase):
                          "ファイルを画面毎に見て行くには、次のコマンドを使います。".decode('utf-8'))
         self.assertEqual(test_trait.authors,
                          "Jane Doe かいと".decode('utf-8'))
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_non_empty_lrs(self,
+                                                    resource_id_mock,
+                                                    g_mock,
+                                                    requests_mock):
+        """Test """
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, 2.37, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [2.7333, 2.1204]  # trait_info = g.db.execute(query).fetchone()
+        ]
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "2.4")
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_empty_lrs_field(self,
+                                                      resource_id_mock,
+                                                      g_mock,
+                                                      requests_mock):
+        """Test retrieve trait info with empty lrs field"""
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, None, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [2, 3]  # trait_info = g.db.execute(query).fetchone()
+        ]
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "N/A")
+        self.assertEqual(test_trait.LRS_location_repr,
+                         "Chr2: 3.000000")
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_empty_chr_field(self,
+                                                      resource_id_mock,
+                                                      g_mock,
+                                                      requests_mock):
+        """Test retrieve trait info with empty chr field"""
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, 2, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [None, 3]  # trait_info = g.db.execute(query).fetchone()
+        ]
+
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "N/A")
+        self.assertEqual(test_trait.LRS_location_repr,
+                         "N/A")
-- 
cgit v1.2.3


From 21ec6863d7f8380d66c39f1ed3b8d9cc0dc86e49 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 28 Sep 2020 18:34:53 +0300
Subject: Fix failing test

* wqflask/tests/base/test_trait.py: Add app_context to test class,
otherwise an error related to working outside the app_context is
generated. Adding the app_context is required when mocking "Flask.g".
---
 wqflask/tests/base/test_trait.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
index 60ebaee0..826ccefd 100644
--- a/wqflask/tests/base/test_trait.py
+++ b/wqflask/tests/base/test_trait.py
@@ -3,6 +3,7 @@
 import unittest
 from unittest import mock
 
+from wqflask import app
 from base.trait import GeneralTrait
 from base.trait import retrieve_trait_info
 
@@ -31,6 +32,14 @@ class MockTrait(GeneralTrait):
 
 class TestRetrieveTraitInfo(unittest.TestCase):
     """Tests for 'retrieve_trait_info'"""
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
     def test_retrieve_trait_info_with_empty_dataset(self):
         """Test that an exception is raised when dataset is empty"""
         with self.assertRaises(AssertionError):
@@ -104,7 +113,7 @@ class TestRetrieveTraitInfo(unittest.TestCase):
                                                     resource_id_mock,
                                                     g_mock,
                                                     requests_mock):
-        """Test """
+        """Test retrieve trait info when lrs has a value"""
         resource_id_mock.return_value = 1
         g_mock.db.execute.return_value.fetchone = mock.Mock()
         g_mock.db.execute.return_value.fetchone.side_effect = [
-- 
cgit v1.2.3


From ce728fa92e02725202bca486e8336b2e1158f4ef Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 29 Sep 2020 15:57:01 +0300
Subject: Add test for process_traits from collections.py

* wqflask/tests/wqflask/test_collect.py: Add it.
---
 wqflask/tests/wqflask/test_collect.py | 73 +++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 wqflask/tests/wqflask/test_collect.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_collect.py b/wqflask/tests/wqflask/test_collect.py
new file mode 100644
index 00000000..06609b4c
--- /dev/null
+++ b/wqflask/tests/wqflask/test_collect.py
@@ -0,0 +1,73 @@
+"""Test cases for some methods in collect.py"""
+
+import unittest
+import mock
+
+from flask import Flask
+from wqflask.collect import process_traits
+
+app = Flask(__name__)
+
+
+class MockSession:
+    """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def logged_in(self):
+        return self.is_logged_in
+
+
+class MockFlaskG:
+    """Helper class for mocking wqflask.collect.g.user_session"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def user_session(self):
+        if self.is_logged_in:
+            return MockSession(is_logged_in=True)
+        return MockSession()
+
+
+class TestCollect(unittest.TestCase):
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("wqflask.collect.g", MockFlaskG())
+    def test_process_traits_with_bytestring(self):
+        """
+        Test that the correct traits are returned when the user is logged
+        out and bytes are used.
+        """
+        self.assertEqual(process_traits(
+            b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+            b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+            b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+            b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
+            set(['1429252_at:HC_M2_0606_P',
+                 '1451401_a_at:HC_M2_0606_P',
+                 '1452447_at:HC_M2_0606_P',
+                 '1452452_at:HC_M2_0606_P']))
+
+    @mock.patch("wqflask.collect.g", MockFlaskG())
+    def test_process_traits_with_normal_string(self):
+        """
+        Test that the correct traits are returned when the user is logged
+        out and a normal string is used.
+        """
+        self.assertEqual(process_traits(
+            '1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+            '1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+            '1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+            '1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
+            set(['1429252_at:HC_M2_0606_P',
+                 '1451401_a_at:HC_M2_0606_P',
+                 '1452447_at:HC_M2_0606_P',
+                 '1452452_at:HC_M2_0606_P']))
-- 
cgit v1.2.3


From 475b6e333e6356103592b0983d5efb8e84eb73e7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 30 Sep 2020 02:09:27 +0300
Subject: Fix import in tests

---
 wqflask/tests/wqflask/test_collect.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_collect.py b/wqflask/tests/wqflask/test_collect.py
index 06609b4c..9a36132d 100644
--- a/wqflask/tests/wqflask/test_collect.py
+++ b/wqflask/tests/wqflask/test_collect.py
@@ -1,7 +1,7 @@
 """Test cases for some methods in collect.py"""
 
 import unittest
-import mock
+from unittest import mock
 
 from flask import Flask
 from wqflask.collect import process_traits
-- 
cgit v1.2.3


From 4d16656304b9702c124721e82ea0dcda3c40ae44 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 29 Sep 2020 15:57:01 +0300
Subject: Add test for process_traits from collections.py

* wqflask/tests/wqflask/test_collect.py: Add it.
---
 wqflask/tests/wqflask/test_collect.py | 57 +++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 wqflask/tests/wqflask/test_collect.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_collect.py b/wqflask/tests/wqflask/test_collect.py
new file mode 100644
index 00000000..6b8d7931
--- /dev/null
+++ b/wqflask/tests/wqflask/test_collect.py
@@ -0,0 +1,57 @@
+"""Test cases for some methods in collect.py"""
+
+import unittest
+import mock
+
+from flask import Flask
+from wqflask.collect import process_traits
+
+app = Flask(__name__)
+
+
+class MockSession:
+    """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def logged_in(self):
+        return self.is_logged_in
+
+
+class MockFlaskG:
+    """Helper class for mocking wqflask.collect.g.user_session"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def user_session(self):
+        if self.is_logged_in:
+            return MockSession(is_logged_in=True)
+        return MockSession()
+
+
+class TestCollect(unittest.TestCase):
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("wqflask.collect.g", MockFlaskG())
+    def test_process_traits_when_user_is_logged_out(self):
+        """
+        Test that the correct traits are returned when the user is logged
+        out
+        """
+        self.assertEqual(process_traits(
+            b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+            b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+            b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+            b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
+            set(['1429252_at:HC_M2_0606_P',
+                 '1451401_a_at:HC_M2_0606_P',
+                 '1452447_at:HC_M2_0606_P',
+                 '1452452_at:HC_M2_0606_P']))
-- 
cgit v1.2.3


From b2b7bacdbc8dc28dd062ebdb94698fca88f9b0cb Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 20 Oct 2020 22:19:56 +0300
Subject: Add pbkdf2 tests

* wqflask/tests/wqflask/test_pbkdf2.py: New tests.
---
 wqflask/tests/wqflask/test_pbkdf2.py | 61 ++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 wqflask/tests/wqflask/test_pbkdf2.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_pbkdf2.py b/wqflask/tests/wqflask/test_pbkdf2.py
new file mode 100644
index 00000000..a33fbd4f
--- /dev/null
+++ b/wqflask/tests/wqflask/test_pbkdf2.py
@@ -0,0 +1,61 @@
+"""Test cases pbkdf2"""
+
+import unittest
+from wqflask.pbkdf2 import pbkdf2_hex
+
+
+class TestPbkdf2(unittest.TestCase):
+    def test_pbkdf2_hex(self):
+        """
+        Test pbkdf2_hex function
+        """
+
+        for password, salt, iterations, keylen, expected_value in [
+                ('password', 'salt', 1, 20,
+                 '0c60c80f961f0e71f3a9b524af6012062fe037a6'),
+                ('password', 'salt', 2, 20,
+                 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'),
+                ('password', 'salt', 4096, 20,
+                 '4b007901b765489abead49d926f721d065a429c1'),
+                ('passwordPASSWORDpassword',
+                 'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+                 4096, 25,
+                 '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'),
+                ('pass\x00word', 'sa\x00lt', 4096, 16,
+                 '56fa6aa75548099dcc37d7f03425e0c3'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1, 16,
+                 'cdedb5281bb2f801565a1122b2563515'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1, 32,
+                 ('cdedb5281bb2f80'
+                  '1565a1122b256351'
+                  '50ad1f7a04bb9f3a33'
+                  '3ecc0e2e1f70837')),
+                ('password', 'ATHENA.MIT.EDUraeburn', 2, 16,
+                 '01dbee7f4a9e243e988b62c73cda935d'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 2, 32,
+                 ('01dbee7f4a9e243e9'
+                  '88b62c73cda935da05'
+                  '378b93244ec8f48a99'
+                  'e61ad799d86')),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1200, 32,
+                 ('5c08eb61fdf71e'
+                  '4e4ec3cf6ba1f55'
+                  '12ba7e52ddbc5e51'
+                  '42f708a31e2e62b1e13')),
+                ('X' * 64, 'pass phrase equals block size', 1200, 32,
+                 ('139c30c0966bc32ba'
+                  '55fdbf212530ac9c5'
+                  'ec59f1a452f5cc9ad'
+                  '940fea0598ed1')),
+                ('X' * 65, 'pass phrase exceeds block size', 1200, 32,
+                 ('9ccad6d468770cd'
+                  '51b10e6a68721be6'
+                  '11a8b4d282601db3'
+                  'b36be9246915ec82a'))
+        ]:
+            self.assertEqual(
+                pbkdf2_hex(data=password,
+                           salt=salt,
+                           iterations=iterations,
+                           keylen=keylen),
+                expected_value)
-- 
cgit v1.2.3


From 5d06524c8465064248cc3605c69dd32687ea7565 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 20 Oct 2020 22:55:19 +0300
Subject: Add tests for encoding password

* wqflask/tests/wqflask/test_user_login.py: New tests.
---
 wqflask/tests/wqflask/test_user_login.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 wqflask/tests/wqflask/test_user_login.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_user_login.py b/wqflask/tests/wqflask/test_user_login.py
new file mode 100644
index 00000000..61cd9ab9
--- /dev/null
+++ b/wqflask/tests/wqflask/test_user_login.py
@@ -0,0 +1,21 @@
+"""Test cases for some methods in login.py"""
+
+import unittest
+from wqflask.user_login import encode_password
+
+
+class TestUserLogin(unittest.TestCase):
+    def test_encode_password(self):
+        """
+        Test encode password
+        """
+        pass_gen_fields = {
+            "salt": "salt",
+            "hashfunc": "sha1",
+            "iterations": 4096,
+            "keylength": 20,
+        }
+        self.assertEqual(
+            encode_password(pass_gen_fields,
+                            "password").get("password"),
+            '4b007901b765489abead49d926f721d065a429c1')
-- 
cgit v1.2.3


From 76f425b1e76debe90f723c99594236853b05b979 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 26 Oct 2020 21:50:56 +0300
Subject: modified test file

---
 wqflask/tests/wqflask/show_trait/__init__.py       |   0
 .../wqflask/show_trait/test_export_trait_data.py   | 103 +++++++++++++++++++++
 2 files changed, 103 insertions(+)
 create mode 100644 wqflask/tests/wqflask/show_trait/__init__.py
 create mode 100644 wqflask/tests/wqflask/show_trait/test_export_trait_data.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/__init__.py b/wqflask/tests/wqflask/show_trait/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
new file mode 100644
index 00000000..f77f11c9
--- /dev/null
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -0,0 +1,103 @@
+import unittest
+from wqflask.show_trait.export_trait_data import dict_to_sorted_list,cmp_samples
+class TestDictionaryList(unittest.TestCase):
+	def setUp(self):
+		self.sample1={
+		"other":"exp1",
+		"name":"exp2"
+		}
+		self.sample2={
+		'se':1,
+		'num_cases':4,
+		'value':6,
+		"name":3
+
+		}
+		self.reversed={
+		"name":3,
+		'value':6,
+		'num_cases':4,
+		'se':1
+		}
+		self.oneItem={
+		'item1':"one"
+		}
+	def  test_dict_to_sortedlist(self):
+		'''Test for converting dict to sorted list'''
+		
+		self.assertEqual(['exp2','exp1'],dict_to_sorted_list(self.sample1))
+		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(self.sample2))
+		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(self.reversed))
+		self.assertEqual(["one"],dict_to_sorted_list(self.oneItem))
+		'''test that the func returns the values not the keys'''
+		self.assertFalse(['other','name']==['exp2','exp1'])
+
+
+
+class TestComparison(unittest.TestCase):
+	def setUp(self):
+		self.sampleA=[
+		[
+		('value','other'),
+		('name','test_name')
+		]
+		]
+		self.sampleB=[
+		[
+		('value','other'),
+		('unknown','test_name')
+		]
+		]
+		self.sampleC=[
+			[('other',"value"),
+			('name','value')
+			],
+			[
+		    ('name',"value"),
+		      ('value',"name")
+			],
+			[
+			('other',"value"),
+			('name','value'
+			)],
+			[
+			('name',"name1"),
+			('se',"valuex")
+			],
+			[(
+			'value',"name1"),
+			('se',"valuex")
+			],
+			[(
+			'other',"name1"),
+			('se',"valuex"
+			)
+			],
+			[(
+			'name',"name_val"),
+			('num_cases',"num_val")
+			],
+			[(
+			"other_a","val_a"),
+			('other_b',"val"
+			)
+			]]
+
+
+
+
+
+	def test_cmp_samples(self):
+		'''Test for func that does sample comparisons'''
+	
+		results=[cmp_samples(val[0],val[1]) for val in self.sampleA]
+		resultB=[cmp_samples(val[0],val[1]) for val in self.sampleB]
+		resultC=[cmp_samples(val[0],val[1]) for val in self.sampleC]
+		self.assertEqual(1,*results)
+		self.assertEqual(-1,*resultB)
+		self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1],resultC)
+
+
+
+ 
+
-- 
cgit v1.2.3


From 09bae9afdde636b84c8e42140f21ba3f60903d9b Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 27 Oct 2020 12:37:02 +0300
Subject: modified to use pep8 standards

---
 .../wqflask/show_trait/test_export_trait_data.py   | 59 +++++++++++-----------
 1 file changed, 30 insertions(+), 29 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index f77f11c9..c64196ff 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -1,54 +1,56 @@
 import unittest
-from wqflask.show_trait.export_trait_data import dict_to_sorted_list,cmp_samples
-class TestDictionaryList(unittest.TestCase):
-	def setUp(self):
-		self.sample1={
+from wqflask.show_trait.export_trait_data import dict_to_sorted_list
+from wqflask.show_trait.export_trait_data import cmp_samples
+
+class TestExportTraits(unittest.TestCase):
+	def test_dict_to_sortedlist(self):
+		'''Test for conversion of dict to sorted list'''
+		sample1={
 		"other":"exp1",
 		"name":"exp2"
 		}
-		self.sample2={
+		sample2={
 		'se':1,
 		'num_cases':4,
 		'value':6,
 		"name":3
 
 		}
-		self.reversed={
+		rever={
 		"name":3,
 		'value':6,
 		'num_cases':4,
 		'se':1
 		}
-		self.oneItem={
+		oneItem={
 		'item1':"one"
 		}
-	def  test_dict_to_sortedlist(self):
-		'''Test for converting dict to sorted list'''
-		
-		self.assertEqual(['exp2','exp1'],dict_to_sorted_list(self.sample1))
-		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(self.sample2))
-		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(self.reversed))
-		self.assertEqual(["one"],dict_to_sorted_list(self.oneItem))
+
+
+		self.assertEqual(['exp2','exp1'],dict_to_sorted_list(sample1))
+		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(sample2))
+		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(rever))
+		self.assertEqual(["one"],dict_to_sorted_list(oneItem))
 		'''test that the func returns the values not the keys'''
-		self.assertFalse(['other','name']==['exp2','exp1'])
+		self.assertFalse(['other','name']==dict_to_sorted_list(sample1))
 
+	def test_cmp_samples(self):
+		'''test for function that does comparisons of samples'''
 
 
-class TestComparison(unittest.TestCase):
-	def setUp(self):
-		self.sampleA=[
+		sampleA=[
 		[
 		('value','other'),
 		('name','test_name')
 		]
 		]
-		self.sampleB=[
+		sampleB=[
 		[
 		('value','other'),
 		('unknown','test_name')
 		]
 		]
-		self.sampleC=[
+		sampleC=[
 			[('other',"value"),
 			('name','value')
 			],
@@ -82,20 +84,19 @@ class TestComparison(unittest.TestCase):
 			('other_b',"val"
 			)
 			]]
+		results=[cmp_samples(val[0],val[1]) for val in sampleA]
+		resultB=[cmp_samples(val[0],val[1]) for val in sampleB]
+		resultC=[cmp_samples(val[0],val[1]) for val in sampleC]
+		self.assertEqual(1,*results)
+		self.assertEqual(-1,*resultB)
+		self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1],resultC)
+
+
 
 
 
 
 
-	def test_cmp_samples(self):
-		'''Test for func that does sample comparisons'''
-	
-		results=[cmp_samples(val[0],val[1]) for val in self.sampleA]
-		resultB=[cmp_samples(val[0],val[1]) for val in self.sampleB]
-		resultC=[cmp_samples(val[0],val[1]) for val in self.sampleC]
-		self.assertEqual(1,*results)
-		self.assertEqual(-1,*resultB)
-		self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1],resultC)
 
 
 
-- 
cgit v1.2.3


From cf4a7154bd7243aa1cf25e04d03d89cb8b43c7c5 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 27 Oct 2020 13:19:27 +0300
Subject: added changes to file

---
 .../wqflask/show_trait/test_export_trait_data.py   | 186 ++++++++++-----------
 1 file changed, 87 insertions(+), 99 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index c64196ff..2f95d219 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -2,103 +2,91 @@ import unittest
 from wqflask.show_trait.export_trait_data import dict_to_sorted_list
 from wqflask.show_trait.export_trait_data import cmp_samples
 
-class TestExportTraits(unittest.TestCase):
-	def test_dict_to_sortedlist(self):
-		'''Test for conversion of dict to sorted list'''
-		sample1={
-		"other":"exp1",
-		"name":"exp2"
-		}
-		sample2={
-		'se':1,
-		'num_cases':4,
-		'value':6,
-		"name":3
-
-		}
-		rever={
-		"name":3,
-		'value':6,
-		'num_cases':4,
-		'se':1
-		}
-		oneItem={
-		'item1':"one"
-		}
-
-
-		self.assertEqual(['exp2','exp1'],dict_to_sorted_list(sample1))
-		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(sample2))
-		self.assertEqual([3, 6, 1, 4],dict_to_sorted_list(rever))
-		self.assertEqual(["one"],dict_to_sorted_list(oneItem))
-		'''test that the func returns the values not the keys'''
-		self.assertFalse(['other','name']==dict_to_sorted_list(sample1))
-
-	def test_cmp_samples(self):
-		'''test for function that does comparisons of samples'''
-
-
-		sampleA=[
-		[
-		('value','other'),
-		('name','test_name')
-		]
-		]
-		sampleB=[
-		[
-		('value','other'),
-		('unknown','test_name')
-		]
-		]
-		sampleC=[
-			[('other',"value"),
-			('name','value')
-			],
-			[
-		    ('name',"value"),
-		      ('value',"name")
-			],
-			[
-			('other',"value"),
-			('name','value'
-			)],
-			[
-			('name',"name1"),
-			('se',"valuex")
-			],
-			[(
-			'value',"name1"),
-			('se',"valuex")
-			],
-			[(
-			'other',"name1"),
-			('se',"valuex"
-			)
-			],
-			[(
-			'name',"name_val"),
-			('num_cases',"num_val")
-			],
-			[(
-			"other_a","val_a"),
-			('other_b',"val"
-			)
-			]]
-		results=[cmp_samples(val[0],val[1]) for val in sampleA]
-		resultB=[cmp_samples(val[0],val[1]) for val in sampleB]
-		resultC=[cmp_samples(val[0],val[1]) for val in sampleC]
-		self.assertEqual(1,*results)
-		self.assertEqual(-1,*resultB)
-		self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1],resultC)
-
-
-
-
-
-
-
-
-
-
- 
 
+class TestExportTraits(unittest.TestCase):
+	"""Test methods related converting dict to sortedlist"""
+    def test_dict_to_sortedlist(self):
+        '''Test for conversion of dict to sorted list'''
+        sample1 = {
+            "other": "exp1",
+            "name": "exp2"
+        }
+        sample2 = {
+            "se": 1,
+            "num_cases": 4,
+            "value": 6,
+            "name": 3
+
+        }
+        rever = {
+            "name": 3,
+            "value": 6,
+            "num_cases": 4,
+            "se": 1
+        }
+        oneItem = {
+            "item1": "one"
+        }
+
+        self.assertEqual(["exp2", "exp1"], dict_to_sorted_list(sample1))
+        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2))
+        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever))
+        self.assertEqual(["one"], dict_to_sorted_list(oneItem))
+        '''test that the func returns the values not the keys'''
+        self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
+
+    def test_cmp_samples(self):
+        '''test for function that does comparisons of samples'''
+
+        sampleA = [
+            [
+                ("value", "other"),
+                ("name", "test_name")
+            ]
+        ]
+        sampleB = [
+            [
+                ("value", "other"),
+                ("unknown", "test_name")
+            ]
+        ]
+        sampleC = [
+            [("other", "value"),
+             ("name", "value")
+             ],
+            [
+                ("name", "value"),
+                ("value", "name")
+            ],
+            [
+                ("other", "value"),
+                ("name", "value"
+                 )],
+            [
+                ("name", "name1"),
+                ("se", "valuex")
+            ],
+            [(
+                "value", "name1"),
+                ("se", "valuex")
+             ],
+            [(
+                "other", "name1"),
+                ("se", "valuex"
+                 )
+             ],
+            [(
+                "name", "name_val"),
+                ("num_cases", "num_val")
+             ],
+            [(
+                "other_a", "val_a"),
+                ("other_b", "val"
+                 )
+             ]]
+        results = [cmp_samples(val[0], val[1]) for val in sampleA]
+        resultB = [cmp_samples(val[0], val[1]) for val in sampleB]
+        resultC = [cmp_samples(val[0], val[1]) for val in sampleC]
+        self.assertEqual(1, *results)
+        self.assertEqual(-1, *resultB)
+        self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC)
-- 
cgit v1.2.3


From 1cf15edbcc3833cd2ec0938d5c6591d7a2e219b7 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 27 Oct 2020 14:07:49 +0300
Subject: address failures

---
 wqflask/tests/wqflask/show_trait/test_export_trait_data.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 2f95d219..bc45a213 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -4,9 +4,10 @@ from wqflask.show_trait.export_trait_data import cmp_samples
 
 
 class TestExportTraits(unittest.TestCase):
-	"""Test methods related converting dict to sortedlist"""
+    """Test methods related to converting dict to sortedlist"""
+
     def test_dict_to_sortedlist(self):
-        '''Test for conversion of dict to sorted list'''
+        '''test for conversion of dict to sorted list'''
         sample1 = {
             "other": "exp1",
             "name": "exp2"
@@ -36,8 +37,7 @@ class TestExportTraits(unittest.TestCase):
         self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
 
     def test_cmp_samples(self):
-        '''test for function that does comparisons of samples'''
-
+        '''test for comparing samples function'''
         sampleA = [
             [
                 ("value", "other"),
@@ -83,10 +83,12 @@ class TestExportTraits(unittest.TestCase):
                 "other_a", "val_a"),
                 ("other_b", "val"
                  )
-             ]]
+             ]
+        ]
         results = [cmp_samples(val[0], val[1]) for val in sampleA]
         resultB = [cmp_samples(val[0], val[1]) for val in sampleB]
         resultC = [cmp_samples(val[0], val[1]) for val in sampleC]
+
         self.assertEqual(1, *results)
         self.assertEqual(-1, *resultB)
         self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC)
-- 
cgit v1.2.3


From abf3758d86c1ee37e458d79e62be69e4c23e515c Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 27 Oct 2020 14:26:06 +0300
Subject: switch from single quote to double quote

---
 wqflask/tests/wqflask/show_trait/test_export_trait_data.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index bc45a213..98d599b1 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -7,7 +7,7 @@ class TestExportTraits(unittest.TestCase):
     """Test methods related to converting dict to sortedlist"""
 
     def test_dict_to_sortedlist(self):
-        '''test for conversion of dict to sorted list'''
+        """test for conversion of dict to sorted list"""
         sample1 = {
             "other": "exp1",
             "name": "exp2"
@@ -33,11 +33,11 @@ class TestExportTraits(unittest.TestCase):
         self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2))
         self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever))
         self.assertEqual(["one"], dict_to_sorted_list(oneItem))
-        '''test that the func returns the values not the keys'''
+        """test that the func returns the values not the keys"""
         self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
 
     def test_cmp_samples(self):
-        '''test for comparing samples function'''
+        """test for comparing samples function"""
         sampleA = [
             [
                 ("value", "other"),
-- 
cgit v1.2.3


From 629553ec992c59500ef64b04b8fc9fb0500bcaee Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 28 Oct 2020 23:11:59 +0300
Subject: Add tests for cookie verification

---
 wqflask/tests/wqflask/test_user_session.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 wqflask/tests/wqflask/test_user_session.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/test_user_session.py b/wqflask/tests/wqflask/test_user_session.py
new file mode 100644
index 00000000..ebb0334a
--- /dev/null
+++ b/wqflask/tests/wqflask/test_user_session.py
@@ -0,0 +1,15 @@
+"""Test cases for some methods in user_session.py"""
+
+import unittest
+from wqflask.user_session import verify_cookie
+
+
+class TestUserSession(unittest.TestCase):
+    def test_verify_cookie(self):
+        """
+        Test cookie verification
+        """
+        self.assertEqual(
+            "3f4c1dbf-5b56-4260-87d6-f35445bda37e",
+            verify_cookie(("3f4c1dbf-5b56-4260-87d6-"
+                           "f35445bda37e:af4fcf5eace9e7c864ce")))
-- 
cgit v1.2.3


From 2120392705c6aa652bab280e98c84b9c33bc5902 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 28 Oct 2020 23:12:49 +0300
Subject: Add new test for hmac_creation with latin-1 secret

* wqflask/tests/utility/test_hmac.py (test_hmac_creation_with_cookie):
New test. For this test, use a secret that behaves differently when
encoded to either utf-8 or latin-1.
---
 wqflask/tests/utility/test_hmac.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/utility/test_hmac.py b/wqflask/tests/utility/test_hmac.py
index 7c61c0a6..4e3652f8 100644
--- a/wqflask/tests/utility/test_hmac.py
+++ b/wqflask/tests/utility/test_hmac.py
@@ -17,6 +17,19 @@ class TestHmacUtil(unittest.TestCase):
         """Test hmac creation with a utf-8 string"""
         self.assertEqual(hmac_creation("ファイ"), "7410466338cfe109e946")
 
+    @mock.patch("utility.hmac.app.config",
+                {'SECRET_HMAC_CODE': ('\x08\xdf\xfa\x93N\x80'
+                                      '\xd9\\H@\\\x9f`\x98d^'
+                                      '\xb4a;\xc6OM\x946a\xbc'
+                                      '\xfc\x80:*\xebc')})
+    def test_hmac_creation_with_cookie(self):
+        """Test hmac creation with a cookie"""
+        cookie = "3f4c1dbf-5b56-4260-87d6-f35445bda37e:af4fcf5eace9e7c864ce"
+        uuid_, _, signature = cookie.partition(":")
+        self.assertEqual(
+            hmac_creation(uuid_),
+            "af4fcf5eace9e7c864ce")
+
     @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
     def test_data_hmac(self):
         """Test data_hmac fn with a utf-8 string"""
-- 
cgit v1.2.3


From f745117da48e9d46e6a07fb7f930f208c489336a Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 29 Oct 2020 14:58:00 +0300
Subject: add test for show_trait/export_trait_data

---
 .../wqflask/show_trait/test_export_trait_data.py   | 49 +++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 98d599b1..0c280315 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -1,10 +1,57 @@
 import unittest
+from unittest import mock
 from wqflask.show_trait.export_trait_data import dict_to_sorted_list
 from wqflask.show_trait.export_trait_data import cmp_samples
-
+from wqflask.show_trait.export_trait_data import export_sample_table
 
 class TestExportTraits(unittest.TestCase):
     """Test methods related to converting dict to sortedlist"""
+    @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
+    @mock.patch("wqflask.show_trait.export_trait_data.get_export_metadata")
+    def test_export_sample_table(self, exp_metadata, dict_list):
+        """test for  exporting sample table"""
+        targs_obj = {
+            "export_data": """{
+                "primary_samples": [
+                    {
+                        "other": "germanotta",
+                        "name": "Sauroniops"
+                    }
+                ],
+                "other_samples": [
+                    {
+                        "se": 1,
+                        "num_cases": 4,
+                        "value": 6,
+                        "name": 3
+                    }
+                ]
+            }""",
+            "trait_display_name": "Hair_color",
+            "trait_id": "23177fdc-312e-4084-ad0c-f3eae785fff5",
+            "dataset": {
+            }
+        }
+        exp_metadata.return_value = [["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'], ["Phenotype:p1"], [
+            "Authors:N/A"], ["Title:research1"], ["Journal:N/A"], ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
+        expected = ('Hair_color',
+                    [['Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f'],
+                     ['Group:gp1'],
+                     ['Phenotype:p1'],
+                     ['Authors:N/A'],
+                     ['Title:research1'],
+                     ['Journal:N/A'],
+                     ['Dataset Link: '
+                      'http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1'],
+                     [],
+                     ['Sauroniops', 'germanotta'],
+                     [3, 6, 1, 4]])
+
+        dict_list.side_effect = [['Sauroniops', 'germanotta'], [3, 6, 1, 4]]
+
+        self.assertEqual(export_sample_table(targs_obj), expected)
+        exp_metadata.assert_called_with("23177fdc-312e-4084-ad0c-f3eae785fff5", {})
+        self.assertEqual(dict_list.call_count, 2)
 
     def test_dict_to_sortedlist(self):
         """test for conversion of dict to sorted list"""
-- 
cgit v1.2.3


From a7c4affd6b50b00ab8801b6daa96b07e88034209 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 29 Oct 2020 15:02:09 +0300
Subject: format file

---
 wqflask/tests/wqflask/show_trait/test_export_trait_data.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 0c280315..adecbf36 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -4,6 +4,7 @@ from wqflask.show_trait.export_trait_data import dict_to_sorted_list
 from wqflask.show_trait.export_trait_data import cmp_samples
 from wqflask.show_trait.export_trait_data import export_sample_table
 
+
 class TestExportTraits(unittest.TestCase):
     """Test methods related to converting dict to sortedlist"""
     @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
@@ -50,7 +51,8 @@ class TestExportTraits(unittest.TestCase):
         dict_list.side_effect = [['Sauroniops', 'germanotta'], [3, 6, 1, 4]]
 
         self.assertEqual(export_sample_table(targs_obj), expected)
-        exp_metadata.assert_called_with("23177fdc-312e-4084-ad0c-f3eae785fff5", {})
+        exp_metadata.assert_called_with(
+            "23177fdc-312e-4084-ad0c-f3eae785fff5", {})
         self.assertEqual(dict_list.call_count, 2)
 
     def test_dict_to_sortedlist(self):
-- 
cgit v1.2.3


From 242c334dbaa84c93a0c45bc80a050cd0e240d81b Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 29 Oct 2020 17:23:46 +0300
Subject: add test for show_trait

---
 .../wqflask/show_trait/test_export_trait_data.py      | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index adecbf36..488c9d63 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -16,7 +16,14 @@ class TestExportTraits(unittest.TestCase):
                 "primary_samples": [
                     {
                         "other": "germanotta",
-                        "name": "Sauroniops"
+                        "name": "Sauroniops",
+                        "se":{
+                        "name":"S2"
+                        },
+                        "num_cases":{
+                        "k1":"value"
+
+                        }
                     }
                 ],
                 "other_samples": [
@@ -33,8 +40,13 @@ class TestExportTraits(unittest.TestCase):
             "dataset": {
             }
         }
-        exp_metadata.return_value = [["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'], ["Phenotype:p1"], [
-            "Authors:N/A"], ["Title:research1"], ["Journal:N/A"], ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
+        exp_metadata.return_value = [
+            ["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'],
+            ["Phenotype:p1"], [
+                "Authors:N/A"],
+            ["Title:research1"],
+            ["Journal:N/A"],
+            ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
         expected = ('Hair_color',
                     [['Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f'],
                      ['Group:gp1'],
@@ -45,6 +57,7 @@ class TestExportTraits(unittest.TestCase):
                      ['Dataset Link: '
                       'http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1'],
                      [],
+                     ['Name', 'Value', 'SE', 'N'],
                      ['Sauroniops', 'germanotta'],
                      [3, 6, 1, 4]])
 
-- 
cgit v1.2.3


From fb9ff600a3cb420303632c8c8d690999a09846d0 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Fri, 30 Oct 2020 12:38:30 +0300
Subject: add test for get_export_metadata

---
 .../wqflask/show_trait/test_export_trait_data.py   | 62 ++++++++++++++++++++++
 1 file changed, 62 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 488c9d63..5d0655ce 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -3,10 +3,72 @@ from unittest import mock
 from wqflask.show_trait.export_trait_data import dict_to_sorted_list
 from wqflask.show_trait.export_trait_data import cmp_samples
 from wqflask.show_trait.export_trait_data import export_sample_table
+from wqflask.show_trait.export_trait_data import get_export_metadata
+
+
+class MockGeneral(object):
+    def __init__(self, obj):
+        for key, value in obj.items():
+            setattr(self, key, value)
+
+
+class MockChild(object):
+    pass
 
 
 class TestExportTraits(unittest.TestCase):
     """Test methods related to converting dict to sortedlist"""
+    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
+    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
+    def test_get_export_metadata_no_publish(self, mock_dataset, mock_trait):
+        """test for exporting metadata with no publish"""
+        mock_data_instance = MockGeneral(
+            {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
+
+        group_obj = MockChild()
+        group_obj.name = "name"
+        mock_data_instance.group = group_obj
+        mock_dataset.create_dataset.return_value = mock_data_instance
+        mock_trait.return_value = MockGeneral({"symbol": "", "description_display": "Description",
+                                               "title": "research1", "journal": "", "authors": ""})
+
+        results = get_export_metadata("random_id", "Temp")
+        expected = [["Record ID: random_id"],
+                    ["Trait URL: http://genenetwork.org/show_trait?trait_id=random_id&dataset=Temp"],
+                    ["Dataset: Temp"],
+                    ["Group: name"], []]
+
+        mock_dataset.create_dataset.assert_called_with("Temp")
+        mock_trait.assert_called_with(
+            dataset=mock_data_instance, name="random_id", cellid=None, get_qtl_info=False)
+        self.assertEqual(results, expected)
+
+    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
+    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
+    def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
+        """test for exporting metadata with dataset.type=Publish"""
+        mock_instance = MockGeneral({"type": "Publish", "dataset_name": "Temp",
+                                     "name": "Temp", "description_display": "Description goes here"})
+
+        group_obj = MockChild()
+        group_obj.name = "name"
+        mock_instance.group = group_obj
+        data_mock.create_dataset.return_value = mock_instance
+        trait_instance = MockGeneral({"symbol": "", "description_display": "Description",
+                                      "title": "research1", "journal": "", "authors": ""})
+        trait_mock.return_value = trait_instance
+
+        results = get_export_metadata(
+            "29ae0615-0d77-4814-97c7-c9e91f6bfd7b", "Temp")
+
+        expected = [['Phenotype ID: 29ae0615-0d77-4814-97c7-c9e91f6bfd7b'],
+                    ['Phenotype URL: http://genenetwork.org/show_trait?trait_id=29ae0615-0d77-4814-97c7-c9e91f6bfd7b&dataset=Temp'], [
+                        'Group: name'], ['Phenotype: Description'],
+                    ['Authors: N/A'], ['Title: research1'],
+                    ['Journal: N/A'], ['Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=Temp'], []]
+
+        self.assertEqual(results, expected)
+
     @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
     @mock.patch("wqflask.show_trait.export_trait_data.get_export_metadata")
     def test_export_sample_table(self, exp_metadata, dict_list):
-- 
cgit v1.2.3


From 7ba5eb8afcb251d271d24c4f8314cafd82d546bb Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sat, 31 Oct 2020 15:06:04 +0300
Subject: Use more descriptive variable and class names

---
 .../wqflask/show_trait/test_export_trait_data.py   | 38 +++++++++++-----------
 1 file changed, 19 insertions(+), 19 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 5d0655ce..085c6a30 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -6,13 +6,13 @@ from wqflask.show_trait.export_trait_data import export_sample_table
 from wqflask.show_trait.export_trait_data import get_export_metadata
 
 
-class MockGeneral(object):
+class AttributesSetterClass:
     def __init__(self, obj):
         for key, value in obj.items():
             setattr(self, key, value)
 
 
-class MockChild(object):
+class HelperClass:
     pass
 
 
@@ -22,15 +22,15 @@ class TestExportTraits(unittest.TestCase):
     @mock.patch("wqflask.show_trait.export_trait_data.data_set")
     def test_get_export_metadata_no_publish(self, mock_dataset, mock_trait):
         """test for exporting metadata with no publish"""
-        mock_data_instance = MockGeneral(
+        mock_dataset_attributes = AttributesSetterClass(
             {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
 
-        group_obj = MockChild()
-        group_obj.name = "name"
-        mock_data_instance.group = group_obj
-        mock_dataset.create_dataset.return_value = mock_data_instance
-        mock_trait.return_value = MockGeneral({"symbol": "", "description_display": "Description",
-                                               "title": "research1", "journal": "", "authors": ""})
+        mock_nested_attributes = HelperClass()
+        mock_nested_attributes.name = "name"
+        mock_dataset_attributes.group = mock_nested_attributes
+        mock_dataset.create_dataset.return_value = mock_dataset_attributes
+        mock_trait.return_value = AttributesSetterClass({"symbol": "", "description_display": "Description",
+                                                         "title": "research1", "journal": "", "authors": ""})
 
         results = get_export_metadata("random_id", "Temp")
         expected = [["Record ID: random_id"],
@@ -40,22 +40,22 @@ class TestExportTraits(unittest.TestCase):
 
         mock_dataset.create_dataset.assert_called_with("Temp")
         mock_trait.assert_called_with(
-            dataset=mock_data_instance, name="random_id", cellid=None, get_qtl_info=False)
+            dataset=mock_dataset_attributes, name="random_id", cellid=None, get_qtl_info=False)
         self.assertEqual(results, expected)
 
     @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
     @mock.patch("wqflask.show_trait.export_trait_data.data_set")
     def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
         """test for exporting metadata with dataset.type=Publish"""
-        mock_instance = MockGeneral({"type": "Publish", "dataset_name": "Temp",
-                                     "name": "Temp", "description_display": "Description goes here"})
-
-        group_obj = MockChild()
-        group_obj.name = "name"
-        mock_instance.group = group_obj
-        data_mock.create_dataset.return_value = mock_instance
-        trait_instance = MockGeneral({"symbol": "", "description_display": "Description",
-                                      "title": "research1", "journal": "", "authors": ""})
+        mock_dataset_attributes = AttributesSetterClass({"type": "Publish", "dataset_name": "Temp",
+                                               "name": "Temp", "description_display": "Description goes here"})
+
+        mock_nested_attributes = HelperClass()
+        mock_nested_attributes.name = "name"
+        mock_dataset_attributes.group = mock_nested_attributes
+        data_mock.create_dataset.return_value = mock_dataset_attributes
+        trait_instance = AttributesSetterClass({"symbol": "", "description_display": "Description",
+                                                "title": "research1", "journal": "", "authors": ""})
         trait_mock.return_value = trait_instance
 
         results = get_export_metadata(
-- 
cgit v1.2.3


From 544f24cb020136532689e3649be1902413f570c8 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sat, 31 Oct 2020 15:17:12 +0300
Subject: use descriptive variable names

---
 wqflask/tests/wqflask/show_trait/test_export_trait_data.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index 085c6a30..bd2f7dac 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -6,7 +6,7 @@ from wqflask.show_trait.export_trait_data import export_sample_table
 from wqflask.show_trait.export_trait_data import get_export_metadata
 
 
-class AttributesSetterClass:
+class AttributesSetter:
     def __init__(self, obj):
         for key, value in obj.items():
             setattr(self, key, value)
@@ -22,14 +22,14 @@ class TestExportTraits(unittest.TestCase):
     @mock.patch("wqflask.show_trait.export_trait_data.data_set")
     def test_get_export_metadata_no_publish(self, mock_dataset, mock_trait):
         """test for exporting metadata with no publish"""
-        mock_dataset_attributes = AttributesSetterClass(
+        mock_dataset_attributes = AttributesSetter(
             {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
 
         mock_nested_attributes = HelperClass()
         mock_nested_attributes.name = "name"
         mock_dataset_attributes.group = mock_nested_attributes
         mock_dataset.create_dataset.return_value = mock_dataset_attributes
-        mock_trait.return_value = AttributesSetterClass({"symbol": "", "description_display": "Description",
+        mock_trait.return_value = AttributesSetter({"symbol": "", "description_display": "Description",
                                                          "title": "research1", "journal": "", "authors": ""})
 
         results = get_export_metadata("random_id", "Temp")
@@ -47,14 +47,14 @@ class TestExportTraits(unittest.TestCase):
     @mock.patch("wqflask.show_trait.export_trait_data.data_set")
     def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
         """test for exporting metadata with dataset.type=Publish"""
-        mock_dataset_attributes = AttributesSetterClass({"type": "Publish", "dataset_name": "Temp",
-                                               "name": "Temp", "description_display": "Description goes here"})
+        mock_dataset_attributes = AttributesSetter({"type": "Publish", "dataset_name": "Temp",
+                                                         "name": "Temp", "description_display": "Description goes here"})
 
         mock_nested_attributes = HelperClass()
         mock_nested_attributes.name = "name"
         mock_dataset_attributes.group = mock_nested_attributes
         data_mock.create_dataset.return_value = mock_dataset_attributes
-        trait_instance = AttributesSetterClass({"symbol": "", "description_display": "Description",
+        trait_instance = AttributesSetter({"symbol": "", "description_display": "Description",
                                                 "title": "research1", "journal": "", "authors": ""})
         trait_mock.return_value = trait_instance
 
-- 
cgit v1.2.3


From 0b962eef391db6aae100a3283e89ee0ac0101f6b Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sat, 31 Oct 2020 15:23:45 +0300
Subject: remove redundant classes

---
 .../tests/wqflask/show_trait/test_export_trait_data.py   | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
index bd2f7dac..41761944 100644
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
@@ -12,10 +12,6 @@ class AttributesSetter:
             setattr(self, key, value)
 
 
-class HelperClass:
-    pass
-
-
 class TestExportTraits(unittest.TestCase):
     """Test methods related to converting dict to sortedlist"""
     @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
@@ -25,12 +21,11 @@ class TestExportTraits(unittest.TestCase):
         mock_dataset_attributes = AttributesSetter(
             {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
 
-        mock_nested_attributes = HelperClass()
-        mock_nested_attributes.name = "name"
+        mock_nested_attributes = AttributesSetter({"name": "name"})
         mock_dataset_attributes.group = mock_nested_attributes
         mock_dataset.create_dataset.return_value = mock_dataset_attributes
         mock_trait.return_value = AttributesSetter({"symbol": "", "description_display": "Description",
-                                                         "title": "research1", "journal": "", "authors": ""})
+                                                    "title": "research1", "journal": "", "authors": ""})
 
         results = get_export_metadata("random_id", "Temp")
         expected = [["Record ID: random_id"],
@@ -48,14 +43,13 @@ class TestExportTraits(unittest.TestCase):
     def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
         """test for exporting metadata with dataset.type=Publish"""
         mock_dataset_attributes = AttributesSetter({"type": "Publish", "dataset_name": "Temp",
-                                                         "name": "Temp", "description_display": "Description goes here"})
+                                                    "name": "Temp", "description_display": "Description goes here"})
 
-        mock_nested_attributes = HelperClass()
-        mock_nested_attributes.name = "name"
+        mock_nested_attributes = AttributesSetter({"name": "name"})
         mock_dataset_attributes.group = mock_nested_attributes
         data_mock.create_dataset.return_value = mock_dataset_attributes
         trait_instance = AttributesSetter({"symbol": "", "description_display": "Description",
-                                                "title": "research1", "journal": "", "authors": ""})
+                                           "title": "research1", "journal": "", "authors": ""})
         trait_mock.return_value = trait_instance
 
         results = get_export_metadata(
-- 
cgit v1.2.3


From 6d2d648126b112ca1455c6e1f2d344a4d8d27c1d Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 2 Nov 2020 11:06:36 +0300
Subject: add tests for show trait module

---
 .../tests/wqflask/show_trait/test_show_trait.py    | 267 +++++++++++++++++++++
 1 file changed, 267 insertions(+)
 create mode 100644 wqflask/tests/wqflask/show_trait/test_show_trait.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
new file mode 100644
index 00000000..37eae06e
--- /dev/null
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -0,0 +1,267 @@
+"""test for wqflask/show_trait/test_show_trait.py"""
+
+
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.show_trait.show_trait import check_if_attr_exists
+from wqflask.show_trait.show_trait import requests
+
+from wqflask.show_trait.show_trait import get_ncbi_summary
+
+from wqflask.show_trait.show_trait import has_num_cases
+
+from wqflask.show_trait.show_trait import get_table_widths
+
+from wqflask.show_trait.show_trait import get_categorical_variables
+from wqflask.show_trait.show_trait import get_trait_units
+
+from wqflask.show_trait.show_trait import get_nearest_marker
+
+from wqflask.show_trait.show_trait import get_genotype_scales
+
+class TraitObject:
+    def __init__(self, obj):
+        for key, value in obj.items():
+            setattr(self, key, value)
+
+
+class TestTraits(unittest.TestCase):
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    def test_check_if_attr_exists_truthy(self):
+        """"test if attributes exists with true return"""
+        trait_obj = TraitObject({"id_type": "id"})
+        trait_obj2 = TraitObject({"sample_name": ['samp1']})
+        results = check_if_attr_exists(trait_obj, "id_type")
+        result2 = check_if_attr_exists(trait_obj2, "sample_name")
+        self.assertIsInstance(trait_obj, TraitObject)
+        self.assertEqual(results, True)
+        self.assertEqual(result2, True)
+
+    def test_check_if_attr_exists_empty_attr(self):
+        """test if attributes exists with empty attributes"""
+        trait_obj = TraitObject({"sample": ""})
+        trait_obj2 = TraitObject({"group": None})
+        result = check_if_attr_exists(trait_obj, "sample")
+        result2 = check_if_attr_exists(trait_obj, "group")
+        self.assertEqual(result, False)
+        self.assertEqual(result2, False)
+
+    def test_check_if_attr_exists_falsey(self):
+        """check if attribute exists with empty attributes"""
+        trait_obj = TraitObject({})
+        results = check_if_attr_exists(trait_obj, "any")
+        self.assertEqual(results, False)
+
+    @mock.patch("wqflask.show_trait.show_trait.requests.get")
+    @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
+    def test_get_ncbi_summary_request_success(self, mock_exists, mock_get):
+        """test for getting ncbi summary with 
+        successful request"""
+        trait = TraitObject({"geneid": "id"})
+        mock_exists.return_value = True
+        content_json_string = """{
+          "result":{
+            "id":{
+              "summary":"this is a summary of the geneid"
+            }
+          }
+        }
+        """
+
+        get_return_obj = TraitObject({"content": content_json_string})
+
+        mock_get.return_value = get_return_obj
+
+        results = get_ncbi_summary(trait)
+        mock_exists.assert_called_once()
+        mock_get.assert_called_once_with(f"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=gene&id={trait.geneid}&retmode=json")
+
+        self.assertEqual(results, "this is a summary of the geneid")
+
+    @mock.patch("wqflask.show_trait.show_trait.requests.get")
+    @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
+    def test_get_ncbi_summary_request_fail(self, mock_exists, mock_get_fail):
+        """test for getting ncbi summary with request fail"""
+        trait = TraitObject({"geneid": "id"})
+        mock_exists.return_value = True
+        mock_get_fail.side_effect = Exception("an error occurred")
+        content_json_string = """{
+          "result":{
+            "id":{
+              "summary":"this is a summary of the geneid"
+            }
+          }
+        }
+        """
+
+        results = get_ncbi_summary(trait)
+        self.assertEqual(results, None)
+
+    def test_hash_num_cases_is_probeset(self):
+        """test for hash num_cases with dataset.type set to Probeset"""
+        create_dataset = TraitObject({"type": "ProbeSet"})
+        create_trait = TraitObject({"dataset": create_dataset})
+
+        self.assertEqual(has_num_cases(create_trait), False)
+
+    def test_hash_num_cases_no_probeset(self):
+        """test for hash num cases with dataset.type not Probeset"""
+        create_dataset = TraitObject({"type": "Temp"})
+
+        construct_data = {
+            "nm1": TraitObject({"num_cases": False}),
+            "nm2": TraitObject({"num_cases": True}),
+            "nm3": TraitObject({"num_cases": False})
+        }
+        construct_data2 = {
+            "nm1": TraitObject({"num_cases": False}),
+            "nm2": TraitObject({"num_cases": False}),
+            "nm3": TraitObject({"num_cases": False})
+
+
+        }
+
+        create_trait = TraitObject(
+            {"dataset": create_dataset, "data": construct_data})
+        create_trait2 = TraitObject(
+            {"dataset": create_dataset, "data": construct_data2})
+
+        results = has_num_cases(create_trait)
+
+        self.assertEqual(has_num_cases(create_trait), True)
+        self.assertEqual(has_num_cases(create_trait2), False)
+
+    def test_get_table_widths(self):
+        """test for getting table widths"""
+        sample_groups = [TraitObject({'se_exists': True, "attributes": ["attr1", "attr2", "attr3"]}
+                                    ), TraitObject(
+            {"se_exists": False, "attributes": ["at1", "at2"]
+             })]
+
+        results_with_numcase = get_table_widths(sample_groups, True)
+        result_no_numcase = get_table_widths(sample_groups, False)
+
+        results_one_sample = get_table_widths(
+            [TraitObject({"se_exists": True, "attributes": []})], True)
+        expected_with_numcase = (450, "750px")
+        expected_no_numcase = (450, "670px")
+        expected_one_sample = (250, "540px")
+
+        self.assertEqual(results_with_numcase, expected_with_numcase)
+        self.assertEqual(result_no_numcase, expected_no_numcase)
+        self.assertEqual(results_one_sample,
+                         expected_one_sample)
+
+    def test_get_categorical_variables_no_sample_attributes(self):
+        """test for getting categorical variable names with no samples"""
+        trait = TraitObject({})
+        sample_list = TraitObject({"se_exists": True, "attributes": []})
+
+        self.assertEqual(get_categorical_variables(trait, sample_list), [])
+
+    def test_get_categorical_variables_with_sample_attributes(self):
+        pass
+
+    def test_get_trait_units(self):
+        """test for gettting trait units"""
+        trait = TraitObject(
+            {"description_fmt": "[this is a description] another test [N/A]"})
+
+        trait_no_unit_type = TraitObject({"description_fmt": ""})
+
+        results = get_trait_units(trait)
+        results_no_unit = get_trait_units(trait_no_unit_type)
+        self.assertEqual(results, "this is a descriptionN/A")
+        self.assertEqual(results_no_unit, "Value")
+
+    @mock.patch("wqflask.show_trait.show_trait.g")
+    def test_get_nearest_marker(self, mock_db):
+        """test for getting nearest marker with non-empty db"""
+
+        mock_db.db.execute.return_value.fetchall.return_value = [
+            ["Geno1", "Geno2"], ["Geno3"]]
+
+        trait = TraitObject({"locus_chr": "test_chr", "locus_mb": "test_mb"})
+
+        group_name = TraitObject({"name": "group_name"})
+
+        this_db = TraitObject({"group": group_name})
+
+        results_with_item_db = get_nearest_marker(trait, this_db)
+
+        called_with_value = """SELECT Geno.Name
+               FROM Geno, GenoXRef, GenoFreeze
+               WHERE Geno.Chr = 'test_chr' AND
+                     GenoXRef.GenoId = Geno.Id AND
+                     GenoFreeze.Id = GenoXRef.GenoFreezeId AND
+                     GenoFreeze.Name = 'group_nameGeno'
+               ORDER BY ABS( Geno.Mb - test_mb) LIMIT 1"""
+
+        mock_db.db.execute.assert_called_with(called_with_value)
+
+        self.assertEqual(results_with_item_db, "Geno1")
+
+    @mock.patch("wqflask.show_trait.show_trait.g")
+    def test_get_nearest_marker_empty_db(self, mock_db):
+        """test for getting nearest marker with empty db"""
+        mock_db.db.execute.return_value.fetchall.return_value = []
+
+        trait = TraitObject({"locus_chr": "test_chr", "locus_mb": "test_mb"})
+        group_name = TraitObject({"name": "group_name"})
+        this_db = TraitObject({"group": group_name})
+
+        results_empty_db = get_nearest_marker(trait, this_db)
+        mock_db.db.execute.assert_called_once()
+        self.assertEqual(results_empty_db, "")
+
+    
+    @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile")
+    def test_get_genotype_scales_with_genofile_is_list(self,mock_get_scales):
+        """test for getting genotype scales with genofile as list """
+        #where genofile is instance of list
+        genofiles_list = [{"filename":"file1","location":"~/data/files/f1"},{"filename":"file2","location":"~/data/files/f2"},{"filename":"file3","location":"~/data/files/f3"}]
+
+        mock_get_scales.side_effect = [[["morgan", "cM"]],[["morgan", "cM"]],[["physic", "Mb"]]]
+
+        results = get_genotype_scales(genofiles_list)
+
+        expected_results = {
+        "~/data/files/f1":[["morgan","cM"]],
+        "~/data/files/f2":[["morgan","cM"]],
+        "~/data/files/f3":[["physic","Mb"]]
+        }
+
+        multiple_calls = [mock.call('~/data/files/f1'),mock.call('~/data/files/f2'),
+        mock.call('~/data/files/f3')]
+
+
+        mock_get_scales.assert_has_calls(multiple_calls)
+        self.assertEqual(results,expected_results)
+
+
+    @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile")
+    def test_genotype_scales_with_genofile_other(self,mock_get_scales):
+        """test for getting genotype scales with genofile as a strig"""
+        file_location = "~/another_file_location"
+        mock_get_scales.return_value = [["physic","Mb"]]
+
+        expected_results = {f"{file_location}":[["physic","Mb"]]}
+
+
+        self.assertEqual(get_genotype_scales(file_location),expected_results)
+        mock_get_scales.assert_called_once_with(file_location)
+
+
+
+
+
+
+
+    
-- 
cgit v1.2.3


From 62996d6b521379576992172fdee99468cb0260c9 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 2 Nov 2020 13:35:59 +0300
Subject: add  function docstring

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 37eae06e..1b5d2265 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -45,7 +45,7 @@ class TestTraits(unittest.TestCase):
         self.assertEqual(result2, True)
 
     def test_check_if_attr_exists_empty_attr(self):
-        """test if attributes exists with empty attributes"""
+        """test if attributes exists with false return"""
         trait_obj = TraitObject({"sample": ""})
         trait_obj2 = TraitObject({"group": None})
         result = check_if_attr_exists(trait_obj, "sample")
@@ -248,7 +248,7 @@ class TestTraits(unittest.TestCase):
 
     @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile")
     def test_genotype_scales_with_genofile_other(self,mock_get_scales):
-        """test for getting genotype scales with genofile as a strig"""
+        """test for getting genotype scales with genofile as a string"""
         file_location = "~/another_file_location"
         mock_get_scales.return_value = [["physic","Mb"]]
 
-- 
cgit v1.2.3


From 2883f17236081bc11faf4c4202393998bde0924d Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 2 Nov 2020 13:50:25 +0300
Subject: add better formatting

---
 .../tests/wqflask/show_trait/test_show_trait.py    | 47 +++++++++-------------
 1 file changed, 20 insertions(+), 27 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 1b5d2265..408797b9 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -20,6 +20,7 @@ from wqflask.show_trait.show_trait import get_nearest_marker
 
 from wqflask.show_trait.show_trait import get_genotype_scales
 
+
 class TraitObject:
     def __init__(self, obj):
         for key, value in obj.items():
@@ -141,7 +142,7 @@ class TestTraits(unittest.TestCase):
     def test_get_table_widths(self):
         """test for getting table widths"""
         sample_groups = [TraitObject({'se_exists': True, "attributes": ["attr1", "attr2", "attr3"]}
-                                    ), TraitObject(
+                                     ), TraitObject(
             {"se_exists": False, "attributes": ["at1", "at2"]
              })]
 
@@ -221,47 +222,39 @@ class TestTraits(unittest.TestCase):
         mock_db.db.execute.assert_called_once()
         self.assertEqual(results_empty_db, "")
 
-    
     @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile")
-    def test_get_genotype_scales_with_genofile_is_list(self,mock_get_scales):
+    def test_get_genotype_scales_with_genofile_is_list(self, mock_get_scales):
         """test for getting genotype scales with genofile as list """
-        #where genofile is instance of list
-        genofiles_list = [{"filename":"file1","location":"~/data/files/f1"},{"filename":"file2","location":"~/data/files/f2"},{"filename":"file3","location":"~/data/files/f3"}]
+        # where genofile is instance of list
+        genofiles_list = [{"filename": "file1", "location": "~/data/files/f1"},
+                          {"filename": "file2", "location": "~/data/files/f2"},
+                          {"filename": "file3", "location": "~/data/files/f3"}]
 
-        mock_get_scales.side_effect = [[["morgan", "cM"]],[["morgan", "cM"]],[["physic", "Mb"]]]
+        mock_get_scales.side_effect = [[["morgan", "cM"]],
+                                       [["morgan", "cM"]],
+                                       [["physic", "Mb"]]]
 
         results = get_genotype_scales(genofiles_list)
 
         expected_results = {
-        "~/data/files/f1":[["morgan","cM"]],
-        "~/data/files/f2":[["morgan","cM"]],
-        "~/data/files/f3":[["physic","Mb"]]
+            "~/data/files/f1": [["morgan", "cM"]],
+            "~/data/files/f2": [["morgan", "cM"]],
+            "~/data/files/f3": [["physic", "Mb"]]
         }
 
-        multiple_calls = [mock.call('~/data/files/f1'),mock.call('~/data/files/f2'),
-        mock.call('~/data/files/f3')]
-
+        multiple_calls = [mock.call('~/data/files/f1'), mock.call('~/data/files/f2'),
+                          mock.call('~/data/files/f3')]
 
         mock_get_scales.assert_has_calls(multiple_calls)
-        self.assertEqual(results,expected_results)
-
+        self.assertEqual(results, expected_results)
 
     @mock.patch("wqflask.show_trait.show_trait.get_scales_from_genofile")
-    def test_genotype_scales_with_genofile_other(self,mock_get_scales):
+    def test_genotype_scales_with_genofile_other(self, mock_get_scales):
         """test for getting genotype scales with genofile as a string"""
         file_location = "~/another_file_location"
-        mock_get_scales.return_value = [["physic","Mb"]]
+        mock_get_scales.return_value = [["physic", "Mb"]]
 
-        expected_results = {f"{file_location}":[["physic","Mb"]]}
+        expected_results = {f"{file_location}": [["physic", "Mb"]]}
 
-
-        self.assertEqual(get_genotype_scales(file_location),expected_results)
+        self.assertEqual(get_genotype_scales(file_location), expected_results)
         mock_get_scales.assert_called_once_with(file_location)
-
-
-
-
-
-
-
-    
-- 
cgit v1.2.3


From 251113ee34819afdc3e2abc63d59a01bd6a560cb Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 10:32:36 +0300
Subject: use assertTrue and assertFalse in while testing boolean

---
 .../tests/wqflask/show_trait/test_show_trait.py    | 38 ++++++++--------------
 1 file changed, 13 insertions(+), 25 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 408797b9..a2ef71dd 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -1,24 +1,12 @@
 """test for wqflask/show_trait/test_show_trait.py"""
 
-
 import unittest
 from unittest import mock
 from wqflask import app
-from wqflask.show_trait.show_trait import check_if_attr_exists
-from wqflask.show_trait.show_trait import requests
-
-from wqflask.show_trait.show_trait import get_ncbi_summary
-
-from wqflask.show_trait.show_trait import has_num_cases
-
-from wqflask.show_trait.show_trait import get_table_widths
-
-from wqflask.show_trait.show_trait import get_categorical_variables
-from wqflask.show_trait.show_trait import get_trait_units
-
-from wqflask.show_trait.show_trait import get_nearest_marker
-
-from wqflask.show_trait.show_trait import get_genotype_scales
+from wqflask.show_trait.show_trait import (check_if_attr_exists, get_ncbi_summary,
+                                           has_num_cases, get_table_widths,
+                                           get_categorical_variables,
+                                           get_trait_units, get_nearest_marker, get_genotype_scales, requests)
 
 
 class TraitObject:
@@ -42,8 +30,8 @@ class TestTraits(unittest.TestCase):
         results = check_if_attr_exists(trait_obj, "id_type")
         result2 = check_if_attr_exists(trait_obj2, "sample_name")
         self.assertIsInstance(trait_obj, TraitObject)
-        self.assertEqual(results, True)
-        self.assertEqual(result2, True)
+        self.assertTrue(results, True)
+        self.assertTrue(result2, True)
 
     def test_check_if_attr_exists_empty_attr(self):
         """test if attributes exists with false return"""
@@ -51,14 +39,14 @@ class TestTraits(unittest.TestCase):
         trait_obj2 = TraitObject({"group": None})
         result = check_if_attr_exists(trait_obj, "sample")
         result2 = check_if_attr_exists(trait_obj, "group")
-        self.assertEqual(result, False)
-        self.assertEqual(result2, False)
+        self.assertFalse(result, False)
+        self.assertFalse(result2, False)
 
     def test_check_if_attr_exists_falsey(self):
         """check if attribute exists with empty attributes"""
         trait_obj = TraitObject({})
         results = check_if_attr_exists(trait_obj, "any")
-        self.assertEqual(results, False)
+        self.assertFalse(results, False)
 
     @mock.patch("wqflask.show_trait.show_trait.requests.get")
     @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
@@ -110,7 +98,7 @@ class TestTraits(unittest.TestCase):
         create_dataset = TraitObject({"type": "ProbeSet"})
         create_trait = TraitObject({"dataset": create_dataset})
 
-        self.assertEqual(has_num_cases(create_trait), False)
+        self.assertFalse(has_num_cases(create_trait), False)
 
     def test_hash_num_cases_no_probeset(self):
         """test for hash num cases with dataset.type not Probeset"""
@@ -136,8 +124,8 @@ class TestTraits(unittest.TestCase):
 
         results = has_num_cases(create_trait)
 
-        self.assertEqual(has_num_cases(create_trait), True)
-        self.assertEqual(has_num_cases(create_trait2), False)
+        self.assertTrue(has_num_cases(create_trait), True)
+        self.assertFalse(has_num_cases(create_trait2), False)
 
     def test_get_table_widths(self):
         """test for getting table widths"""
@@ -171,7 +159,7 @@ class TestTraits(unittest.TestCase):
         pass
 
     def test_get_trait_units(self):
-        """test for gettting trait units"""
+        """test for getting trait units"""
         trait = TraitObject(
             {"description_fmt": "[this is a description] another test [N/A]"})
 
-- 
cgit v1.2.3


From ef0c9bb30523b32decc163dcb62c125e7ba5a076 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 16:50:23 +0300
Subject: switch from assertTrue/False to assertIs to make the tests tighter

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index a2ef71dd..f666912b 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -1,5 +1,4 @@
 """test for wqflask/show_trait/test_show_trait.py"""
-
 import unittest
 from unittest import mock
 from wqflask import app
@@ -30,8 +29,9 @@ class TestTraits(unittest.TestCase):
         results = check_if_attr_exists(trait_obj, "id_type")
         result2 = check_if_attr_exists(trait_obj2, "sample_name")
         self.assertIsInstance(trait_obj, TraitObject)
-        self.assertTrue(results, True)
-        self.assertTrue(result2, True)
+        self.assertIs(results, True)
+        self.assertIs(result2, True)
+        
 
     def test_check_if_attr_exists_empty_attr(self):
         """test if attributes exists with false return"""
@@ -39,14 +39,14 @@ class TestTraits(unittest.TestCase):
         trait_obj2 = TraitObject({"group": None})
         result = check_if_attr_exists(trait_obj, "sample")
         result2 = check_if_attr_exists(trait_obj, "group")
-        self.assertFalse(result, False)
-        self.assertFalse(result2, False)
+        self.assertIs(result, False)
+        self.assertIs(result2, False)
 
     def test_check_if_attr_exists_falsey(self):
         """check if attribute exists with empty attributes"""
         trait_obj = TraitObject({})
         results = check_if_attr_exists(trait_obj, "any")
-        self.assertFalse(results, False)
+        self.assertIs(results, False)
 
     @mock.patch("wqflask.show_trait.show_trait.requests.get")
     @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
@@ -124,8 +124,8 @@ class TestTraits(unittest.TestCase):
 
         results = has_num_cases(create_trait)
 
-        self.assertTrue(has_num_cases(create_trait), True)
-        self.assertFalse(has_num_cases(create_trait2), False)
+        self.assertIs(has_num_cases(create_trait), True)
+        self.assertIs(has_num_cases(create_trait2), False)
 
     def test_get_table_widths(self):
         """test for getting table widths"""
-- 
cgit v1.2.3


From 7da9a5206800d305f97b025e180300ca451ac92d Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 17:08:05 +0300
Subject: switch from assertFalse to assertIs

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index f666912b..ec45d558 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -31,7 +31,6 @@ class TestTraits(unittest.TestCase):
         self.assertIsInstance(trait_obj, TraitObject)
         self.assertIs(results, True)
         self.assertIs(result2, True)
-        
 
     def test_check_if_attr_exists_empty_attr(self):
         """test if attributes exists with false return"""
@@ -98,7 +97,7 @@ class TestTraits(unittest.TestCase):
         create_dataset = TraitObject({"type": "ProbeSet"})
         create_trait = TraitObject({"dataset": create_dataset})
 
-        self.assertFalse(has_num_cases(create_trait), False)
+        self.assertIs(has_num_cases(create_trait), False)
 
     def test_hash_num_cases_no_probeset(self):
         """test for hash num cases with dataset.type not Probeset"""
-- 
cgit v1.2.3


From 5d9b1f5d6380beaf8a2d713b5c33baa5a163b2bc Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 18:11:06 +0300
Subject: Add test for "/glossary" route

---
 wqflask/tests/integration/__init__.py      |  0
 wqflask/tests/integration/test_glossary.py | 28 ++++++++++++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 wqflask/tests/integration/__init__.py
 create mode 100644 wqflask/tests/integration/test_glossary.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/integration/__init__.py b/wqflask/tests/integration/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/integration/test_glossary.py b/wqflask/tests/integration/test_glossary.py
new file mode 100644
index 00000000..c9f1e62a
--- /dev/null
+++ b/wqflask/tests/integration/test_glossary.py
@@ -0,0 +1,28 @@
+"Integration tests for glossary"
+import unittest
+
+from bs4 import BeautifulSoup
+
+from wqflask import app
+
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for glossary"""
+
+    def setUp(self):
+        self.app = app.test_client()
+
+    def tearDown(self):
+        pass
+
+    def test_glossary_page(self):
+        """Test that the glossary page is rendered properly"""
+        response = self.app.get('/glossary', follow_redirects=True)
+        html_content = BeautifulSoup(response.data, "lxml")
+        self.assertEqual(html_content.find("title").get_text(),
+                         "Glossary GeneNetwork 2")
+        self.assertEqual(
+            html_content.find(
+                'p',
+                attrs={'id': 'mytest'}).get_text(),
+            "Test")
-- 
cgit v1.2.3


From f4a3652ee5b8087f551553df9498d5f00e169a86 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 18:13:57 +0300
Subject: Separate unittests from integration tests

---
 wqflask/tests/base/__init__.py                     |   0
 wqflask/tests/base/data.py                         | 110 ------
 wqflask/tests/base/test_data_set.py                | 181 ---------
 wqflask/tests/base/test_general_object.py          |  40 --
 wqflask/tests/base/test_trait.py                   | 241 ------------
 wqflask/tests/base/test_webqtl_case_data.py        |  39 --
 wqflask/tests/unit/__init__.py                     |   0
 wqflask/tests/unit/base/__init__.py                |   0
 wqflask/tests/unit/base/data.py                    | 110 ++++++
 wqflask/tests/unit/base/test_data_set.py           | 181 +++++++++
 wqflask/tests/unit/base/test_general_object.py     |  40 ++
 wqflask/tests/unit/base/test_trait.py              | 241 ++++++++++++
 wqflask/tests/unit/base/test_webqtl_case_data.py   |  39 ++
 wqflask/tests/unit/utility/__init__.py             |   0
 .../unit/utility/test_authentication_tools.py      | 189 ++++++++++
 wqflask/tests/unit/utility/test_chunks.py          |  19 +
 wqflask/tests/unit/utility/test_corestats.py       |  55 +++
 .../tests/unit/utility/test_corr_result_helpers.py |  32 ++
 wqflask/tests/unit/utility/test_formatting.py      |  33 ++
 wqflask/tests/unit/utility/test_hmac.py            |  52 +++
 wqflask/tests/unit/wqflask/__init__.py             |   0
 wqflask/tests/unit/wqflask/api/__init__.py         |   0
 wqflask/tests/unit/wqflask/api/test_gen_menu.py    | 413 +++++++++++++++++++++
 .../unit/wqflask/marker_regression/__init__.py     |   0
 .../test_display_mapping_results.py                | 156 ++++++++
 wqflask/tests/unit/wqflask/show_trait/__init__.py  |   0
 .../wqflask/show_trait/test_export_trait_data.py   | 212 +++++++++++
 wqflask/tests/unit/wqflask/test_collect.py         |  73 ++++
 wqflask/tests/unit/wqflask/test_pbkdf2.py          |  61 +++
 wqflask/tests/unit/wqflask/test_user_login.py      |  21 ++
 wqflask/tests/unit/wqflask/test_user_session.py    |  15 +
 wqflask/tests/utility/__init__.py                  |   0
 wqflask/tests/utility/test_authentication_tools.py | 189 ----------
 wqflask/tests/utility/test_chunks.py               |  19 -
 wqflask/tests/utility/test_corestats.py            |  55 ---
 wqflask/tests/utility/test_corr_result_helpers.py  |  32 --
 wqflask/tests/utility/test_formatting.py           |  33 --
 wqflask/tests/utility/test_hmac.py                 |  52 ---
 wqflask/tests/wqflask/__init__.py                  |   0
 wqflask/tests/wqflask/api/__init__.py              |   0
 wqflask/tests/wqflask/api/test_gen_menu.py         | 413 ---------------------
 .../tests/wqflask/marker_regression/__init__.py    |   0
 .../test_display_mapping_results.py                | 156 --------
 wqflask/tests/wqflask/show_trait/__init__.py       |   0
 .../wqflask/show_trait/test_export_trait_data.py   | 212 -----------
 wqflask/tests/wqflask/test_collect.py              |  73 ----
 wqflask/tests/wqflask/test_pbkdf2.py               |  61 ---
 wqflask/tests/wqflask/test_user_login.py           |  21 --
 wqflask/tests/wqflask/test_user_session.py         |  15 -
 wqflask/wqflask/templates/glossary.html            |   2 +-
 50 files changed, 1943 insertions(+), 1943 deletions(-)
 delete mode 100644 wqflask/tests/base/__init__.py
 delete mode 100644 wqflask/tests/base/data.py
 delete mode 100644 wqflask/tests/base/test_data_set.py
 delete mode 100644 wqflask/tests/base/test_general_object.py
 delete mode 100644 wqflask/tests/base/test_trait.py
 delete mode 100644 wqflask/tests/base/test_webqtl_case_data.py
 create mode 100644 wqflask/tests/unit/__init__.py
 create mode 100644 wqflask/tests/unit/base/__init__.py
 create mode 100644 wqflask/tests/unit/base/data.py
 create mode 100644 wqflask/tests/unit/base/test_data_set.py
 create mode 100644 wqflask/tests/unit/base/test_general_object.py
 create mode 100644 wqflask/tests/unit/base/test_trait.py
 create mode 100644 wqflask/tests/unit/base/test_webqtl_case_data.py
 create mode 100644 wqflask/tests/unit/utility/__init__.py
 create mode 100644 wqflask/tests/unit/utility/test_authentication_tools.py
 create mode 100644 wqflask/tests/unit/utility/test_chunks.py
 create mode 100644 wqflask/tests/unit/utility/test_corestats.py
 create mode 100644 wqflask/tests/unit/utility/test_corr_result_helpers.py
 create mode 100644 wqflask/tests/unit/utility/test_formatting.py
 create mode 100644 wqflask/tests/unit/utility/test_hmac.py
 create mode 100644 wqflask/tests/unit/wqflask/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/api/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/api/test_gen_menu.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
 create mode 100644 wqflask/tests/unit/wqflask/show_trait/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py
 create mode 100644 wqflask/tests/unit/wqflask/test_collect.py
 create mode 100644 wqflask/tests/unit/wqflask/test_pbkdf2.py
 create mode 100644 wqflask/tests/unit/wqflask/test_user_login.py
 create mode 100644 wqflask/tests/unit/wqflask/test_user_session.py
 delete mode 100644 wqflask/tests/utility/__init__.py
 delete mode 100644 wqflask/tests/utility/test_authentication_tools.py
 delete mode 100644 wqflask/tests/utility/test_chunks.py
 delete mode 100644 wqflask/tests/utility/test_corestats.py
 delete mode 100644 wqflask/tests/utility/test_corr_result_helpers.py
 delete mode 100644 wqflask/tests/utility/test_formatting.py
 delete mode 100644 wqflask/tests/utility/test_hmac.py
 delete mode 100644 wqflask/tests/wqflask/__init__.py
 delete mode 100644 wqflask/tests/wqflask/api/__init__.py
 delete mode 100644 wqflask/tests/wqflask/api/test_gen_menu.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/__init__.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
 delete mode 100644 wqflask/tests/wqflask/show_trait/__init__.py
 delete mode 100644 wqflask/tests/wqflask/show_trait/test_export_trait_data.py
 delete mode 100644 wqflask/tests/wqflask/test_collect.py
 delete mode 100644 wqflask/tests/wqflask/test_pbkdf2.py
 delete mode 100644 wqflask/tests/wqflask/test_user_login.py
 delete mode 100644 wqflask/tests/wqflask/test_user_session.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/base/__init__.py b/wqflask/tests/base/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/base/data.py b/wqflask/tests/base/data.py
deleted file mode 100644
index 06a5a989..00000000
--- a/wqflask/tests/base/data.py
+++ /dev/null
@@ -1,110 +0,0 @@
-gen_menu_json = """
-{
-  "datasets": {
-    "human": {
-      "HLC": {
-        "Liver mRNA": [
-          [
-            "320",
-            "HLC_0311",
-            "GSE9588 Human Liver Normal (Mar11) Both Sexes"
-          ]
-        ],
-        "Phenotypes": [
-          [
-            "635",
-            "HLCPublish",
-            "HLC Published Phenotypes"
-          ]
-        ]
-      }
-    },
-    "mouse": {
-      "BXD": {
-        "Genotypes": [
-          [
-            "600",
-            "BXDGeno",
-            "BXD Genotypes"
-          ]
-        ],
-        "Hippocampus mRNA": [
-          [
-            "112",
-            "HC_M2_0606_P",
-            "Hippocampus Consortium M430v2 (Jun06) PDNN"
-          ]
-        ],
-        "Phenotypes": [
-          [
-            "602",
-            "BXDPublish",
-            "BXD Published Phenotypes"
-          ]
-        ]
-      }
-    }
-  },
-  "groups": {
-    "human": [
-      [
-        "HLC",
-        "Liver: Normal Gene Expression with Genotypes (Merck)",
-        "Family:None"
-      ]
-    ],
-    "mouse": [
-      [
-        "BXD",
-        "BXD",
-        "Family:None"
-      ]
-    ]
-  },
-  "species": [
-    [
-      "human",
-      "Human"
-    ],
-    [
-      "mouse",
-      "Mouse"
-    ]
-  ],
-  "types": {
-    "human": {
-      "HLC": [
-        [
-          "Phenotypes",
-          "Traits and Cofactors",
-          "Phenotypes"
-        ],
-        [
-          "Liver mRNA",
-          "Liver mRNA",
-          "Molecular Trait Datasets"
-        ]
-      ]
-    },
-    "mouse": {
-      "BXD": [
-        [
-          "Phenotypes",
-          "Traits and Cofactors",
-          "Phenotypes"
-        ],
-        [
-          "Genotypes",
-          "DNA Markers and SNPs",
-          "Genotypes"
-        ],
-        [
-          "Hippocampus mRNA",
-          "Hippocampus mRNA",
-          "Molecular Trait Datasets"
-        ]
-      ]
-    }
-  }
-}
-"""
diff --git a/wqflask/tests/base/test_data_set.py b/wqflask/tests/base/test_data_set.py
deleted file mode 100644
index 96563a16..00000000
--- a/wqflask/tests/base/test_data_set.py
+++ /dev/null
@@ -1,181 +0,0 @@
-"""Tests for wqflask/base/data_set.py"""
-
-import unittest
-from unittest import mock
-
-from wqflask import app
-from .data import gen_menu_json
-from base.data_set import DatasetType
-
-
-class TestDataSetTypes(unittest.TestCase):
-    """Tests for the DataSetType class"""
-
-    def setUp(self):
-        self.test_dataset = """
-            {
-                "AD-cases-controls-MyersGeno": "Geno",
-                "AD-cases-controls-MyersPublish": "Publish",
-                "AKXDGeno": "Geno",
-                "AXBXAGeno": "Geno",
-                "AXBXAPublish": "Publish",
-                "Aging-Brain-UCIPublish": "Publish",
-                "All Phenotypes": "Publish",
-                "B139_K_1206_M": "ProbeSet",
-                "B139_K_1206_R": "ProbeSet"
-            }
-            """
-        self.app_context = app.app_context()
-        self.app_context.push()
-
-    def tearDown(self):
-        self.app_context.pop()
-
-    @mock.patch('base.data_set.g')
-    def test_data_set_type(self, db_mock):
-        """Test that DatasetType returns correctly if the Redis Instance is not empty
-        and the name variable exists in the dictionary
-
-        """
-        with app.app_context():
-            db_mock.get = mock.Mock()
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = self.test_dataset
-            self.assertEqual(DatasetType(redis_mock)
-                             ("All Phenotypes"), "Publish")
-            redis_mock.get.assert_called_once_with("dataset_structure")
-
-    @mock.patch('base.data_set.requests.get')
-    def test_data_set_type_with_empty_redis(self, request_mock):
-        """Test that DatasetType returns correctly if the Redis Instance is empty and
-        the name variable exists in the dictionary
-
-        """
-        with app.app_context():
-            request_mock.return_value.content = gen_menu_json
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = None
-            data_set = DatasetType(redis_mock)
-            self.assertEqual(data_set("BXDGeno"), "Geno")
-            self.assertEqual(data_set("BXDPublish"), "Publish")
-            self.assertEqual(data_set("HLC_0311"), "ProbeSet")
-
-            redis_mock.set.assert_called_once_with(
-                "dataset_structure",
-                ('{"HLC_0311": "ProbeSet", '
-                 '"HLCPublish": "Publish", '
-                 '"BXDGeno": "Geno", '
-                 '"HC_M2_0606_P": "ProbeSet", '
-                 '"BXDPublish": "Publish"}'))
-
-    @mock.patch('base.data_set.g')
-    def test_set_dataset_key_mrna(self, db_mock):
-        with app.app_context():
-            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = self.test_dataset
-            data_set = DatasetType(redis_mock)
-            data_set.set_dataset_key("mrna_expr", "Test")
-            self.assertEqual(data_set("Test"), "ProbeSet")
-            redis_mock.set.assert_called_once_with(
-                "dataset_structure",
-                ('{"AD-cases-controls-MyersGeno": "Geno", '
-                 '"AD-cases-controls-MyersPublish": "Publish", '
-                 '"AKXDGeno": "Geno", '
-                 '"AXBXAGeno": "Geno", '
-                 '"AXBXAPublish": "Publish", '
-                 '"Aging-Brain-UCIPublish": "Publish", '
-                 '"All Phenotypes": "Publish", '
-                 '"B139_K_1206_M": "ProbeSet", '
-                 '"B139_K_1206_R": "ProbeSet", '
-                 '"Test": "ProbeSet"}'))
-
-            db_mock.db.execute.assert_called_with(
-                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
-                 "WHERE ProbeSetFreeze.Name = \"Test\" ")
-            )
-
-    @mock.patch('base.data_set.g')
-    def test_set_dataset_key_pheno(self, db_mock):
-        with app.app_context():
-            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = self.test_dataset
-            data_set = DatasetType(redis_mock)
-            data_set.set_dataset_key("pheno", "Test")
-            self.assertEqual(data_set("Test"), "Publish")
-            redis_mock.set.assert_called_once_with(
-                "dataset_structure",
-                ('{"AD-cases-controls-MyersGeno": "Geno", '
-                 '"AD-cases-controls-MyersPublish": "Publish", '
-                 '"AKXDGeno": "Geno", '
-                 '"AXBXAGeno": "Geno", '
-                 '"AXBXAPublish": "Publish", '
-                 '"Aging-Brain-UCIPublish": "Publish", '
-                 '"All Phenotypes": "Publish", '
-                 '"B139_K_1206_M": "ProbeSet", '
-                 '"B139_K_1206_R": "ProbeSet", '
-                 '"Test": "Publish"}'))
-            db_mock.db.execute.assert_called_with(
-                ("SELECT InfoFiles.GN_AccesionId "
-                 "FROM InfoFiles, PublishFreeze, InbredSet "
-                 "WHERE InbredSet.Name = 'Test' AND "
-                 "PublishFreeze.InbredSetId = InbredSet.Id AND "
-                 "InfoFiles.InfoPageName = PublishFreeze.Name")
-            )
-
-    @mock.patch('base.data_set.g')
-    def test_set_dataset_other_pheno(self, db_mock):
-        with app.app_context():
-            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = self.test_dataset
-            data_set = DatasetType(redis_mock)
-            data_set.set_dataset_key("other_pheno", "Test")
-            self.assertEqual(data_set("Test"), "Publish")
-
-            redis_mock.set.assert_called_once_with(
-                "dataset_structure",
-                ('{"AD-cases-controls-MyersGeno": "Geno", '
-                 '"AD-cases-controls-MyersPublish": "Publish", '
-                 '"AKXDGeno": "Geno", '
-                 '"AXBXAGeno": "Geno", '
-                 '"AXBXAPublish": "Publish", '
-                 '"Aging-Brain-UCIPublish": "Publish", '
-                 '"All Phenotypes": "Publish", '
-                 '"B139_K_1206_M": "ProbeSet", '
-                 '"B139_K_1206_R": "ProbeSet", '
-                 '"Test": "Publish"}'))
-
-            db_mock.db.execute.assert_called_with(
-                ("SELECT PublishFreeze.Name " +
-                 "FROM PublishFreeze, InbredSet " +
-                 "WHERE InbredSet.Name = 'Test' AND "
-                 "PublishFreeze.InbredSetId = InbredSet.Id")
-            )
-
-    @mock.patch('base.data_set.g')
-    def test_set_dataset_geno(self, db_mock):
-        with app.app_context():
-            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
-            redis_mock = mock.Mock()
-            redis_mock.get.return_value = self.test_dataset
-            data_set = DatasetType(redis_mock)
-            data_set.set_dataset_key("geno", "Test")
-            self.assertEqual(data_set("Test"), "Geno")
-            redis_mock.set.assert_called_once_with(
-                "dataset_structure",
-                ('{"AD-cases-controls-MyersGeno": "Geno", '
-                 '"AD-cases-controls-MyersPublish": "Publish", '
-                 '"AKXDGeno": "Geno", '
-                 '"AXBXAGeno": "Geno", '
-                 '"AXBXAPublish": "Publish", '
-                 '"Aging-Brain-UCIPublish": "Publish", '
-                 '"All Phenotypes": "Publish", '
-                 '"B139_K_1206_M": "ProbeSet", '
-                 '"B139_K_1206_R": "ProbeSet", '
-                 '"Test": "Geno"}'))
-
-            db_mock.db.execute.assert_called_with(
-                ("SELECT GenoFreeze.Id FROM "
-                 "GenoFreeze WHERE GenoFreeze.Name = \"Test\" "))
diff --git a/wqflask/tests/base/test_general_object.py b/wqflask/tests/base/test_general_object.py
deleted file mode 100644
index 00fd3c72..00000000
--- a/wqflask/tests/base/test_general_object.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import unittest
-
-from base.GeneralObject import GeneralObject
-
-
-class TestGeneralObjectTests(unittest.TestCase):
-    """
-    Test the GeneralObject base class
-    """
-
-    def test_object_contents(self):
-        """Test whether base contents are stored properly"""
-        test_obj = GeneralObject("a", "b", "c")
-        self.assertEqual("abc", ''.join(test_obj.contents))
-        self.assertEqual(len(test_obj), 0)
-
-    def test_object_dict(self):
-        """Test whether the base class is printed properly"""
-        test_obj = GeneralObject("a", name="test", value=1)
-        self.assertEqual(str(test_obj), "name = test\nvalue = 1\n")
-        self.assertEqual(
-            repr(test_obj), "contents = ['a']\nname = test\nvalue = 1\n")
-        self.assertEqual(len(test_obj), 2)
-        self.assertEqual(test_obj["value"], 1)
-        test_obj["test"] = 1
-        self.assertEqual(test_obj["test"], 1)
-
-    def test_get_attribute(self):
-        "Test that getattr works"
-        test_obj = GeneralObject("a", name="test", value=1)
-        self.assertEqual(getattr(test_obj, "value", None), 1)
-        self.assertEqual(getattr(test_obj, "non-existent", None), None)
-
-    def test_object_comparisons(self):
-        "Test that 2 objects of the same length are equal"
-        test_obj1 = GeneralObject("a", name="test", value=1)
-        test_obj2 = GeneralObject("b", name="test2", value=2)
-        test_obj3 = GeneralObject("a", name="test", x=1, y=2)
-        self.assertTrue(test_obj1 == test_obj2)
-        self.assertFalse(test_obj1 == test_obj3)
diff --git a/wqflask/tests/base/test_trait.py b/wqflask/tests/base/test_trait.py
deleted file mode 100644
index 826ccefd..00000000
--- a/wqflask/tests/base/test_trait.py
+++ /dev/null
@@ -1,241 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Tests wqflask/base/trait.py"""
-import unittest
-from unittest import mock
-
-from wqflask import app
-from base.trait import GeneralTrait
-from base.trait import retrieve_trait_info
-
-
-class TestResponse:
-    """Mock Test Response after a request"""
-    @property
-    def content(self):
-        """Mock the content from Requests.get(params).content"""
-        return "[1, 2, 3, 4]"
-
-
-class TestNilResponse:
-    """Mock Test Response after a request"""
-    @property
-    def content(self):
-        """Mock the content from Requests.get(params).content"""
-        return "{}"
-
-
-class MockTrait(GeneralTrait):
-    @property
-    def wikidata_alias_fmt(self):
-        return "Mock alias"
-
-
-class TestRetrieveTraitInfo(unittest.TestCase):
-    """Tests for 'retrieve_trait_info'"""
-
-    def setUp(self):
-        self.app_context = app.app_context()
-        self.app_context.push()
-
-    def tearDown(self):
-        self.app_context.pop()
-
-    def test_retrieve_trait_info_with_empty_dataset(self):
-        """Test that an exception is raised when dataset is empty"""
-        with self.assertRaises(AssertionError):
-            retrieve_trait_info(trait=mock.MagicMock(),
-                                dataset={})
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g', mock.Mock())
-    def test_retrieve_trait_info_with_empty_trait_info(self,
-                                                       requests_mock):
-        """Empty trait info"""
-        requests_mock.return_value = TestNilResponse()
-        with self.assertRaises(KeyError):
-            retrieve_trait_info(trait=mock.MagicMock(),
-                                dataset=mock.MagicMock())
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g', mock.Mock())
-    def test_retrieve_trait_info_with_non_empty_trait_info(self,
-                                                           requests_mock):
-        """Test that attributes are set"""
-        mock_dataset = mock.MagicMock()
-        requests_mock.return_value = TestResponse()
-        type(mock_dataset).display_fields = mock.PropertyMock(
-            return_value=["a", "b", "c", "d"])
-        test_trait = retrieve_trait_info(trait=MockTrait(dataset=mock_dataset),
-                                         dataset=mock_dataset)
-        self.assertEqual(test_trait.a, 1)
-        self.assertEqual(test_trait.b, 2)
-        self.assertEqual(test_trait.c, 3)
-        self.assertEqual(test_trait.d, 4)
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g', mock.Mock())
-    def test_retrieve_trait_info_utf8_parsing(self,
-                                              requests_mock):
-        """Test that utf-8 strings are parsed correctly"""
-        utf_8_string = "test_string"
-        mock_dataset = mock.MagicMock()
-        requests_mock.return_value = TestResponse()
-        type(mock_dataset).display_fields = mock.PropertyMock(
-            return_value=["a", "b", "c", "d"])
-        type(mock_dataset).type = 'Publish'
-
-        mock_trait = MockTrait(
-            dataset=mock_dataset,
-            pre_publication_description=utf_8_string
-        )
-        trait_attrs = {
-            "group_code": "test_code",
-            "pre_publication_description": "test_pre_pub",
-            "pre_publication_abbreviation": "ファイルを画面毎に見て行くには、次のコマンドを使います。",
-            "post_publication_description": None,
-            "pubmed_id": None,
-            'year': "2020",
-            "authors": "Jane Doe かいと",
-        }
-        for key, val in list(trait_attrs.items()):
-            setattr(mock_trait, key, val)
-        test_trait = retrieve_trait_info(trait=mock_trait,
-                                         dataset=mock_dataset)
-        self.assertEqual(test_trait.abbreviation,
-                         "ファイルを画面毎に見て行くには、次のコマンドを使います。")
-        self.assertEqual(test_trait.authors,
-                         "Jane Doe かいと")
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
-    @mock.patch('base.trait.get_resource_id')
-    def test_retrieve_trait_info_with_non_empty_lrs(self,
-                                                    resource_id_mock,
-                                                    g_mock,
-                                                    requests_mock):
-        """Test retrieve trait info when lrs has a value"""
-        resource_id_mock.return_value = 1
-        g_mock.db.execute.return_value.fetchone = mock.Mock()
-        g_mock.db.execute.return_value.fetchone.side_effect = [
-            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
-            [1, 2.37, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
-            [2.7333, 2.1204]  # trait_info = g.db.execute(query).fetchone()
-        ]
-        requests_mock.return_value = None
-
-        mock_dataset = mock.MagicMock()
-        type(mock_dataset).display_fields = mock.PropertyMock(
-            return_value=["a", "b", "c", "d"])
-        type(mock_dataset).type = "ProbeSet"
-        type(mock_dataset).name = "RandomName"
-
-        mock_trait = MockTrait(
-            dataset=mock_dataset,
-            pre_publication_description="test_string"
-        )
-        trait_attrs = {
-            "description": "some description",
-            "probe_target_description": "some description",
-            "cellid": False,
-            "chr": 2.733,
-            "mb": 2.1204
-        }
-
-        for key, val in list(trait_attrs.items()):
-            setattr(mock_trait, key, val)
-        test_trait = retrieve_trait_info(trait=mock_trait,
-                                         dataset=mock_dataset,
-                                         get_qtl_info=True)
-        self.assertEqual(test_trait.LRS_score_repr,
-                         "2.4")
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
-    @mock.patch('base.trait.get_resource_id')
-    def test_retrieve_trait_info_with_empty_lrs_field(self,
-                                                      resource_id_mock,
-                                                      g_mock,
-                                                      requests_mock):
-        """Test retrieve trait info with empty lrs field"""
-        resource_id_mock.return_value = 1
-        g_mock.db.execute.return_value.fetchone = mock.Mock()
-        g_mock.db.execute.return_value.fetchone.side_effect = [
-            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
-            [1, None, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
-            [2, 3]  # trait_info = g.db.execute(query).fetchone()
-        ]
-        requests_mock.return_value = None
-
-        mock_dataset = mock.MagicMock()
-        type(mock_dataset).display_fields = mock.PropertyMock(
-            return_value=["a", "b", "c", "d"])
-        type(mock_dataset).type = "ProbeSet"
-        type(mock_dataset).name = "RandomName"
-
-        mock_trait = MockTrait(
-            dataset=mock_dataset,
-            pre_publication_description="test_string"
-        )
-        trait_attrs = {
-            "description": "some description",
-            "probe_target_description": "some description",
-            "cellid": False,
-            "chr": 2.733,
-            "mb": 2.1204
-        }
-
-        for key, val in list(trait_attrs.items()):
-            setattr(mock_trait, key, val)
-        test_trait = retrieve_trait_info(trait=mock_trait,
-                                         dataset=mock_dataset,
-                                         get_qtl_info=True)
-        self.assertEqual(test_trait.LRS_score_repr,
-                         "N/A")
-        self.assertEqual(test_trait.LRS_location_repr,
-                         "Chr2: 3.000000")
-
-    @mock.patch('base.trait.requests.get')
-    @mock.patch('base.trait.g')
-    @mock.patch('base.trait.get_resource_id')
-    def test_retrieve_trait_info_with_empty_chr_field(self,
-                                                      resource_id_mock,
-                                                      g_mock,
-                                                      requests_mock):
-        """Test retrieve trait info with empty chr field"""
-        resource_id_mock.return_value = 1
-        g_mock.db.execute.return_value.fetchone = mock.Mock()
-        g_mock.db.execute.return_value.fetchone.side_effect = [
-            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
-            [1, 2, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
-            [None, 3]  # trait_info = g.db.execute(query).fetchone()
-        ]
-
-        requests_mock.return_value = None
-
-        mock_dataset = mock.MagicMock()
-        type(mock_dataset).display_fields = mock.PropertyMock(
-            return_value=["a", "b", "c", "d"])
-        type(mock_dataset).type = "ProbeSet"
-        type(mock_dataset).name = "RandomName"
-
-        mock_trait = MockTrait(
-            dataset=mock_dataset,
-            pre_publication_description="test_string"
-        )
-        trait_attrs = {
-            "description": "some description",
-            "probe_target_description": "some description",
-            "cellid": False,
-            "chr": 2.733,
-            "mb": 2.1204
-        }
-
-        for key, val in list(trait_attrs.items()):
-            setattr(mock_trait, key, val)
-        test_trait = retrieve_trait_info(trait=mock_trait,
-                                         dataset=mock_dataset,
-                                         get_qtl_info=True)
-        self.assertEqual(test_trait.LRS_score_repr,
-                         "N/A")
-        self.assertEqual(test_trait.LRS_location_repr,
-                         "N/A")
diff --git a/wqflask/tests/base/test_webqtl_case_data.py b/wqflask/tests/base/test_webqtl_case_data.py
deleted file mode 100644
index 8e8ba482..00000000
--- a/wqflask/tests/base/test_webqtl_case_data.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""Tests for wqflask/base/webqtlCaseData.py"""
-import unittest
-
-from wqflask import app  # Required because of utility.tools in webqtlCaseData.py
-from base.webqtlCaseData import webqtlCaseData
-
-class TestWebqtlCaseData(unittest.TestCase):
-    """Tests for WebqtlCaseData class"""
-
-    def setUp(self):
-        self.w = webqtlCaseData(name="Test",
-                           value=0,
-                           variance=0.0,
-                           num_cases=10,
-                           name2="Test2")
-
-    def test_webqtl_case_data_repr(self):
-        self.assertEqual(
-            repr(self.w),
-            "<webqtlCaseData> value=0.000 variance=0.000 ndata=10 name=Test name2=Test2"
-        )
-
-    def test_class_outlier(self):
-        self.assertEqual(self.w.class_outlier, "")
-
-    def test_display_value(self):
-        self.assertEqual(self.w.display_value, "0.000")
-        self.w.value = None
-        self.assertEqual(self.w.display_value, "x")
-
-    def test_display_variance(self):
-        self.assertEqual(self.w.display_variance, "0.000")
-        self.w.variance = None
-        self.assertEqual(self.w.display_variance, "x")
-
-    def test_display_num_cases(self):
-        self.assertEqual(self.w.display_num_cases, "10")
-        self.w.num_cases = None
-        self.assertEqual(self.w.display_num_cases, "x")
diff --git a/wqflask/tests/unit/__init__.py b/wqflask/tests/unit/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/base/__init__.py b/wqflask/tests/unit/base/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/base/data.py b/wqflask/tests/unit/base/data.py
new file mode 100644
index 00000000..06a5a989
--- /dev/null
+++ b/wqflask/tests/unit/base/data.py
@@ -0,0 +1,110 @@
+gen_menu_json = """
+{
+  "datasets": {
+    "human": {
+      "HLC": {
+        "Liver mRNA": [
+          [
+            "320",
+            "HLC_0311",
+            "GSE9588 Human Liver Normal (Mar11) Both Sexes"
+          ]
+        ],
+        "Phenotypes": [
+          [
+            "635",
+            "HLCPublish",
+            "HLC Published Phenotypes"
+          ]
+        ]
+      }
+    },
+    "mouse": {
+      "BXD": {
+        "Genotypes": [
+          [
+            "600",
+            "BXDGeno",
+            "BXD Genotypes"
+          ]
+        ],
+        "Hippocampus mRNA": [
+          [
+            "112",
+            "HC_M2_0606_P",
+            "Hippocampus Consortium M430v2 (Jun06) PDNN"
+          ]
+        ],
+        "Phenotypes": [
+          [
+            "602",
+            "BXDPublish",
+            "BXD Published Phenotypes"
+          ]
+        ]
+      }
+    }
+  },
+  "groups": {
+    "human": [
+      [
+        "HLC",
+        "Liver: Normal Gene Expression with Genotypes (Merck)",
+        "Family:None"
+      ]
+    ],
+    "mouse": [
+      [
+        "BXD",
+        "BXD",
+        "Family:None"
+      ]
+    ]
+  },
+  "species": [
+    [
+      "human",
+      "Human"
+    ],
+    [
+      "mouse",
+      "Mouse"
+    ]
+  ],
+  "types": {
+    "human": {
+      "HLC": [
+        [
+          "Phenotypes",
+          "Traits and Cofactors",
+          "Phenotypes"
+        ],
+        [
+          "Liver mRNA",
+          "Liver mRNA",
+          "Molecular Trait Datasets"
+        ]
+      ]
+    },
+    "mouse": {
+      "BXD": [
+        [
+          "Phenotypes",
+          "Traits and Cofactors",
+          "Phenotypes"
+        ],
+        [
+          "Genotypes",
+          "DNA Markers and SNPs",
+          "Genotypes"
+        ],
+        [
+          "Hippocampus mRNA",
+          "Hippocampus mRNA",
+          "Molecular Trait Datasets"
+        ]
+      ]
+    }
+  }
+}
+"""
diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
new file mode 100644
index 00000000..96563a16
--- /dev/null
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -0,0 +1,181 @@
+"""Tests for wqflask/base/data_set.py"""
+
+import unittest
+from unittest import mock
+
+from wqflask import app
+from .data import gen_menu_json
+from base.data_set import DatasetType
+
+
+class TestDataSetTypes(unittest.TestCase):
+    """Tests for the DataSetType class"""
+
+    def setUp(self):
+        self.test_dataset = """
+            {
+                "AD-cases-controls-MyersGeno": "Geno",
+                "AD-cases-controls-MyersPublish": "Publish",
+                "AKXDGeno": "Geno",
+                "AXBXAGeno": "Geno",
+                "AXBXAPublish": "Publish",
+                "Aging-Brain-UCIPublish": "Publish",
+                "All Phenotypes": "Publish",
+                "B139_K_1206_M": "ProbeSet",
+                "B139_K_1206_R": "ProbeSet"
+            }
+            """
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch('base.data_set.g')
+    def test_data_set_type(self, db_mock):
+        """Test that DatasetType returns correctly if the Redis Instance is not empty
+        and the name variable exists in the dictionary
+
+        """
+        with app.app_context():
+            db_mock.get = mock.Mock()
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            self.assertEqual(DatasetType(redis_mock)
+                             ("All Phenotypes"), "Publish")
+            redis_mock.get.assert_called_once_with("dataset_structure")
+
+    @mock.patch('base.data_set.requests.get')
+    def test_data_set_type_with_empty_redis(self, request_mock):
+        """Test that DatasetType returns correctly if the Redis Instance is empty and
+        the name variable exists in the dictionary
+
+        """
+        with app.app_context():
+            request_mock.return_value.content = gen_menu_json
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = None
+            data_set = DatasetType(redis_mock)
+            self.assertEqual(data_set("BXDGeno"), "Geno")
+            self.assertEqual(data_set("BXDPublish"), "Publish")
+            self.assertEqual(data_set("HLC_0311"), "ProbeSet")
+
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                ('{"HLC_0311": "ProbeSet", '
+                 '"HLCPublish": "Publish", '
+                 '"BXDGeno": "Geno", '
+                 '"HC_M2_0606_P": "ProbeSet", '
+                 '"BXDPublish": "Publish"}'))
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_key_mrna(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("mrna_expr", "Test")
+            self.assertEqual(data_set("Test"), "ProbeSet")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "ProbeSet"}'))
+
+            db_mock.db.execute.assert_called_with(
+                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
+                 "WHERE ProbeSetFreeze.Name = \"Test\" ")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_key_pheno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("pheno", "Test")
+            self.assertEqual(data_set("Test"), "Publish")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Publish"}'))
+            db_mock.db.execute.assert_called_with(
+                ("SELECT InfoFiles.GN_AccesionId "
+                 "FROM InfoFiles, PublishFreeze, InbredSet "
+                 "WHERE InbredSet.Name = 'Test' AND "
+                 "PublishFreeze.InbredSetId = InbredSet.Id AND "
+                 "InfoFiles.InfoPageName = PublishFreeze.Name")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_other_pheno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("other_pheno", "Test")
+            self.assertEqual(data_set("Test"), "Publish")
+
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Publish"}'))
+
+            db_mock.db.execute.assert_called_with(
+                ("SELECT PublishFreeze.Name " +
+                 "FROM PublishFreeze, InbredSet " +
+                 "WHERE InbredSet.Name = 'Test' AND "
+                 "PublishFreeze.InbredSetId = InbredSet.Id")
+            )
+
+    @mock.patch('base.data_set.g')
+    def test_set_dataset_geno(self, db_mock):
+        with app.app_context():
+            db_mock.db.execute.return_value.fetchone.return_value = [1, 2, 3]
+            redis_mock = mock.Mock()
+            redis_mock.get.return_value = self.test_dataset
+            data_set = DatasetType(redis_mock)
+            data_set.set_dataset_key("geno", "Test")
+            self.assertEqual(data_set("Test"), "Geno")
+            redis_mock.set.assert_called_once_with(
+                "dataset_structure",
+                ('{"AD-cases-controls-MyersGeno": "Geno", '
+                 '"AD-cases-controls-MyersPublish": "Publish", '
+                 '"AKXDGeno": "Geno", '
+                 '"AXBXAGeno": "Geno", '
+                 '"AXBXAPublish": "Publish", '
+                 '"Aging-Brain-UCIPublish": "Publish", '
+                 '"All Phenotypes": "Publish", '
+                 '"B139_K_1206_M": "ProbeSet", '
+                 '"B139_K_1206_R": "ProbeSet", '
+                 '"Test": "Geno"}'))
+
+            db_mock.db.execute.assert_called_with(
+                ("SELECT GenoFreeze.Id FROM "
+                 "GenoFreeze WHERE GenoFreeze.Name = \"Test\" "))
diff --git a/wqflask/tests/unit/base/test_general_object.py b/wqflask/tests/unit/base/test_general_object.py
new file mode 100644
index 00000000..00fd3c72
--- /dev/null
+++ b/wqflask/tests/unit/base/test_general_object.py
@@ -0,0 +1,40 @@
+import unittest
+
+from base.GeneralObject import GeneralObject
+
+
+class TestGeneralObjectTests(unittest.TestCase):
+    """
+    Test the GeneralObject base class
+    """
+
+    def test_object_contents(self):
+        """Test whether base contents are stored properly"""
+        test_obj = GeneralObject("a", "b", "c")
+        self.assertEqual("abc", ''.join(test_obj.contents))
+        self.assertEqual(len(test_obj), 0)
+
+    def test_object_dict(self):
+        """Test whether the base class is printed properly"""
+        test_obj = GeneralObject("a", name="test", value=1)
+        self.assertEqual(str(test_obj), "name = test\nvalue = 1\n")
+        self.assertEqual(
+            repr(test_obj), "contents = ['a']\nname = test\nvalue = 1\n")
+        self.assertEqual(len(test_obj), 2)
+        self.assertEqual(test_obj["value"], 1)
+        test_obj["test"] = 1
+        self.assertEqual(test_obj["test"], 1)
+
+    def test_get_attribute(self):
+        "Test that getattr works"
+        test_obj = GeneralObject("a", name="test", value=1)
+        self.assertEqual(getattr(test_obj, "value", None), 1)
+        self.assertEqual(getattr(test_obj, "non-existent", None), None)
+
+    def test_object_comparisons(self):
+        "Test that 2 objects of the same length are equal"
+        test_obj1 = GeneralObject("a", name="test", value=1)
+        test_obj2 = GeneralObject("b", name="test2", value=2)
+        test_obj3 = GeneralObject("a", name="test", x=1, y=2)
+        self.assertTrue(test_obj1 == test_obj2)
+        self.assertFalse(test_obj1 == test_obj3)
diff --git a/wqflask/tests/unit/base/test_trait.py b/wqflask/tests/unit/base/test_trait.py
new file mode 100644
index 00000000..826ccefd
--- /dev/null
+++ b/wqflask/tests/unit/base/test_trait.py
@@ -0,0 +1,241 @@
+# -*- coding: utf-8 -*-
+"""Tests wqflask/base/trait.py"""
+import unittest
+from unittest import mock
+
+from wqflask import app
+from base.trait import GeneralTrait
+from base.trait import retrieve_trait_info
+
+
+class TestResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return "[1, 2, 3, 4]"
+
+
+class TestNilResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return "{}"
+
+
+class MockTrait(GeneralTrait):
+    @property
+    def wikidata_alias_fmt(self):
+        return "Mock alias"
+
+
+class TestRetrieveTraitInfo(unittest.TestCase):
+    """Tests for 'retrieve_trait_info'"""
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    def test_retrieve_trait_info_with_empty_dataset(self):
+        """Test that an exception is raised when dataset is empty"""
+        with self.assertRaises(AssertionError):
+            retrieve_trait_info(trait=mock.MagicMock(),
+                                dataset={})
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g', mock.Mock())
+    def test_retrieve_trait_info_with_empty_trait_info(self,
+                                                       requests_mock):
+        """Empty trait info"""
+        requests_mock.return_value = TestNilResponse()
+        with self.assertRaises(KeyError):
+            retrieve_trait_info(trait=mock.MagicMock(),
+                                dataset=mock.MagicMock())
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g', mock.Mock())
+    def test_retrieve_trait_info_with_non_empty_trait_info(self,
+                                                           requests_mock):
+        """Test that attributes are set"""
+        mock_dataset = mock.MagicMock()
+        requests_mock.return_value = TestResponse()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        test_trait = retrieve_trait_info(trait=MockTrait(dataset=mock_dataset),
+                                         dataset=mock_dataset)
+        self.assertEqual(test_trait.a, 1)
+        self.assertEqual(test_trait.b, 2)
+        self.assertEqual(test_trait.c, 3)
+        self.assertEqual(test_trait.d, 4)
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g', mock.Mock())
+    def test_retrieve_trait_info_utf8_parsing(self,
+                                              requests_mock):
+        """Test that utf-8 strings are parsed correctly"""
+        utf_8_string = "test_string"
+        mock_dataset = mock.MagicMock()
+        requests_mock.return_value = TestResponse()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = 'Publish'
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description=utf_8_string
+        )
+        trait_attrs = {
+            "group_code": "test_code",
+            "pre_publication_description": "test_pre_pub",
+            "pre_publication_abbreviation": "ファイルを画面毎に見て行くには、次のコマンドを使います。",
+            "post_publication_description": None,
+            "pubmed_id": None,
+            'year': "2020",
+            "authors": "Jane Doe かいと",
+        }
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset)
+        self.assertEqual(test_trait.abbreviation,
+                         "ファイルを画面毎に見て行くには、次のコマンドを使います。")
+        self.assertEqual(test_trait.authors,
+                         "Jane Doe かいと")
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_non_empty_lrs(self,
+                                                    resource_id_mock,
+                                                    g_mock,
+                                                    requests_mock):
+        """Test retrieve trait info when lrs has a value"""
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, 2.37, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [2.7333, 2.1204]  # trait_info = g.db.execute(query).fetchone()
+        ]
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "2.4")
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_empty_lrs_field(self,
+                                                      resource_id_mock,
+                                                      g_mock,
+                                                      requests_mock):
+        """Test retrieve trait info with empty lrs field"""
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, None, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [2, 3]  # trait_info = g.db.execute(query).fetchone()
+        ]
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "N/A")
+        self.assertEqual(test_trait.LRS_location_repr,
+                         "Chr2: 3.000000")
+
+    @mock.patch('base.trait.requests.get')
+    @mock.patch('base.trait.g')
+    @mock.patch('base.trait.get_resource_id')
+    def test_retrieve_trait_info_with_empty_chr_field(self,
+                                                      resource_id_mock,
+                                                      g_mock,
+                                                      requests_mock):
+        """Test retrieve trait info with empty chr field"""
+        resource_id_mock.return_value = 1
+        g_mock.db.execute.return_value.fetchone = mock.Mock()
+        g_mock.db.execute.return_value.fetchone.side_effect = [
+            [1, 2, 3, 4],  # trait_info = g.db.execute(query).fetchone()
+            [1, 2, 3, 4, 5],  # trait_qtl = g.db.execute(query).fetchone()
+            [None, 3]  # trait_info = g.db.execute(query).fetchone()
+        ]
+
+        requests_mock.return_value = None
+
+        mock_dataset = mock.MagicMock()
+        type(mock_dataset).display_fields = mock.PropertyMock(
+            return_value=["a", "b", "c", "d"])
+        type(mock_dataset).type = "ProbeSet"
+        type(mock_dataset).name = "RandomName"
+
+        mock_trait = MockTrait(
+            dataset=mock_dataset,
+            pre_publication_description="test_string"
+        )
+        trait_attrs = {
+            "description": "some description",
+            "probe_target_description": "some description",
+            "cellid": False,
+            "chr": 2.733,
+            "mb": 2.1204
+        }
+
+        for key, val in list(trait_attrs.items()):
+            setattr(mock_trait, key, val)
+        test_trait = retrieve_trait_info(trait=mock_trait,
+                                         dataset=mock_dataset,
+                                         get_qtl_info=True)
+        self.assertEqual(test_trait.LRS_score_repr,
+                         "N/A")
+        self.assertEqual(test_trait.LRS_location_repr,
+                         "N/A")
diff --git a/wqflask/tests/unit/base/test_webqtl_case_data.py b/wqflask/tests/unit/base/test_webqtl_case_data.py
new file mode 100644
index 00000000..8e8ba482
--- /dev/null
+++ b/wqflask/tests/unit/base/test_webqtl_case_data.py
@@ -0,0 +1,39 @@
+"""Tests for wqflask/base/webqtlCaseData.py"""
+import unittest
+
+from wqflask import app  # Required because of utility.tools in webqtlCaseData.py
+from base.webqtlCaseData import webqtlCaseData
+
+class TestWebqtlCaseData(unittest.TestCase):
+    """Tests for WebqtlCaseData class"""
+
+    def setUp(self):
+        self.w = webqtlCaseData(name="Test",
+                           value=0,
+                           variance=0.0,
+                           num_cases=10,
+                           name2="Test2")
+
+    def test_webqtl_case_data_repr(self):
+        self.assertEqual(
+            repr(self.w),
+            "<webqtlCaseData> value=0.000 variance=0.000 ndata=10 name=Test name2=Test2"
+        )
+
+    def test_class_outlier(self):
+        self.assertEqual(self.w.class_outlier, "")
+
+    def test_display_value(self):
+        self.assertEqual(self.w.display_value, "0.000")
+        self.w.value = None
+        self.assertEqual(self.w.display_value, "x")
+
+    def test_display_variance(self):
+        self.assertEqual(self.w.display_variance, "0.000")
+        self.w.variance = None
+        self.assertEqual(self.w.display_variance, "x")
+
+    def test_display_num_cases(self):
+        self.assertEqual(self.w.display_num_cases, "10")
+        self.w.num_cases = None
+        self.assertEqual(self.w.display_num_cases, "x")
diff --git a/wqflask/tests/unit/utility/__init__.py b/wqflask/tests/unit/utility/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
new file mode 100644
index 00000000..5c391be5
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -0,0 +1,189 @@
+"""Tests for authentication tools"""
+import unittest
+from unittest import mock
+
+from utility.authentication_tools import check_resource_availability
+from utility.authentication_tools import add_new_resource
+
+
+class TestResponse:
+    """Mock Test Response after a request"""
+    @property
+    def content(self):
+        """Mock the content from Requests.get(params).content"""
+        return '["foo"]'
+
+
+class TestUser:
+    """Mock user"""
+    @property
+    def user_id(self):
+        """Mockes user id. Used in Flask.g.user_session.user_id"""
+        return "Jane"
+
+
+class TestUserSession:
+    """Mock user session"""
+    @property
+    def user_session(self):
+        """Mock user session. Mocks Flask.g.user_session object"""
+        return TestUser()
+
+
+def mock_add_resource(resource_ob, update=False):
+    return resource_ob
+
+
+class TestCheckResourceAvailability(unittest.TestCase):
+    """Test methods related to checking the resource availability"""
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g', mock.Mock())
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_default_mask(
+            self,
+            resource_id_mock,
+            redis_mock,
+            add_new_resource_mock):
+        """Test the resource availability with default mask"""
+        resource_id_mock.return_value = 1
+        redis_mock.smembers.return_value = []
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        self.assertEqual(check_resource_availability(test_dataset), 2)
+
+    @mock.patch('utility.authentication_tools.requests.get')
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g', TestUserSession())
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_non_default_mask(
+            self,
+            resource_id_mock,
+            redis_mock,
+            add_new_resource_mock,
+            requests_mock):
+        """Test the resource availability with default mask"""
+        resource_id_mock.return_value = 1
+        redis_mock.smembers.return_value = []
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        requests_mock.return_value = TestResponse()
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         ['foo'])
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.SUPER_PRIVILEGES',
+                "SUPERUSER")
+    @mock.patch('utility.authentication_tools.requests.get')
+    @mock.patch('utility.authentication_tools.add_new_resource')
+    @mock.patch('utility.authentication_tools.Redis')
+    @mock.patch('utility.authentication_tools.g', TestUserSession())
+    @mock.patch('utility.authentication_tools.get_resource_id')
+    def test_check_resource_availability_of_super_user(
+            self,
+            resource_id_mock,
+            redis_mock,
+            add_new_resource_mock,
+            requests_mock):
+        """Test the resource availability if the user is the super user"""
+        resource_id_mock.return_value = 1
+        redis_mock.smembers.return_value = ["Jane"]
+        add_new_resource_mock.return_value = {"default_mask": 2}
+        requests_mock.return_value = TestResponse()
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Test")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         "SUPERUSER")
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    def test_check_resource_availability_string_dataset(self):
+        """Test the resource availability if the dataset is a string"""
+        self.assertEqual(check_resource_availability("Test"),
+                         "John Doe")
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    def test_check_resource_availability_temp(self):
+        """Test the resource availability if the dataset is a string"""
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Temp")
+        self.assertEqual(check_resource_availability(test_dataset),
+                         "John Doe")
+
+
+class TestAddNewResource(unittest.TestCase):
+    """Test cases for add_new_resource method"""
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_publish_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is 'publish'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).type = mock.PropertyMock(return_value="Publish")
+        type(test_dataset).id = mock.PropertyMock(return_value=10)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Test_None",
+            "data": {
+                "dataset": 10,
+                "trait": None
+            },
+            "type": "dataset-publish"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_geno_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is 'geno'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).type = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).id = mock.PropertyMock(return_value=20)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Geno",
+            "data": {
+                "dataset": 20,
+            },
+            "type": "dataset-geno"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
+
+    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
+                "John Doe")
+    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
+    @mock.patch('utility.authentication_tools.get_group_code')
+    def test_add_new_resource_if_other_datatype(self, group_code_mock):
+        """Test add_new_resource if dataset type is not 'geno' or 'publish'"""
+        group_code_mock.return_value = "Test"
+        test_dataset = mock.MagicMock()
+        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
+        type(test_dataset).type = mock.PropertyMock(return_value="other")
+        type(test_dataset).id = mock.PropertyMock(return_value=20)
+        expected_value = {
+            "owner_id": "none",
+            "default_mask": "John Doe",
+            "group_masks": {},
+            "name": "Geno",
+            "data": {
+                "dataset": 20,
+            },
+            "type": "dataset-probeset"
+        }
+        self.assertEqual(add_new_resource(test_dataset),
+                         expected_value)
diff --git a/wqflask/tests/unit/utility/test_chunks.py b/wqflask/tests/unit/utility/test_chunks.py
new file mode 100644
index 00000000..8d90a1ec
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_chunks.py
@@ -0,0 +1,19 @@
+"""Test chunking"""
+
+import unittest
+
+from utility.chunks import divide_into_chunks
+
+
+class TestChunks(unittest.TestCase):
+    "Test Utility method for chunking"
+    def test_divide_into_chunks(self):
+        "Check that a list is chunked correctly"
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3),
+                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 4),
+                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
+        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 5),
+                         [[1, 2], [7, 3], [22, 8], [5, 22], [333]])
+        self.assertEqual(divide_into_chunks([], 5),
+                         [[]])
diff --git a/wqflask/tests/unit/utility/test_corestats.py b/wqflask/tests/unit/utility/test_corestats.py
new file mode 100644
index 00000000..cf91a248
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_corestats.py
@@ -0,0 +1,55 @@
+"""Test Core Stats"""
+
+import unittest
+
+from utility.corestats import Stats
+
+
+class TestChunks(unittest.TestCase):
+    "Test Utility method for chunking"
+
+    def setUp(self):
+        self.stat_test = Stats((x for x in range(1, 11)))
+
+    def test_stats_sum(self):
+        """ Test sequence sum """
+        self.assertEqual(self.stat_test.sum(), 55)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.sum(), None)
+
+    def test_stats_count(self):
+        """ Test sequence count """
+        self.assertEqual(self.stat_test.count(), 10)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.count(), 0)
+
+    def test_stats_min(self):
+        """ Test min value in sequence"""
+        self.assertEqual(self.stat_test.min(), 1)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.min(), None)
+
+    def test_stats_max(self):
+        """ Test max value in sequence """
+        self.assertEqual(self.stat_test.max(), 10)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.max(), None)
+
+    def test_stats_avg(self):
+        """ Test avg of sequence """
+        self.assertEqual(self.stat_test.avg(), 5.5)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.avg(), None)
+
+    def test_stats_stdev(self):
+        """ Test standard deviation of sequence """
+        self.assertEqual(self.stat_test.stdev(), 3.0276503540974917)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.stdev(), None)
+
+    def test_stats_percentile(self):
+        """ Test percentile of sequence """
+        self.assertEqual(self.stat_test.percentile(20), 3.0)
+        self.assertEqual(self.stat_test.percentile(101), None)
+        self.stat_test = Stats([])
+        self.assertEqual(self.stat_test.percentile(20), None)
diff --git a/wqflask/tests/unit/utility/test_corr_result_helpers.py b/wqflask/tests/unit/utility/test_corr_result_helpers.py
new file mode 100644
index 00000000..e196fbdf
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_corr_result_helpers.py
@@ -0,0 +1,32 @@
+""" Test correlation helper methods """
+
+import unittest
+from utility.corr_result_helpers import normalize_values, common_keys, normalize_values_with_samples
+
+
+class TestCorrelationHelpers(unittest.TestCase):
+    """Test methods for normalising lists"""
+
+    def test_normalize_values(self):
+        """Test that a list is normalised correctly"""
+        self.assertEqual(
+            normalize_values([2.3, None, None, 3.2, 4.1, 5], [
+                             3.4, 7.2, 1.3, None, 6.2, 4.1]),
+            ([2.3, 4.1, 5], [3.4, 6.2, 4.1], 3)
+        )
+
+    def test_common_keys(self):
+        """Test that common keys are returned as a list"""
+        a = dict(BXD1=9.113, BXD2=9.825, BXD14=8.985, BXD15=9.300)
+        b = dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)
+        self.assertEqual(sorted(common_keys(a, b)), ['BXD1', 'BXD14'])
+
+    def test_normalize_values_with_samples(self):
+        """Test that a sample(dict) is normalised correctly"""
+        self.assertEqual(
+            normalize_values_with_samples(
+                dict(BXD1=9.113, BXD2=9.825, BXD14=8.985,
+                     BXD15=9.300, BXD20=9.300),
+                dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)),
+            (({'BXD1': 9.113, 'BXD14': 8.985}, {'BXD1': 9.723, 'BXD14': 9.124}, 2))
+        )
diff --git a/wqflask/tests/unit/utility/test_formatting.py b/wqflask/tests/unit/utility/test_formatting.py
new file mode 100644
index 00000000..9d3033d1
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_formatting.py
@@ -0,0 +1,33 @@
+import unittest
+from utility.formatting import numify, commify
+
+
+class TestFormatting(unittest.TestCase):
+    """Test formatting numbers by numifying or commifying"""
+
+    def test_numify(self):
+        "Test that a number is correctly converted to a English readable string"
+        self.assertEqual(numify(1, 'item', 'items'),
+                         'one item')
+        self.assertEqual(numify(2, 'book'), 'two')
+        self.assertEqual(numify(2, 'book', 'books'), 'two books')
+        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
+        self.assertEqual(numify(0), 'zero')
+        self.assertEqual(numify(5), 'five')
+        self.assertEqual(numify(14, 'book', 'books'), '14 books')
+        self.assertEqual(numify(999, 'book', 'books'), '999 books')
+        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
+        self.assertEqual(numify(1956), '1956')
+
+    def test_commify(self):
+        "Test that commas are added correctly"
+        self.assertEqual(commify(1), '1')
+        self.assertEqual(commify(123), '123')
+        self.assertEqual(commify(1234), '1234')
+        self.assertEqual(commify(12345), '12,345')
+        self.assertEqual(commify(1234567890), '1,234,567,890')
+        self.assertEqual(commify(123.0), '123.0')
+        self.assertEqual(commify(1234.5), '1234.5')
+        self.assertEqual(commify(1234.56789), '1234.56789')
+        self.assertEqual(commify(123456.789), '123,456.789')
+        self.assertEqual(commify(None), None)
diff --git a/wqflask/tests/unit/utility/test_hmac.py b/wqflask/tests/unit/utility/test_hmac.py
new file mode 100644
index 00000000..4e3652f8
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_hmac.py
@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+"""Test hmac utility functions"""
+
+import unittest
+from unittest import mock
+
+from utility.hmac import data_hmac
+from utility.hmac import url_for_hmac
+from utility.hmac import hmac_creation
+
+
+class TestHmacUtil(unittest.TestCase):
+    """Test Utility method for hmac creation"""
+
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
+    def test_hmac_creation(self):
+        """Test hmac creation with a utf-8 string"""
+        self.assertEqual(hmac_creation("ファイ"), "7410466338cfe109e946")
+
+    @mock.patch("utility.hmac.app.config",
+                {'SECRET_HMAC_CODE': ('\x08\xdf\xfa\x93N\x80'
+                                      '\xd9\\H@\\\x9f`\x98d^'
+                                      '\xb4a;\xc6OM\x946a\xbc'
+                                      '\xfc\x80:*\xebc')})
+    def test_hmac_creation_with_cookie(self):
+        """Test hmac creation with a cookie"""
+        cookie = "3f4c1dbf-5b56-4260-87d6-f35445bda37e:af4fcf5eace9e7c864ce"
+        uuid_, _, signature = cookie.partition(":")
+        self.assertEqual(
+            hmac_creation(uuid_),
+            "af4fcf5eace9e7c864ce")
+
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
+    def test_data_hmac(self):
+        """Test data_hmac fn with a utf-8 string"""
+        self.assertEqual(data_hmac("ファイ"), "ファイ:7410466338cfe109e946")
+
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
+    @mock.patch("utility.hmac.url_for")
+    def test_url_for_hmac_with_plain_url(self, mock_url):
+        """Test url_for_hmac without params"""
+        mock_url.return_value = "https://mock_url.com/ファイ/"
+        self.assertEqual(url_for_hmac("ファイ"),
+                         "https://mock_url.com/ファイ/?hm=05bc39e659b1948f41e7")
+
+    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
+    @mock.patch("utility.hmac.url_for")
+    def test_url_for_hmac_with_param_in_url(self, mock_url):
+        """Test url_for_hmac with params"""
+        mock_url.return_value = "https://mock_url.com/?ファイ=1"
+        self.assertEqual(url_for_hmac("ファイ"),
+                         "https://mock_url.com/?ファイ=1&hm=4709c1708270644aed79")
diff --git a/wqflask/tests/unit/wqflask/__init__.py b/wqflask/tests/unit/wqflask/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/api/__init__.py b/wqflask/tests/unit/wqflask/api/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
new file mode 100644
index 00000000..84898bd1
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -0,0 +1,413 @@
+"""Test cases for wqflask.api.gen_menu"""
+import unittest
+from unittest import mock
+
+from wqflask import app
+from wqflask.api.gen_menu import gen_dropdown_json
+from wqflask.api.gen_menu import get_species
+from wqflask.api.gen_menu import get_groups
+from wqflask.api.gen_menu import get_types
+from wqflask.api.gen_menu import get_datasets
+from wqflask.api.gen_menu import phenotypes_exist
+from wqflask.api.gen_menu import genotypes_exist
+from wqflask.api.gen_menu import build_datasets
+from wqflask.api.gen_menu import build_types
+
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for the gen_menu module"""
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+        self.test_group = {
+            'mouse': [
+                ['H_T1',
+                 'H_T',
+                 'Family:DescriptionA'
+                 ],
+                ['H_T2', "H_T'", 'Family:None']
+            ],
+            'human': [
+                ['BXD', 'BXD', 'Family:None'],
+                ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+                 'Family:Test']
+            ]
+        }
+
+        self.test_type = {
+            'mouse': {
+                'H_T2': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [('Phenotypes',
+                          'Traits and Cofactors',
+                          'Phenotypes'),
+                         ('Genotypes',
+                          'DNA Markers and SNPs',
+                          'Genotypes'),
+                         ['M', 'M', 'Molecular Trait Datasets']]
+            },
+            'human': {
+                'HLC': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [('Phenotypes',
+                         'Traits and Cofactors',
+                         'Phenotypes'),
+                        ('Genotypes',
+                         'DNA Markers and SNPs',
+                         'Genotypes'),
+                        ['M', 'M', 'Molecular Trait Datasets']]
+            }
+        }
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_species(self, db_mock):
+        """Test that assertion is raised when dataset and dataset_name
+        are defined"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('human', 'Human'),
+            ('mouse', 'Mouse'))
+        self.assertEqual(get_species(),
+                         [['human', 'Human'], ['mouse', 'Mouse']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_get_groups(self, db_mock):
+        """Test that species groups are grouped correctly"""
+        db_mock.db.execute.return_value.fetchall.side_effect = [
+            # Mouse
+            (('BXD', 'BXD', None),
+             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
+              'Test')),
+            # Human
+            (('H_T1', "H_T", "DescriptionA"),
+             ('H_T2', "H_T'", None))
+        ]
+
+        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
+                         self.test_group)
+
+        for name in ["mouse", "human"]:
+            db_mock.db.execute.assert_any_call(
+                ("SELECT InbredSet.Name, InbredSet.FullName, " +
+                 "IFNULL(InbredSet.Family, 'None') " +
+                 "FROM InbredSet, Species WHERE Species.Name " +
+                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
+                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
+                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
+                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
+                 "InbredSet.MenuOrderId ASC").format(name)
+            )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that phenotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        phenotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM PublishFreeze "
+            "WHERE PublishFreeze.Name = 'testPublish'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_falsy_values(self, db_mock):
+        """Test that phenotype check returns correctly when given
+        a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_phenotypes_exist_with_truthy_value(self, db_mock):
+        """Test that phenotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_called_with_correct_query(self, db_mock):
+        """Test that genotypes_exist is called with the correct query"""
+        db_mock.db.execute.return_value.fetchone.return_value = None
+        genotypes_exist("test")
+        db_mock.db.execute.assert_called_with(
+            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_falsy_values(self, db_mock):
+        """Test that genotype check returns correctly when given
+        a None value"""
+        for x in [None, False, (), [], ""]:
+            db_mock.db.execute.return_value.fetchone.return_value = x
+            self.assertFalse(genotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_genotypes_exist_with_truthy_value(self, db_mock):
+        """Test that genotype check returns correctly when given Truthy """
+        for x in ["x", ("result"), ["result"], [1]]:
+            db_mock.db.execute.return_value.fetchone.return_value = (x)
+            self.assertTrue(phenotypes_exist("test"))
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (602, "BXDPublish", "BXD Published Phenotypes"),
+        )
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
+            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
+            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
+            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
+            "InfoFiles.InfoPageName = PublishFreeze.Name " +
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [['602', "BXDPublish", "Mouse Phenome Database"]])
+
+        db_mock.db.execute.return_value.fetchall.return_value = ()
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            "BXDPublish", "Mouse Phenome Database"
+        )
+        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
+                         [["None", "BXDPublish", "Mouse Phenome Database"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type with no
+        results
+
+        """
+        db_mock.db.execute.return_value.fetchall.return_value = None
+        db_mock.db.execute.return_value.fetchone.return_value = (121,
+                                                                 "text value")
+        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
+                         [["None", "121", "text value"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+            "FROM PublishFreeze, InbredSet "
+            "WHERE InbredSet.Name = 'BXD' AND "
+            "PublishFreeze.InbredSetId = InbredSet.Id "
+            "ORDER BY PublishFreeze.CreateTime ASC"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_genotypes(self, db_mock):
+        """Test that correct dataset is returned for a phenotype type"""
+        db_mock.db.execute.return_value.fetchone.return_value = (
+            635, "HLCPublish", "HLC Published Genotypes"
+        )
+
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["635", "HLCGeno", "HLC Genotypes"]])
+        db_mock.db.execute.assert_called_with(
+            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
+            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
+            "GenoFreeze.InbredSetId = InbredSet.Id AND "
+            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
+            "ORDER BY GenoFreeze.CreateTime DESC"
+        )
+        db_mock.db.execute.return_value.fetchone.return_value = ()
+        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
+                         [["None", "HLCGeno", "HLC Genotypes"]])
+
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_datasets_with_type_mrna(self, db_mock):
+        """Test that correct dataset is returned for a mRNA
+        expression/ Probeset"""
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            (112, "HC_M2_0606_P",
+             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
+            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
+        ]])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
+            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
+            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
+            "Species.Name = 'Mouse' AND Species.Id = " +
+            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
+            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
+            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
+            "ORDER BY ProbeSetFreeze.CreateTime DESC")
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    @mock.patch('wqflask.api.gen_menu.g')
+    def test_build_types(self, db_mock, datasets_mock):
+        """Test that correct tissue metadata is returned"""
+        datasets_mock.return_value = [
+            ["112", 'HC_M2_0606_P',
+                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
+        ]
+        db_mock.db.execute.return_value.fetchall.return_value = (
+            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+        )
+        self.assertEqual(build_types('mouse', 'random group'),
+                         [['M', 'M', 'Molecular Traits'],
+                          ['H', 'H', 'Molecular Traits'],
+                          ['R', 'R', 'Molecular Traits']])
+        db_mock.db.execute.assert_called_once_with(
+            "SELECT DISTINCT Tissue.Name " +
+            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
+            "Tissue, Species WHERE Species.Name = 'mouse' " +
+            "AND Species.Id = InbredSet.SpeciesId AND " +
+            "InbredSet.Name = 'random group' AND " +
+            "ProbeFreeze.TissueId = Tissue.Id AND " +
+            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
+            "ORDER BY Tissue.Name"
+        )
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_existing_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes and genotypes
+        exist
+
+        """
+        phenotypes_exist_mock.return_value = True
+        genotypes_exist_mock.return_value = True
+
+        expected_result = self.test_type
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        self.assertEqual(get_types(self.test_group), expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist and
+        genotypes_exist are false but build_type is falsy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = []
+        self.assertEqual(get_types(self.test_group), {
+            'mouse': {},
+            'human': {}
+        })
+
+    @mock.patch('wqflask.api.gen_menu.build_types')
+    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
+    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
+    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
+            self,
+            phenotypes_exist_mock,
+            genotypes_exist_mock,
+            build_types_mock):
+        """Test that build types are constructed correctly if phenotypes_exist,
+        genotypes_exist and build_types are truthy
+
+        """
+        phenotypes_exist_mock.return_value = False
+        genotypes_exist_mock.return_value = False
+
+        build_types_mock.return_value = [
+            ['M', 'M', 'Molecular Trait Datasets']
+        ]
+        expected_result = {
+            'mouse': {
+                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
+                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
+            'human': {
+                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
+                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
+        self.assertEqual(get_types(self.test_group),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_existent_datasets(self,
+                                                 build_datasets_mock):
+        """Test correct dataset is returned with existent build_datasets"""
+        build_datasets_mock.return_value = "Test"
+        expected_result = {
+            'mouse': {
+                'H_T2': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'},
+                'H_T1': {'Genotypes': 'Test',
+                         'M': 'Test',
+                         'Phenotypes': 'Test'}},
+            'human': {'HLC': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'},
+                      'BXD': {'Genotypes': 'Test',
+                              'M': 'Test',
+                              'Phenotypes': 'Test'}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.build_datasets')
+    def test_get_datasets_with_non_existent_datasets(self,
+                                                     build_datasets_mock):
+        """Test correct dataset is returned with non-existent build_datasets"""
+        build_datasets_mock.return_value = None
+        expected_result = {
+            'mouse': {
+                'H_T2': {},
+                'H_T1': {}},
+            'human': {'HLC': {},
+                      'BXD': {}}}
+        self.assertEqual(get_datasets(self.test_type),
+                         expected_result)
+
+    @mock.patch('wqflask.api.gen_menu.get_datasets')
+    @mock.patch('wqflask.api.gen_menu.get_types')
+    @mock.patch('wqflask.api.gen_menu.get_groups')
+    @mock.patch('wqflask.api.gen_menu.get_species')
+    def test_gen_dropdown_json(self,
+                               species_mock,
+                               groups_mock,
+                               types_mock,
+                               datasets_mock):
+        "Test that the correct dictionary is constructed properly"
+        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
+                                     .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+        groups_mock.return_value = ("groupA groupB groupC groupD"
+                                    .split(" "))
+        types_mock.return_value = ("typeA typeB typeC typeD"
+                                   .split(" "))
+        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
+                                      .split(" "))
+
+        expected_result = {
+            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
+            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
+            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
+            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
+
+        self.assertEqual(gen_dropdown_json(), expected_result)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/__init__.py b/wqflask/tests/unit/wqflask/marker_regression/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
new file mode 100644
index 00000000..8ae0f09f
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -0,0 +1,156 @@
+import unittest
+
+import htmlgen as HT
+from wqflask.marker_regression.display_mapping_results import (
+    DisplayMappingResults,
+    HtmlGenWrapper
+)
+
+
+class TestDisplayMappingResults(unittest.TestCase):
+    """Basic Methods to test Mapping Results"""
+    def test_pil_colors(self):
+        """Test that colors use PILLOW color format"""
+        self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
+                         (245, 211, 211))
+
+
+class TestHtmlGenWrapper(unittest.TestCase):
+    """Test Wrapper around HTMLGen"""
+    def test_create_image(self):
+        """Test HT.Image method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_image_tag(src="test.png",
+                                                alt="random",
+                                                border="0",
+                                                width="10",
+                                                height="13",
+                                                usemap="#webqtlmap")),
+            ("""<img alt="random" border="0" height="13" """
+             """src="test.png" usemap="#webqtlmap" """
+             """width="10"/>""")
+        )
+
+    def test_create_form(self):
+        """Test HT.Form method"""
+        test_form = HtmlGenWrapper.create_form_tag(
+            cgi="/testing/",
+            enctype='multipart/form-data',
+            name="formName",
+            submit=HtmlGenWrapper.create_input_tag(type_='hidden', name='Default_Name')
+        )
+        test_image = HtmlGenWrapper.create_image_tag(
+            src="test.png",
+            alt="random",
+            border="0",
+            width="10",
+            height="13",
+            usemap="#webqtlmap"
+        )
+        self.assertEqual(
+            str(test_form).replace("\n", ""),
+            ("""<form action="/testing/" enctype="multipart/form-data" """
+             """method="POST" """
+             """name="formName"><input name="Default_Name" """
+             """type="hidden"/></form>"""))
+        hddn = {
+            'FormID': 'showDatabase',
+            'ProbeSetID': '_',
+            'database': "TestGeno",
+            'CellID': '_',
+            'RISet': "Test",
+            'incparentsf1': 'ON'
+        }
+        for key in hddn.keys():
+            test_form.append(
+                HtmlGenWrapper.create_input_tag(
+                    name=key,
+                    value=hddn[key],
+                    type_='hidden'))
+        test_form.append(test_image)
+
+        self.assertEqual(str(test_form).replace("\n", ""), (
+            """<form action="/testing/" enctype="multipart/form-data" """
+            """method="POST" name="formName">"""
+            """<input name="Default_Name" type="hidden"/>"""
+            """<input name="FormID" type="hidden" value="showDatabase"/>"""
+            """<input name="ProbeSetID" type="hidden" value="_"/>"""
+            """<input name="database" type="hidden" value="TestGeno"/>"""
+            """<input name="CellID" type="hidden" value="_"/>"""
+            """<input name="RISet" type="hidden" value="Test"/>"""
+            """<input name="incparentsf1" type="hidden" value="ON"/>"""
+            """<img alt="random" border="0" height="13" src="test.png" """
+            """usemap="#webqtlmap" width="10"/>"""
+            """</form>"""))
+
+    def test_create_paragraph(self):
+        """Test HT.Paragraph method"""
+        test_p_element = HtmlGenWrapper.create_p_tag(id="smallSize")
+        par_text = (
+            "Mapping using genotype data as "
+            "a trait will result in infinity LRS at one locus. "
+            "In order to display the result properly, all LRSs "
+            "higher than 100 are capped at 100."
+        )
+        self.assertEqual(
+            str(test_p_element),
+            """<p id="smallSize"></p>"""
+        )
+        test_p_element.append(HtmlGenWrapper.create_br_tag())
+        test_p_element.append(par_text)
+        self.assertEqual(
+            str(test_p_element),
+            """<p id="smallSize"><br/>{}</p>""".format(par_text)
+        )
+
+    def test_create_br_tag(self):
+        """Test HT.BR() method"""
+        self.assertEqual(str(HtmlGenWrapper.create_br_tag()),
+                         "<br/>")
+
+    def test_create_input_tag(self):
+        """Test HT.Input method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_input_tag(
+                type_="hidden",
+                name="name",
+                value="key",
+                Class="trait trait_")).replace("\n", ""),
+            ("""<input class="trait trait_" name="name" """
+             """type="hidden" value="key"/>"""))
+
+    def test_create_map_tag(self):
+        """Test HT.Map method"""
+        self.assertEqual(str(HtmlGenWrapper.create_map_tag(
+            name="WebqTLImageMap")).replace("\n", ""),
+            """<map name="WebqTLImageMap"></map>""")
+        gifmap = HtmlGenWrapper.create_map_tag(name="test")
+        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
+                                                     coords='1 2 3', href='#area1'))
+        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
+                                                     coords='1 2 3', href='#area2'))
+        self.assertEqual(
+            str(gifmap).replace("\n", ""),
+            ("""<map name="test">"""
+             """<area coords="1 2 3" """
+             """href="#area1" shape="rect"/>"""
+             """<area coords="1 2 3" href="#area2" shape="rect"/>"""
+             """</map>"""))
+
+    def test_create_area_tag(self):
+        """Test HT.Area method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_area_tag(
+                shape="rect",
+                coords="1 2",
+                href="http://test.com",
+                title="Some Title")).replace("\n", ""),
+            ("""<area coords="1 2" href="http://test.com" """
+             """shape="rect" title="Some Title"/>"""))
+
+    def test_create_link_tag(self):
+        """Test HT.HREF method"""
+        self.assertEqual(
+            str(HtmlGenWrapper.create_link_tag(
+                "www.test.com", "test", target="_blank")).replace("\n", ""),
+            """<a href="www.test.com" target="_blank">test</a>""")
diff --git a/wqflask/tests/unit/wqflask/show_trait/__init__.py b/wqflask/tests/unit/wqflask/show_trait/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py
new file mode 100644
index 00000000..41761944
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/show_trait/test_export_trait_data.py
@@ -0,0 +1,212 @@
+import unittest
+from unittest import mock
+from wqflask.show_trait.export_trait_data import dict_to_sorted_list
+from wqflask.show_trait.export_trait_data import cmp_samples
+from wqflask.show_trait.export_trait_data import export_sample_table
+from wqflask.show_trait.export_trait_data import get_export_metadata
+
+
+class AttributesSetter:
+    def __init__(self, obj):
+        for key, value in obj.items():
+            setattr(self, key, value)
+
+
+class TestExportTraits(unittest.TestCase):
+    """Test methods related to converting dict to sortedlist"""
+    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
+    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
+    def test_get_export_metadata_no_publish(self, mock_dataset, mock_trait):
+        """test for exporting metadata with no publish"""
+        mock_dataset_attributes = AttributesSetter(
+            {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
+
+        mock_nested_attributes = AttributesSetter({"name": "name"})
+        mock_dataset_attributes.group = mock_nested_attributes
+        mock_dataset.create_dataset.return_value = mock_dataset_attributes
+        mock_trait.return_value = AttributesSetter({"symbol": "", "description_display": "Description",
+                                                    "title": "research1", "journal": "", "authors": ""})
+
+        results = get_export_metadata("random_id", "Temp")
+        expected = [["Record ID: random_id"],
+                    ["Trait URL: http://genenetwork.org/show_trait?trait_id=random_id&dataset=Temp"],
+                    ["Dataset: Temp"],
+                    ["Group: name"], []]
+
+        mock_dataset.create_dataset.assert_called_with("Temp")
+        mock_trait.assert_called_with(
+            dataset=mock_dataset_attributes, name="random_id", cellid=None, get_qtl_info=False)
+        self.assertEqual(results, expected)
+
+    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
+    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
+    def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
+        """test for exporting metadata with dataset.type=Publish"""
+        mock_dataset_attributes = AttributesSetter({"type": "Publish", "dataset_name": "Temp",
+                                                    "name": "Temp", "description_display": "Description goes here"})
+
+        mock_nested_attributes = AttributesSetter({"name": "name"})
+        mock_dataset_attributes.group = mock_nested_attributes
+        data_mock.create_dataset.return_value = mock_dataset_attributes
+        trait_instance = AttributesSetter({"symbol": "", "description_display": "Description",
+                                           "title": "research1", "journal": "", "authors": ""})
+        trait_mock.return_value = trait_instance
+
+        results = get_export_metadata(
+            "29ae0615-0d77-4814-97c7-c9e91f6bfd7b", "Temp")
+
+        expected = [['Phenotype ID: 29ae0615-0d77-4814-97c7-c9e91f6bfd7b'],
+                    ['Phenotype URL: http://genenetwork.org/show_trait?trait_id=29ae0615-0d77-4814-97c7-c9e91f6bfd7b&dataset=Temp'], [
+                        'Group: name'], ['Phenotype: Description'],
+                    ['Authors: N/A'], ['Title: research1'],
+                    ['Journal: N/A'], ['Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=Temp'], []]
+
+        self.assertEqual(results, expected)
+
+    @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
+    @mock.patch("wqflask.show_trait.export_trait_data.get_export_metadata")
+    def test_export_sample_table(self, exp_metadata, dict_list):
+        """test for  exporting sample table"""
+        targs_obj = {
+            "export_data": """{
+                "primary_samples": [
+                    {
+                        "other": "germanotta",
+                        "name": "Sauroniops",
+                        "se":{
+                        "name":"S2"
+                        },
+                        "num_cases":{
+                        "k1":"value"
+
+                        }
+                    }
+                ],
+                "other_samples": [
+                    {
+                        "se": 1,
+                        "num_cases": 4,
+                        "value": 6,
+                        "name": 3
+                    }
+                ]
+            }""",
+            "trait_display_name": "Hair_color",
+            "trait_id": "23177fdc-312e-4084-ad0c-f3eae785fff5",
+            "dataset": {
+            }
+        }
+        exp_metadata.return_value = [
+            ["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'],
+            ["Phenotype:p1"], [
+                "Authors:N/A"],
+            ["Title:research1"],
+            ["Journal:N/A"],
+            ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
+        expected = ('Hair_color',
+                    [['Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f'],
+                     ['Group:gp1'],
+                     ['Phenotype:p1'],
+                     ['Authors:N/A'],
+                     ['Title:research1'],
+                     ['Journal:N/A'],
+                     ['Dataset Link: '
+                      'http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1'],
+                     [],
+                     ['Name', 'Value', 'SE', 'N'],
+                     ['Sauroniops', 'germanotta'],
+                     [3, 6, 1, 4]])
+
+        dict_list.side_effect = [['Sauroniops', 'germanotta'], [3, 6, 1, 4]]
+
+        self.assertEqual(export_sample_table(targs_obj), expected)
+        exp_metadata.assert_called_with(
+            "23177fdc-312e-4084-ad0c-f3eae785fff5", {})
+        self.assertEqual(dict_list.call_count, 2)
+
+    def test_dict_to_sortedlist(self):
+        """test for conversion of dict to sorted list"""
+        sample1 = {
+            "other": "exp1",
+            "name": "exp2"
+        }
+        sample2 = {
+            "se": 1,
+            "num_cases": 4,
+            "value": 6,
+            "name": 3
+
+        }
+        rever = {
+            "name": 3,
+            "value": 6,
+            "num_cases": 4,
+            "se": 1
+        }
+        oneItem = {
+            "item1": "one"
+        }
+
+        self.assertEqual(["exp2", "exp1"], dict_to_sorted_list(sample1))
+        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2))
+        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever))
+        self.assertEqual(["one"], dict_to_sorted_list(oneItem))
+        """test that the func returns the values not the keys"""
+        self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
+
+    def test_cmp_samples(self):
+        """test for comparing samples function"""
+        sampleA = [
+            [
+                ("value", "other"),
+                ("name", "test_name")
+            ]
+        ]
+        sampleB = [
+            [
+                ("value", "other"),
+                ("unknown", "test_name")
+            ]
+        ]
+        sampleC = [
+            [("other", "value"),
+             ("name", "value")
+             ],
+            [
+                ("name", "value"),
+                ("value", "name")
+            ],
+            [
+                ("other", "value"),
+                ("name", "value"
+                 )],
+            [
+                ("name", "name1"),
+                ("se", "valuex")
+            ],
+            [(
+                "value", "name1"),
+                ("se", "valuex")
+             ],
+            [(
+                "other", "name1"),
+                ("se", "valuex"
+                 )
+             ],
+            [(
+                "name", "name_val"),
+                ("num_cases", "num_val")
+             ],
+            [(
+                "other_a", "val_a"),
+                ("other_b", "val"
+                 )
+             ]
+        ]
+        results = [cmp_samples(val[0], val[1]) for val in sampleA]
+        resultB = [cmp_samples(val[0], val[1]) for val in sampleB]
+        resultC = [cmp_samples(val[0], val[1]) for val in sampleC]
+
+        self.assertEqual(1, *results)
+        self.assertEqual(-1, *resultB)
+        self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC)
diff --git a/wqflask/tests/unit/wqflask/test_collect.py b/wqflask/tests/unit/wqflask/test_collect.py
new file mode 100644
index 00000000..9a36132d
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_collect.py
@@ -0,0 +1,73 @@
+"""Test cases for some methods in collect.py"""
+
+import unittest
+from unittest import mock
+
+from flask import Flask
+from wqflask.collect import process_traits
+
+app = Flask(__name__)
+
+
+class MockSession:
+    """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def logged_in(self):
+        return self.is_logged_in
+
+
+class MockFlaskG:
+    """Helper class for mocking wqflask.collect.g.user_session"""
+    def __init__(self, is_logged_in=False):
+        self.is_logged_in = is_logged_in
+
+    @property
+    def user_session(self):
+        if self.is_logged_in:
+            return MockSession(is_logged_in=True)
+        return MockSession()
+
+
+class TestCollect(unittest.TestCase):
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("wqflask.collect.g", MockFlaskG())
+    def test_process_traits_with_bytestring(self):
+        """
+        Test that the correct traits are returned when the user is logged
+        out and bytes are used.
+        """
+        self.assertEqual(process_traits(
+            b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+            b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+            b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+            b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
+            set(['1429252_at:HC_M2_0606_P',
+                 '1451401_a_at:HC_M2_0606_P',
+                 '1452447_at:HC_M2_0606_P',
+                 '1452452_at:HC_M2_0606_P']))
+
+    @mock.patch("wqflask.collect.g", MockFlaskG())
+    def test_process_traits_with_normal_string(self):
+        """
+        Test that the correct traits are returned when the user is logged
+        out and a normal string is used.
+        """
+        self.assertEqual(process_traits(
+            '1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
+            '1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
+            '1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
+            '1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
+            set(['1429252_at:HC_M2_0606_P',
+                 '1451401_a_at:HC_M2_0606_P',
+                 '1452447_at:HC_M2_0606_P',
+                 '1452452_at:HC_M2_0606_P']))
diff --git a/wqflask/tests/unit/wqflask/test_pbkdf2.py b/wqflask/tests/unit/wqflask/test_pbkdf2.py
new file mode 100644
index 00000000..a33fbd4f
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_pbkdf2.py
@@ -0,0 +1,61 @@
+"""Test cases pbkdf2"""
+
+import unittest
+from wqflask.pbkdf2 import pbkdf2_hex
+
+
+class TestPbkdf2(unittest.TestCase):
+    def test_pbkdf2_hex(self):
+        """
+        Test pbkdf2_hex function
+        """
+
+        for password, salt, iterations, keylen, expected_value in [
+                ('password', 'salt', 1, 20,
+                 '0c60c80f961f0e71f3a9b524af6012062fe037a6'),
+                ('password', 'salt', 2, 20,
+                 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'),
+                ('password', 'salt', 4096, 20,
+                 '4b007901b765489abead49d926f721d065a429c1'),
+                ('passwordPASSWORDpassword',
+                 'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+                 4096, 25,
+                 '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'),
+                ('pass\x00word', 'sa\x00lt', 4096, 16,
+                 '56fa6aa75548099dcc37d7f03425e0c3'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1, 16,
+                 'cdedb5281bb2f801565a1122b2563515'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1, 32,
+                 ('cdedb5281bb2f80'
+                  '1565a1122b256351'
+                  '50ad1f7a04bb9f3a33'
+                  '3ecc0e2e1f70837')),
+                ('password', 'ATHENA.MIT.EDUraeburn', 2, 16,
+                 '01dbee7f4a9e243e988b62c73cda935d'),
+                ('password', 'ATHENA.MIT.EDUraeburn', 2, 32,
+                 ('01dbee7f4a9e243e9'
+                  '88b62c73cda935da05'
+                  '378b93244ec8f48a99'
+                  'e61ad799d86')),
+                ('password', 'ATHENA.MIT.EDUraeburn', 1200, 32,
+                 ('5c08eb61fdf71e'
+                  '4e4ec3cf6ba1f55'
+                  '12ba7e52ddbc5e51'
+                  '42f708a31e2e62b1e13')),
+                ('X' * 64, 'pass phrase equals block size', 1200, 32,
+                 ('139c30c0966bc32ba'
+                  '55fdbf212530ac9c5'
+                  'ec59f1a452f5cc9ad'
+                  '940fea0598ed1')),
+                ('X' * 65, 'pass phrase exceeds block size', 1200, 32,
+                 ('9ccad6d468770cd'
+                  '51b10e6a68721be6'
+                  '11a8b4d282601db3'
+                  'b36be9246915ec82a'))
+        ]:
+            self.assertEqual(
+                pbkdf2_hex(data=password,
+                           salt=salt,
+                           iterations=iterations,
+                           keylen=keylen),
+                expected_value)
diff --git a/wqflask/tests/unit/wqflask/test_user_login.py b/wqflask/tests/unit/wqflask/test_user_login.py
new file mode 100644
index 00000000..61cd9ab9
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_user_login.py
@@ -0,0 +1,21 @@
+"""Test cases for some methods in login.py"""
+
+import unittest
+from wqflask.user_login import encode_password
+
+
+class TestUserLogin(unittest.TestCase):
+    def test_encode_password(self):
+        """
+        Test encode password
+        """
+        pass_gen_fields = {
+            "salt": "salt",
+            "hashfunc": "sha1",
+            "iterations": 4096,
+            "keylength": 20,
+        }
+        self.assertEqual(
+            encode_password(pass_gen_fields,
+                            "password").get("password"),
+            '4b007901b765489abead49d926f721d065a429c1')
diff --git a/wqflask/tests/unit/wqflask/test_user_session.py b/wqflask/tests/unit/wqflask/test_user_session.py
new file mode 100644
index 00000000..ebb0334a
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_user_session.py
@@ -0,0 +1,15 @@
+"""Test cases for some methods in user_session.py"""
+
+import unittest
+from wqflask.user_session import verify_cookie
+
+
+class TestUserSession(unittest.TestCase):
+    def test_verify_cookie(self):
+        """
+        Test cookie verification
+        """
+        self.assertEqual(
+            "3f4c1dbf-5b56-4260-87d6-f35445bda37e",
+            verify_cookie(("3f4c1dbf-5b56-4260-87d6-"
+                           "f35445bda37e:af4fcf5eace9e7c864ce")))
diff --git a/wqflask/tests/utility/__init__.py b/wqflask/tests/utility/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/utility/test_authentication_tools.py b/wqflask/tests/utility/test_authentication_tools.py
deleted file mode 100644
index 5c391be5..00000000
--- a/wqflask/tests/utility/test_authentication_tools.py
+++ /dev/null
@@ -1,189 +0,0 @@
-"""Tests for authentication tools"""
-import unittest
-from unittest import mock
-
-from utility.authentication_tools import check_resource_availability
-from utility.authentication_tools import add_new_resource
-
-
-class TestResponse:
-    """Mock Test Response after a request"""
-    @property
-    def content(self):
-        """Mock the content from Requests.get(params).content"""
-        return '["foo"]'
-
-
-class TestUser:
-    """Mock user"""
-    @property
-    def user_id(self):
-        """Mockes user id. Used in Flask.g.user_session.user_id"""
-        return "Jane"
-
-
-class TestUserSession:
-    """Mock user session"""
-    @property
-    def user_session(self):
-        """Mock user session. Mocks Flask.g.user_session object"""
-        return TestUser()
-
-
-def mock_add_resource(resource_ob, update=False):
-    return resource_ob
-
-
-class TestCheckResourceAvailability(unittest.TestCase):
-    """Test methods related to checking the resource availability"""
-    @mock.patch('utility.authentication_tools.add_new_resource')
-    @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g', mock.Mock())
-    @mock.patch('utility.authentication_tools.get_resource_id')
-    def test_check_resource_availability_default_mask(
-            self,
-            resource_id_mock,
-            redis_mock,
-            add_new_resource_mock):
-        """Test the resource availability with default mask"""
-        resource_id_mock.return_value = 1
-        redis_mock.smembers.return_value = []
-        test_dataset = mock.MagicMock()
-        type(test_dataset).type = mock.PropertyMock(return_value="Test")
-        add_new_resource_mock.return_value = {"default_mask": 2}
-        self.assertEqual(check_resource_availability(test_dataset), 2)
-
-    @mock.patch('utility.authentication_tools.requests.get')
-    @mock.patch('utility.authentication_tools.add_new_resource')
-    @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g', TestUserSession())
-    @mock.patch('utility.authentication_tools.get_resource_id')
-    def test_check_resource_availability_non_default_mask(
-            self,
-            resource_id_mock,
-            redis_mock,
-            add_new_resource_mock,
-            requests_mock):
-        """Test the resource availability with default mask"""
-        resource_id_mock.return_value = 1
-        redis_mock.smembers.return_value = []
-        add_new_resource_mock.return_value = {"default_mask": 2}
-        requests_mock.return_value = TestResponse()
-        test_dataset = mock.MagicMock()
-        type(test_dataset).type = mock.PropertyMock(return_value="Test")
-        self.assertEqual(check_resource_availability(test_dataset),
-                         ['foo'])
-
-    @mock.patch('utility.authentication_tools.webqtlConfig.SUPER_PRIVILEGES',
-                "SUPERUSER")
-    @mock.patch('utility.authentication_tools.requests.get')
-    @mock.patch('utility.authentication_tools.add_new_resource')
-    @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g', TestUserSession())
-    @mock.patch('utility.authentication_tools.get_resource_id')
-    def test_check_resource_availability_of_super_user(
-            self,
-            resource_id_mock,
-            redis_mock,
-            add_new_resource_mock,
-            requests_mock):
-        """Test the resource availability if the user is the super user"""
-        resource_id_mock.return_value = 1
-        redis_mock.smembers.return_value = ["Jane"]
-        add_new_resource_mock.return_value = {"default_mask": 2}
-        requests_mock.return_value = TestResponse()
-        test_dataset = mock.MagicMock()
-        type(test_dataset).type = mock.PropertyMock(return_value="Test")
-        self.assertEqual(check_resource_availability(test_dataset),
-                         "SUPERUSER")
-
-    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
-                "John Doe")
-    def test_check_resource_availability_string_dataset(self):
-        """Test the resource availability if the dataset is a string"""
-        self.assertEqual(check_resource_availability("Test"),
-                         "John Doe")
-
-    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
-                "John Doe")
-    def test_check_resource_availability_temp(self):
-        """Test the resource availability if the dataset is a string"""
-        test_dataset = mock.MagicMock()
-        type(test_dataset).type = mock.PropertyMock(return_value="Temp")
-        self.assertEqual(check_resource_availability(test_dataset),
-                         "John Doe")
-
-
-class TestAddNewResource(unittest.TestCase):
-    """Test cases for add_new_resource method"""
-    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
-                "John Doe")
-    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
-    @mock.patch('utility.authentication_tools.get_group_code')
-    def test_add_new_resource_if_publish_datatype(self, group_code_mock):
-        """Test add_new_resource if dataset type is 'publish'"""
-        group_code_mock.return_value = "Test"
-        test_dataset = mock.MagicMock()
-        type(test_dataset).type = mock.PropertyMock(return_value="Publish")
-        type(test_dataset).id = mock.PropertyMock(return_value=10)
-        expected_value = {
-            "owner_id": "none",
-            "default_mask": "John Doe",
-            "group_masks": {},
-            "name": "Test_None",
-            "data": {
-                "dataset": 10,
-                "trait": None
-            },
-            "type": "dataset-publish"
-        }
-        self.assertEqual(add_new_resource(test_dataset),
-                         expected_value)
-
-    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
-                "John Doe")
-    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
-    @mock.patch('utility.authentication_tools.get_group_code')
-    def test_add_new_resource_if_geno_datatype(self, group_code_mock):
-        """Test add_new_resource if dataset type is 'geno'"""
-        group_code_mock.return_value = "Test"
-        test_dataset = mock.MagicMock()
-        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
-        type(test_dataset).type = mock.PropertyMock(return_value="Geno")
-        type(test_dataset).id = mock.PropertyMock(return_value=20)
-        expected_value = {
-            "owner_id": "none",
-            "default_mask": "John Doe",
-            "group_masks": {},
-            "name": "Geno",
-            "data": {
-                "dataset": 20,
-            },
-            "type": "dataset-geno"
-        }
-        self.assertEqual(add_new_resource(test_dataset),
-                         expected_value)
-
-    @mock.patch('utility.authentication_tools.webqtlConfig.DEFAULT_PRIVILEGES',
-                "John Doe")
-    @mock.patch('utility.authentication_tools.add_resource', mock_add_resource)
-    @mock.patch('utility.authentication_tools.get_group_code')
-    def test_add_new_resource_if_other_datatype(self, group_code_mock):
-        """Test add_new_resource if dataset type is not 'geno' or 'publish'"""
-        group_code_mock.return_value = "Test"
-        test_dataset = mock.MagicMock()
-        type(test_dataset).name = mock.PropertyMock(return_value="Geno")
-        type(test_dataset).type = mock.PropertyMock(return_value="other")
-        type(test_dataset).id = mock.PropertyMock(return_value=20)
-        expected_value = {
-            "owner_id": "none",
-            "default_mask": "John Doe",
-            "group_masks": {},
-            "name": "Geno",
-            "data": {
-                "dataset": 20,
-            },
-            "type": "dataset-probeset"
-        }
-        self.assertEqual(add_new_resource(test_dataset),
-                         expected_value)
diff --git a/wqflask/tests/utility/test_chunks.py b/wqflask/tests/utility/test_chunks.py
deleted file mode 100644
index 8d90a1ec..00000000
--- a/wqflask/tests/utility/test_chunks.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""Test chunking"""
-
-import unittest
-
-from utility.chunks import divide_into_chunks
-
-
-class TestChunks(unittest.TestCase):
-    "Test Utility method for chunking"
-    def test_divide_into_chunks(self):
-        "Check that a list is chunked correctly"
-        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3),
-                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
-        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 4),
-                         [[1, 2, 7], [3, 22, 8], [5, 22, 333]])
-        self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 5),
-                         [[1, 2], [7, 3], [22, 8], [5, 22], [333]])
-        self.assertEqual(divide_into_chunks([], 5),
-                         [[]])
diff --git a/wqflask/tests/utility/test_corestats.py b/wqflask/tests/utility/test_corestats.py
deleted file mode 100644
index cf91a248..00000000
--- a/wqflask/tests/utility/test_corestats.py
+++ /dev/null
@@ -1,55 +0,0 @@
-"""Test Core Stats"""
-
-import unittest
-
-from utility.corestats import Stats
-
-
-class TestChunks(unittest.TestCase):
-    "Test Utility method for chunking"
-
-    def setUp(self):
-        self.stat_test = Stats((x for x in range(1, 11)))
-
-    def test_stats_sum(self):
-        """ Test sequence sum """
-        self.assertEqual(self.stat_test.sum(), 55)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.sum(), None)
-
-    def test_stats_count(self):
-        """ Test sequence count """
-        self.assertEqual(self.stat_test.count(), 10)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.count(), 0)
-
-    def test_stats_min(self):
-        """ Test min value in sequence"""
-        self.assertEqual(self.stat_test.min(), 1)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.min(), None)
-
-    def test_stats_max(self):
-        """ Test max value in sequence """
-        self.assertEqual(self.stat_test.max(), 10)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.max(), None)
-
-    def test_stats_avg(self):
-        """ Test avg of sequence """
-        self.assertEqual(self.stat_test.avg(), 5.5)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.avg(), None)
-
-    def test_stats_stdev(self):
-        """ Test standard deviation of sequence """
-        self.assertEqual(self.stat_test.stdev(), 3.0276503540974917)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.stdev(), None)
-
-    def test_stats_percentile(self):
-        """ Test percentile of sequence """
-        self.assertEqual(self.stat_test.percentile(20), 3.0)
-        self.assertEqual(self.stat_test.percentile(101), None)
-        self.stat_test = Stats([])
-        self.assertEqual(self.stat_test.percentile(20), None)
diff --git a/wqflask/tests/utility/test_corr_result_helpers.py b/wqflask/tests/utility/test_corr_result_helpers.py
deleted file mode 100644
index e196fbdf..00000000
--- a/wqflask/tests/utility/test_corr_result_helpers.py
+++ /dev/null
@@ -1,32 +0,0 @@
-""" Test correlation helper methods """
-
-import unittest
-from utility.corr_result_helpers import normalize_values, common_keys, normalize_values_with_samples
-
-
-class TestCorrelationHelpers(unittest.TestCase):
-    """Test methods for normalising lists"""
-
-    def test_normalize_values(self):
-        """Test that a list is normalised correctly"""
-        self.assertEqual(
-            normalize_values([2.3, None, None, 3.2, 4.1, 5], [
-                             3.4, 7.2, 1.3, None, 6.2, 4.1]),
-            ([2.3, 4.1, 5], [3.4, 6.2, 4.1], 3)
-        )
-
-    def test_common_keys(self):
-        """Test that common keys are returned as a list"""
-        a = dict(BXD1=9.113, BXD2=9.825, BXD14=8.985, BXD15=9.300)
-        b = dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)
-        self.assertEqual(sorted(common_keys(a, b)), ['BXD1', 'BXD14'])
-
-    def test_normalize_values_with_samples(self):
-        """Test that a sample(dict) is normalised correctly"""
-        self.assertEqual(
-            normalize_values_with_samples(
-                dict(BXD1=9.113, BXD2=9.825, BXD14=8.985,
-                     BXD15=9.300, BXD20=9.300),
-                dict(BXD1=9.723, BXD3=9.825, BXD14=9.124, BXD16=9.300)),
-            (({'BXD1': 9.113, 'BXD14': 8.985}, {'BXD1': 9.723, 'BXD14': 9.124}, 2))
-        )
diff --git a/wqflask/tests/utility/test_formatting.py b/wqflask/tests/utility/test_formatting.py
deleted file mode 100644
index 9d3033d1..00000000
--- a/wqflask/tests/utility/test_formatting.py
+++ /dev/null
@@ -1,33 +0,0 @@
-import unittest
-from utility.formatting import numify, commify
-
-
-class TestFormatting(unittest.TestCase):
-    """Test formatting numbers by numifying or commifying"""
-
-    def test_numify(self):
-        "Test that a number is correctly converted to a English readable string"
-        self.assertEqual(numify(1, 'item', 'items'),
-                         'one item')
-        self.assertEqual(numify(2, 'book'), 'two')
-        self.assertEqual(numify(2, 'book', 'books'), 'two books')
-        self.assertEqual(numify(0, 'book', 'books'), 'zero books')
-        self.assertEqual(numify(0), 'zero')
-        self.assertEqual(numify(5), 'five')
-        self.assertEqual(numify(14, 'book', 'books'), '14 books')
-        self.assertEqual(numify(999, 'book', 'books'), '999 books')
-        self.assertEqual(numify(1000000, 'book', 'books'), '1,000,000 books')
-        self.assertEqual(numify(1956), '1956')
-
-    def test_commify(self):
-        "Test that commas are added correctly"
-        self.assertEqual(commify(1), '1')
-        self.assertEqual(commify(123), '123')
-        self.assertEqual(commify(1234), '1234')
-        self.assertEqual(commify(12345), '12,345')
-        self.assertEqual(commify(1234567890), '1,234,567,890')
-        self.assertEqual(commify(123.0), '123.0')
-        self.assertEqual(commify(1234.5), '1234.5')
-        self.assertEqual(commify(1234.56789), '1234.56789')
-        self.assertEqual(commify(123456.789), '123,456.789')
-        self.assertEqual(commify(None), None)
diff --git a/wqflask/tests/utility/test_hmac.py b/wqflask/tests/utility/test_hmac.py
deleted file mode 100644
index 4e3652f8..00000000
--- a/wqflask/tests/utility/test_hmac.py
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Test hmac utility functions"""
-
-import unittest
-from unittest import mock
-
-from utility.hmac import data_hmac
-from utility.hmac import url_for_hmac
-from utility.hmac import hmac_creation
-
-
-class TestHmacUtil(unittest.TestCase):
-    """Test Utility method for hmac creation"""
-
-    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
-    def test_hmac_creation(self):
-        """Test hmac creation with a utf-8 string"""
-        self.assertEqual(hmac_creation("ファイ"), "7410466338cfe109e946")
-
-    @mock.patch("utility.hmac.app.config",
-                {'SECRET_HMAC_CODE': ('\x08\xdf\xfa\x93N\x80'
-                                      '\xd9\\H@\\\x9f`\x98d^'
-                                      '\xb4a;\xc6OM\x946a\xbc'
-                                      '\xfc\x80:*\xebc')})
-    def test_hmac_creation_with_cookie(self):
-        """Test hmac creation with a cookie"""
-        cookie = "3f4c1dbf-5b56-4260-87d6-f35445bda37e:af4fcf5eace9e7c864ce"
-        uuid_, _, signature = cookie.partition(":")
-        self.assertEqual(
-            hmac_creation(uuid_),
-            "af4fcf5eace9e7c864ce")
-
-    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
-    def test_data_hmac(self):
-        """Test data_hmac fn with a utf-8 string"""
-        self.assertEqual(data_hmac("ファイ"), "ファイ:7410466338cfe109e946")
-
-    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
-    @mock.patch("utility.hmac.url_for")
-    def test_url_for_hmac_with_plain_url(self, mock_url):
-        """Test url_for_hmac without params"""
-        mock_url.return_value = "https://mock_url.com/ファイ/"
-        self.assertEqual(url_for_hmac("ファイ"),
-                         "https://mock_url.com/ファイ/?hm=05bc39e659b1948f41e7")
-
-    @mock.patch("utility.hmac.app.config", {'SECRET_HMAC_CODE': "secret"})
-    @mock.patch("utility.hmac.url_for")
-    def test_url_for_hmac_with_param_in_url(self, mock_url):
-        """Test url_for_hmac with params"""
-        mock_url.return_value = "https://mock_url.com/?ファイ=1"
-        self.assertEqual(url_for_hmac("ファイ"),
-                         "https://mock_url.com/?ファイ=1&hm=4709c1708270644aed79")
diff --git a/wqflask/tests/wqflask/__init__.py b/wqflask/tests/wqflask/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/wqflask/api/__init__.py b/wqflask/tests/wqflask/api/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/wqflask/api/test_gen_menu.py b/wqflask/tests/wqflask/api/test_gen_menu.py
deleted file mode 100644
index 84898bd1..00000000
--- a/wqflask/tests/wqflask/api/test_gen_menu.py
+++ /dev/null
@@ -1,413 +0,0 @@
-"""Test cases for wqflask.api.gen_menu"""
-import unittest
-from unittest import mock
-
-from wqflask import app
-from wqflask.api.gen_menu import gen_dropdown_json
-from wqflask.api.gen_menu import get_species
-from wqflask.api.gen_menu import get_groups
-from wqflask.api.gen_menu import get_types
-from wqflask.api.gen_menu import get_datasets
-from wqflask.api.gen_menu import phenotypes_exist
-from wqflask.api.gen_menu import genotypes_exist
-from wqflask.api.gen_menu import build_datasets
-from wqflask.api.gen_menu import build_types
-
-
-class TestGenMenu(unittest.TestCase):
-    """Tests for the gen_menu module"""
-
-    def setUp(self):
-        self.app_context = app.app_context()
-        self.app_context.push()
-        self.test_group = {
-            'mouse': [
-                ['H_T1',
-                 'H_T',
-                 'Family:DescriptionA'
-                 ],
-                ['H_T2', "H_T'", 'Family:None']
-            ],
-            'human': [
-                ['BXD', 'BXD', 'Family:None'],
-                ['HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
-                 'Family:Test']
-            ]
-        }
-
-        self.test_type = {
-            'mouse': {
-                'H_T2': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']],
-                'H_T1': [('Phenotypes',
-                          'Traits and Cofactors',
-                          'Phenotypes'),
-                         ('Genotypes',
-                          'DNA Markers and SNPs',
-                          'Genotypes'),
-                         ['M', 'M', 'Molecular Trait Datasets']]
-            },
-            'human': {
-                'HLC': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']],
-                'BXD': [('Phenotypes',
-                         'Traits and Cofactors',
-                         'Phenotypes'),
-                        ('Genotypes',
-                         'DNA Markers and SNPs',
-                         'Genotypes'),
-                        ['M', 'M', 'Molecular Trait Datasets']]
-            }
-        }
-
-    def tearDown(self):
-        self.app_context.pop()
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_species(self, db_mock):
-        """Test that assertion is raised when dataset and dataset_name
-        are defined"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('human', 'Human'),
-            ('mouse', 'Mouse'))
-        self.assertEqual(get_species(),
-                         [['human', 'Human'], ['mouse', 'Mouse']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_groups(self, db_mock):
-        """Test that species groups are grouped correctly"""
-        db_mock.db.execute.return_value.fetchall.side_effect = [
-            # Mouse
-            (('BXD', 'BXD', None),
-             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
-              'Test')),
-            # Human
-            (('H_T1', "H_T", "DescriptionA"),
-             ('H_T2', "H_T'", None))
-        ]
-
-        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
-                         self.test_group)
-
-        for name in ["mouse", "human"]:
-            db_mock.db.execute.assert_any_call(
-                ("SELECT InbredSet.Name, InbredSet.FullName, " +
-                 "IFNULL(InbredSet.Family, 'None') " +
-                 "FROM InbredSet, Species WHERE Species.Name " +
-                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
-                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
-                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
-                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
-                 "InbredSet.MenuOrderId ASC").format(name)
-            )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
-        """Test that phenotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        phenotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM PublishFreeze "
-            "WHERE PublishFreeze.Name = 'testPublish'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_falsy_values(self, db_mock):
-        """Test that phenotype check returns correctly when given
-        a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_truthy_value(self, db_mock):
-        """Test that phenotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_called_with_correct_query(self, db_mock):
-        """Test that genotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        genotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_falsy_values(self, db_mock):
-        """Test that genotype check returns correctly when given
-        a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(genotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_truthy_value(self, db_mock):
-        """Test that genotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (602, "BXDPublish", "BXD Published Phenotypes"),
-        )
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
-            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
-            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
-            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
-            "InfoFiles.InfoPageName = PublishFreeze.Name " +
-            "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [['602', "BXDPublish", "Mouse Phenome Database"]])
-
-        db_mock.db.execute.return_value.fetchall.return_value = ()
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            "BXDPublish", "Mouse Phenome Database"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [["None", "BXDPublish", "Mouse Phenome Database"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type with no
-        results
-
-        """
-        db_mock.db.execute.return_value.fetchall.return_value = None
-        db_mock.db.execute.return_value.fetchone.return_value = (121,
-                                                                 "text value")
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [["None", "121", "text value"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
-            "FROM PublishFreeze, InbredSet "
-            "WHERE InbredSet.Name = 'BXD' AND "
-            "PublishFreeze.InbredSetId = InbredSet.Id "
-            "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_genotypes(self, db_mock):
-        """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            635, "HLCPublish", "HLC Published Genotypes"
-        )
-
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["635", "HLCGeno", "HLC Genotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
-            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
-            "GenoFreeze.InbredSetId = InbredSet.Id AND "
-            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
-            "ORDER BY GenoFreeze.CreateTime DESC"
-        )
-        db_mock.db.execute.return_value.fetchone.return_value = ()
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["None", "HLCGeno", "HLC Genotypes"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_mrna(self, db_mock):
-        """Test that correct dataset is returned for a mRNA
-        expression/ Probeset"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (112, "HC_M2_0606_P",
-             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
-        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
-            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
-        ]])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
-            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
-            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
-            "Species.Name = 'Mouse' AND Species.Id = " +
-            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
-            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
-            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-            "ORDER BY ProbeSetFreeze.CreateTime DESC")
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_types(self, db_mock, datasets_mock):
-        """Test that correct tissue metadata is returned"""
-        datasets_mock.return_value = [
-            ["112", 'HC_M2_0606_P',
-                "Hippocampus Consortium M430v2 (Jun06) PDNN"]
-        ]
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
-        )
-        self.assertEqual(build_types('mouse', 'random group'),
-                         [['M', 'M', 'Molecular Traits'],
-                          ['H', 'H', 'Molecular Traits'],
-                          ['R', 'R', 'Molecular Traits']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT DISTINCT Tissue.Name " +
-            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
-            "Tissue, Species WHERE Species.Name = 'mouse' " +
-            "AND Species.Id = InbredSet.SpeciesId AND " +
-            "InbredSet.Name = 'random group' AND " +
-            "ProbeFreeze.TissueId = Tissue.Id AND " +
-            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
-            "ORDER BY Tissue.Name"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_existing_genotype_and_phenotypes(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes and genotypes
-        exist
-
-        """
-        phenotypes_exist_mock.return_value = True
-        genotypes_exist_mock.return_value = True
-
-        expected_result = self.test_type
-
-        build_types_mock.return_value = [
-            ['M', 'M', 'Molecular Trait Datasets']
-        ]
-        self.assertEqual(get_types(self.test_group), expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_buildtype_and_non_existent_genotype_and_phenotypes(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes_exist and
-        genotypes_exist are false but build_type is falsy
-
-        """
-        phenotypes_exist_mock.return_value = False
-        genotypes_exist_mock.return_value = False
-
-        build_types_mock.return_value = []
-        self.assertEqual(get_types(self.test_group), {
-            'mouse': {},
-            'human': {}
-        })
-
-    @mock.patch('wqflask.api.gen_menu.build_types')
-    @mock.patch('wqflask.api.gen_menu.genotypes_exist')
-    @mock.patch('wqflask.api.gen_menu.phenotypes_exist')
-    def test_get_types_with_non_existent_genotype_phenotypes_and_buildtype(
-            self,
-            phenotypes_exist_mock,
-            genotypes_exist_mock,
-            build_types_mock):
-        """Test that build types are constructed correctly if phenotypes_exist,
-        genotypes_exist and build_types are truthy
-
-        """
-        phenotypes_exist_mock.return_value = False
-        genotypes_exist_mock.return_value = False
-
-        build_types_mock.return_value = [
-            ['M', 'M', 'Molecular Trait Datasets']
-        ]
-        expected_result = {
-            'mouse': {
-                'H_T2': [['M', 'M', 'Molecular Trait Datasets']],
-                'H_T1': [['M', 'M', 'Molecular Trait Datasets']]},
-            'human': {
-                'HLC': [['M', 'M', 'Molecular Trait Datasets']],
-                'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
-        self.assertEqual(get_types(self.test_group),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    def test_get_datasets_with_existent_datasets(self,
-                                                 build_datasets_mock):
-        """Test correct dataset is returned with existent build_datasets"""
-        build_datasets_mock.return_value = "Test"
-        expected_result = {
-            'mouse': {
-                'H_T2': {'Genotypes': 'Test',
-                         'M': 'Test',
-                         'Phenotypes': 'Test'},
-                'H_T1': {'Genotypes': 'Test',
-                         'M': 'Test',
-                         'Phenotypes': 'Test'}},
-            'human': {'HLC': {'Genotypes': 'Test',
-                              'M': 'Test',
-                              'Phenotypes': 'Test'},
-                      'BXD': {'Genotypes': 'Test',
-                              'M': 'Test',
-                              'Phenotypes': 'Test'}}}
-        self.assertEqual(get_datasets(self.test_type),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.build_datasets')
-    def test_get_datasets_with_non_existent_datasets(self,
-                                                     build_datasets_mock):
-        """Test correct dataset is returned with non-existent build_datasets"""
-        build_datasets_mock.return_value = None
-        expected_result = {
-            'mouse': {
-                'H_T2': {},
-                'H_T1': {}},
-            'human': {'HLC': {},
-                      'BXD': {}}}
-        self.assertEqual(get_datasets(self.test_type),
-                         expected_result)
-
-    @mock.patch('wqflask.api.gen_menu.get_datasets')
-    @mock.patch('wqflask.api.gen_menu.get_types')
-    @mock.patch('wqflask.api.gen_menu.get_groups')
-    @mock.patch('wqflask.api.gen_menu.get_species')
-    def test_gen_dropdown_json(self,
-                               species_mock,
-                               groups_mock,
-                               types_mock,
-                               datasets_mock):
-        "Test that the correct dictionary is constructed properly"
-        species_mock.return_value = ("speciesA speciesB speciesC speciesD"
-                                     .split(" "))
-        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
-                                      .split(" "))
-        groups_mock.return_value = ("groupA groupB groupC groupD"
-                                    .split(" "))
-        types_mock.return_value = ("typeA typeB typeC typeD"
-                                   .split(" "))
-        datasets_mock.return_value = ("datasetA datasetB datasetC datasetD"
-                                      .split(" "))
-
-        expected_result = {
-            'datasets': ['datasetA', 'datasetB', 'datasetC', 'datasetD'],
-            'types': ['typeA', 'typeB', 'typeC', 'typeD'],
-            'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
-            'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
-
-        self.assertEqual(gen_dropdown_json(), expected_result)
diff --git a/wqflask/tests/wqflask/marker_regression/__init__.py b/wqflask/tests/wqflask/marker_regression/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
deleted file mode 100644
index 8ae0f09f..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_display_mapping_results.py
+++ /dev/null
@@ -1,156 +0,0 @@
-import unittest
-
-import htmlgen as HT
-from wqflask.marker_regression.display_mapping_results import (
-    DisplayMappingResults,
-    HtmlGenWrapper
-)
-
-
-class TestDisplayMappingResults(unittest.TestCase):
-    """Basic Methods to test Mapping Results"""
-    def test_pil_colors(self):
-        """Test that colors use PILLOW color format"""
-        self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
-                         (245, 211, 211))
-
-
-class TestHtmlGenWrapper(unittest.TestCase):
-    """Test Wrapper around HTMLGen"""
-    def test_create_image(self):
-        """Test HT.Image method"""
-        self.assertEqual(
-            str(HtmlGenWrapper.create_image_tag(src="test.png",
-                                                alt="random",
-                                                border="0",
-                                                width="10",
-                                                height="13",
-                                                usemap="#webqtlmap")),
-            ("""<img alt="random" border="0" height="13" """
-             """src="test.png" usemap="#webqtlmap" """
-             """width="10"/>""")
-        )
-
-    def test_create_form(self):
-        """Test HT.Form method"""
-        test_form = HtmlGenWrapper.create_form_tag(
-            cgi="/testing/",
-            enctype='multipart/form-data',
-            name="formName",
-            submit=HtmlGenWrapper.create_input_tag(type_='hidden', name='Default_Name')
-        )
-        test_image = HtmlGenWrapper.create_image_tag(
-            src="test.png",
-            alt="random",
-            border="0",
-            width="10",
-            height="13",
-            usemap="#webqtlmap"
-        )
-        self.assertEqual(
-            str(test_form).replace("\n", ""),
-            ("""<form action="/testing/" enctype="multipart/form-data" """
-             """method="POST" """
-             """name="formName"><input name="Default_Name" """
-             """type="hidden"/></form>"""))
-        hddn = {
-            'FormID': 'showDatabase',
-            'ProbeSetID': '_',
-            'database': "TestGeno",
-            'CellID': '_',
-            'RISet': "Test",
-            'incparentsf1': 'ON'
-        }
-        for key in hddn.keys():
-            test_form.append(
-                HtmlGenWrapper.create_input_tag(
-                    name=key,
-                    value=hddn[key],
-                    type_='hidden'))
-        test_form.append(test_image)
-
-        self.assertEqual(str(test_form).replace("\n", ""), (
-            """<form action="/testing/" enctype="multipart/form-data" """
-            """method="POST" name="formName">"""
-            """<input name="Default_Name" type="hidden"/>"""
-            """<input name="FormID" type="hidden" value="showDatabase"/>"""
-            """<input name="ProbeSetID" type="hidden" value="_"/>"""
-            """<input name="database" type="hidden" value="TestGeno"/>"""
-            """<input name="CellID" type="hidden" value="_"/>"""
-            """<input name="RISet" type="hidden" value="Test"/>"""
-            """<input name="incparentsf1" type="hidden" value="ON"/>"""
-            """<img alt="random" border="0" height="13" src="test.png" """
-            """usemap="#webqtlmap" width="10"/>"""
-            """</form>"""))
-
-    def test_create_paragraph(self):
-        """Test HT.Paragraph method"""
-        test_p_element = HtmlGenWrapper.create_p_tag(id="smallSize")
-        par_text = (
-            "Mapping using genotype data as "
-            "a trait will result in infinity LRS at one locus. "
-            "In order to display the result properly, all LRSs "
-            "higher than 100 are capped at 100."
-        )
-        self.assertEqual(
-            str(test_p_element),
-            """<p id="smallSize"></p>"""
-        )
-        test_p_element.append(HtmlGenWrapper.create_br_tag())
-        test_p_element.append(par_text)
-        self.assertEqual(
-            str(test_p_element),
-            """<p id="smallSize"><br/>{}</p>""".format(par_text)
-        )
-
-    def test_create_br_tag(self):
-        """Test HT.BR() method"""
-        self.assertEqual(str(HtmlGenWrapper.create_br_tag()),
-                         "<br/>")
-
-    def test_create_input_tag(self):
-        """Test HT.Input method"""
-        self.assertEqual(
-            str(HtmlGenWrapper.create_input_tag(
-                type_="hidden",
-                name="name",
-                value="key",
-                Class="trait trait_")).replace("\n", ""),
-            ("""<input class="trait trait_" name="name" """
-             """type="hidden" value="key"/>"""))
-
-    def test_create_map_tag(self):
-        """Test HT.Map method"""
-        self.assertEqual(str(HtmlGenWrapper.create_map_tag(
-            name="WebqTLImageMap")).replace("\n", ""),
-            """<map name="WebqTLImageMap"></map>""")
-        gifmap = HtmlGenWrapper.create_map_tag(name="test")
-        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
-                                                     coords='1 2 3', href='#area1'))
-        gifmap.append(HtmlGenWrapper.create_area_tag(shape="rect",
-                                                     coords='1 2 3', href='#area2'))
-        self.assertEqual(
-            str(gifmap).replace("\n", ""),
-            ("""<map name="test">"""
-             """<area coords="1 2 3" """
-             """href="#area1" shape="rect"/>"""
-             """<area coords="1 2 3" href="#area2" shape="rect"/>"""
-             """</map>"""))
-
-    def test_create_area_tag(self):
-        """Test HT.Area method"""
-        self.assertEqual(
-            str(HtmlGenWrapper.create_area_tag(
-                shape="rect",
-                coords="1 2",
-                href="http://test.com",
-                title="Some Title")).replace("\n", ""),
-            ("""<area coords="1 2" href="http://test.com" """
-             """shape="rect" title="Some Title"/>"""))
-
-    def test_create_link_tag(self):
-        """Test HT.HREF method"""
-        self.assertEqual(
-            str(HtmlGenWrapper.create_link_tag(
-                "www.test.com", "test", target="_blank")).replace("\n", ""),
-            """<a href="www.test.com" target="_blank">test</a>""")
diff --git a/wqflask/tests/wqflask/show_trait/__init__.py b/wqflask/tests/wqflask/show_trait/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py b/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
deleted file mode 100644
index 41761944..00000000
--- a/wqflask/tests/wqflask/show_trait/test_export_trait_data.py
+++ /dev/null
@@ -1,212 +0,0 @@
-import unittest
-from unittest import mock
-from wqflask.show_trait.export_trait_data import dict_to_sorted_list
-from wqflask.show_trait.export_trait_data import cmp_samples
-from wqflask.show_trait.export_trait_data import export_sample_table
-from wqflask.show_trait.export_trait_data import get_export_metadata
-
-
-class AttributesSetter:
-    def __init__(self, obj):
-        for key, value in obj.items():
-            setattr(self, key, value)
-
-
-class TestExportTraits(unittest.TestCase):
-    """Test methods related to converting dict to sortedlist"""
-    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
-    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
-    def test_get_export_metadata_no_publish(self, mock_dataset, mock_trait):
-        """test for exporting metadata with no publish"""
-        mock_dataset_attributes = AttributesSetter(
-            {"type": "no_publish", "dataset_name": "Temp", "name": "Temp"})
-
-        mock_nested_attributes = AttributesSetter({"name": "name"})
-        mock_dataset_attributes.group = mock_nested_attributes
-        mock_dataset.create_dataset.return_value = mock_dataset_attributes
-        mock_trait.return_value = AttributesSetter({"symbol": "", "description_display": "Description",
-                                                    "title": "research1", "journal": "", "authors": ""})
-
-        results = get_export_metadata("random_id", "Temp")
-        expected = [["Record ID: random_id"],
-                    ["Trait URL: http://genenetwork.org/show_trait?trait_id=random_id&dataset=Temp"],
-                    ["Dataset: Temp"],
-                    ["Group: name"], []]
-
-        mock_dataset.create_dataset.assert_called_with("Temp")
-        mock_trait.assert_called_with(
-            dataset=mock_dataset_attributes, name="random_id", cellid=None, get_qtl_info=False)
-        self.assertEqual(results, expected)
-
-    @mock.patch("wqflask.show_trait.export_trait_data.create_trait")
-    @mock.patch("wqflask.show_trait.export_trait_data.data_set")
-    def test_get_export_metadata_with_publish(self, data_mock, trait_mock):
-        """test for exporting metadata with dataset.type=Publish"""
-        mock_dataset_attributes = AttributesSetter({"type": "Publish", "dataset_name": "Temp",
-                                                    "name": "Temp", "description_display": "Description goes here"})
-
-        mock_nested_attributes = AttributesSetter({"name": "name"})
-        mock_dataset_attributes.group = mock_nested_attributes
-        data_mock.create_dataset.return_value = mock_dataset_attributes
-        trait_instance = AttributesSetter({"symbol": "", "description_display": "Description",
-                                           "title": "research1", "journal": "", "authors": ""})
-        trait_mock.return_value = trait_instance
-
-        results = get_export_metadata(
-            "29ae0615-0d77-4814-97c7-c9e91f6bfd7b", "Temp")
-
-        expected = [['Phenotype ID: 29ae0615-0d77-4814-97c7-c9e91f6bfd7b'],
-                    ['Phenotype URL: http://genenetwork.org/show_trait?trait_id=29ae0615-0d77-4814-97c7-c9e91f6bfd7b&dataset=Temp'], [
-                        'Group: name'], ['Phenotype: Description'],
-                    ['Authors: N/A'], ['Title: research1'],
-                    ['Journal: N/A'], ['Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=Temp'], []]
-
-        self.assertEqual(results, expected)
-
-    @mock.patch("wqflask.show_trait.export_trait_data.dict_to_sorted_list")
-    @mock.patch("wqflask.show_trait.export_trait_data.get_export_metadata")
-    def test_export_sample_table(self, exp_metadata, dict_list):
-        """test for  exporting sample table"""
-        targs_obj = {
-            "export_data": """{
-                "primary_samples": [
-                    {
-                        "other": "germanotta",
-                        "name": "Sauroniops",
-                        "se":{
-                        "name":"S2"
-                        },
-                        "num_cases":{
-                        "k1":"value"
-
-                        }
-                    }
-                ],
-                "other_samples": [
-                    {
-                        "se": 1,
-                        "num_cases": 4,
-                        "value": 6,
-                        "name": 3
-                    }
-                ]
-            }""",
-            "trait_display_name": "Hair_color",
-            "trait_id": "23177fdc-312e-4084-ad0c-f3eae785fff5",
-            "dataset": {
-            }
-        }
-        exp_metadata.return_value = [
-            ["Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f"], ['Group:gp1'],
-            ["Phenotype:p1"], [
-                "Authors:N/A"],
-            ["Title:research1"],
-            ["Journal:N/A"],
-            ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1"], []]
-        expected = ('Hair_color',
-                    [['Phenotype ID:0a2be192-57f5-400b-bbbd-0cf50135995f'],
-                     ['Group:gp1'],
-                     ['Phenotype:p1'],
-                     ['Authors:N/A'],
-                     ['Title:research1'],
-                     ['Journal:N/A'],
-                     ['Dataset Link: '
-                      'http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=name1'],
-                     [],
-                     ['Name', 'Value', 'SE', 'N'],
-                     ['Sauroniops', 'germanotta'],
-                     [3, 6, 1, 4]])
-
-        dict_list.side_effect = [['Sauroniops', 'germanotta'], [3, 6, 1, 4]]
-
-        self.assertEqual(export_sample_table(targs_obj), expected)
-        exp_metadata.assert_called_with(
-            "23177fdc-312e-4084-ad0c-f3eae785fff5", {})
-        self.assertEqual(dict_list.call_count, 2)
-
-    def test_dict_to_sortedlist(self):
-        """test for conversion of dict to sorted list"""
-        sample1 = {
-            "other": "exp1",
-            "name": "exp2"
-        }
-        sample2 = {
-            "se": 1,
-            "num_cases": 4,
-            "value": 6,
-            "name": 3
-
-        }
-        rever = {
-            "name": 3,
-            "value": 6,
-            "num_cases": 4,
-            "se": 1
-        }
-        oneItem = {
-            "item1": "one"
-        }
-
-        self.assertEqual(["exp2", "exp1"], dict_to_sorted_list(sample1))
-        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(sample2))
-        self.assertEqual([3, 6, 1, 4], dict_to_sorted_list(rever))
-        self.assertEqual(["one"], dict_to_sorted_list(oneItem))
-        """test that the func returns the values not the keys"""
-        self.assertFalse(["other", "name"] == dict_to_sorted_list(sample1))
-
-    def test_cmp_samples(self):
-        """test for comparing samples function"""
-        sampleA = [
-            [
-                ("value", "other"),
-                ("name", "test_name")
-            ]
-        ]
-        sampleB = [
-            [
-                ("value", "other"),
-                ("unknown", "test_name")
-            ]
-        ]
-        sampleC = [
-            [("other", "value"),
-             ("name", "value")
-             ],
-            [
-                ("name", "value"),
-                ("value", "name")
-            ],
-            [
-                ("other", "value"),
-                ("name", "value"
-                 )],
-            [
-                ("name", "name1"),
-                ("se", "valuex")
-            ],
-            [(
-                "value", "name1"),
-                ("se", "valuex")
-             ],
-            [(
-                "other", "name1"),
-                ("se", "valuex"
-                 )
-             ],
-            [(
-                "name", "name_val"),
-                ("num_cases", "num_val")
-             ],
-            [(
-                "other_a", "val_a"),
-                ("other_b", "val"
-                 )
-             ]
-        ]
-        results = [cmp_samples(val[0], val[1]) for val in sampleA]
-        resultB = [cmp_samples(val[0], val[1]) for val in sampleB]
-        resultC = [cmp_samples(val[0], val[1]) for val in sampleC]
-
-        self.assertEqual(1, *results)
-        self.assertEqual(-1, *resultB)
-        self.assertEqual([1, -1, 1, -1, -1, 1, -1, -1], resultC)
diff --git a/wqflask/tests/wqflask/test_collect.py b/wqflask/tests/wqflask/test_collect.py
deleted file mode 100644
index 9a36132d..00000000
--- a/wqflask/tests/wqflask/test_collect.py
+++ /dev/null
@@ -1,73 +0,0 @@
-"""Test cases for some methods in collect.py"""
-
-import unittest
-from unittest import mock
-
-from flask import Flask
-from wqflask.collect import process_traits
-
-app = Flask(__name__)
-
-
-class MockSession:
-    """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
-    def __init__(self, is_logged_in=False):
-        self.is_logged_in = is_logged_in
-
-    @property
-    def logged_in(self):
-        return self.is_logged_in
-
-
-class MockFlaskG:
-    """Helper class for mocking wqflask.collect.g.user_session"""
-    def __init__(self, is_logged_in=False):
-        self.is_logged_in = is_logged_in
-
-    @property
-    def user_session(self):
-        if self.is_logged_in:
-            return MockSession(is_logged_in=True)
-        return MockSession()
-
-
-class TestCollect(unittest.TestCase):
-
-    def setUp(self):
-        self.app_context = app.app_context()
-        self.app_context.push()
-
-    def tearDown(self):
-        self.app_context.pop()
-
-    @mock.patch("wqflask.collect.g", MockFlaskG())
-    def test_process_traits_with_bytestring(self):
-        """
-        Test that the correct traits are returned when the user is logged
-        out and bytes are used.
-        """
-        self.assertEqual(process_traits(
-            b'1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
-            b'1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
-            b'1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
-            b'1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
-            set(['1429252_at:HC_M2_0606_P',
-                 '1451401_a_at:HC_M2_0606_P',
-                 '1452447_at:HC_M2_0606_P',
-                 '1452452_at:HC_M2_0606_P']))
-
-    @mock.patch("wqflask.collect.g", MockFlaskG())
-    def test_process_traits_with_normal_string(self):
-        """
-        Test that the correct traits are returned when the user is logged
-        out and a normal string is used.
-        """
-        self.assertEqual(process_traits(
-            '1452452_at:HC_M2_0606_P:163d04f7db7c9e110de6,'
-            '1452447_at:HC_M2_0606_P:eeece8fceb67072debea,'
-            '1451401_a_at:HC_M2_0606_P:a043d23b3b3906d8318e,'
-            '1429252_at:HC_M2_0606_P:6fa378b349bc9180e8f5'),
-            set(['1429252_at:HC_M2_0606_P',
-                 '1451401_a_at:HC_M2_0606_P',
-                 '1452447_at:HC_M2_0606_P',
-                 '1452452_at:HC_M2_0606_P']))
diff --git a/wqflask/tests/wqflask/test_pbkdf2.py b/wqflask/tests/wqflask/test_pbkdf2.py
deleted file mode 100644
index a33fbd4f..00000000
--- a/wqflask/tests/wqflask/test_pbkdf2.py
+++ /dev/null
@@ -1,61 +0,0 @@
-"""Test cases pbkdf2"""
-
-import unittest
-from wqflask.pbkdf2 import pbkdf2_hex
-
-
-class TestPbkdf2(unittest.TestCase):
-    def test_pbkdf2_hex(self):
-        """
-        Test pbkdf2_hex function
-        """
-
-        for password, salt, iterations, keylen, expected_value in [
-                ('password', 'salt', 1, 20,
-                 '0c60c80f961f0e71f3a9b524af6012062fe037a6'),
-                ('password', 'salt', 2, 20,
-                 'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'),
-                ('password', 'salt', 4096, 20,
-                 '4b007901b765489abead49d926f721d065a429c1'),
-                ('passwordPASSWORDpassword',
-                 'saltSALTsaltSALTsaltSALTsaltSALTsalt',
-                 4096, 25,
-                 '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'),
-                ('pass\x00word', 'sa\x00lt', 4096, 16,
-                 '56fa6aa75548099dcc37d7f03425e0c3'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1, 16,
-                 'cdedb5281bb2f801565a1122b2563515'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1, 32,
-                 ('cdedb5281bb2f80'
-                  '1565a1122b256351'
-                  '50ad1f7a04bb9f3a33'
-                  '3ecc0e2e1f70837')),
-                ('password', 'ATHENA.MIT.EDUraeburn', 2, 16,
-                 '01dbee7f4a9e243e988b62c73cda935d'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 2, 32,
-                 ('01dbee7f4a9e243e9'
-                  '88b62c73cda935da05'
-                  '378b93244ec8f48a99'
-                  'e61ad799d86')),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1200, 32,
-                 ('5c08eb61fdf71e'
-                  '4e4ec3cf6ba1f55'
-                  '12ba7e52ddbc5e51'
-                  '42f708a31e2e62b1e13')),
-                ('X' * 64, 'pass phrase equals block size', 1200, 32,
-                 ('139c30c0966bc32ba'
-                  '55fdbf212530ac9c5'
-                  'ec59f1a452f5cc9ad'
-                  '940fea0598ed1')),
-                ('X' * 65, 'pass phrase exceeds block size', 1200, 32,
-                 ('9ccad6d468770cd'
-                  '51b10e6a68721be6'
-                  '11a8b4d282601db3'
-                  'b36be9246915ec82a'))
-        ]:
-            self.assertEqual(
-                pbkdf2_hex(data=password,
-                           salt=salt,
-                           iterations=iterations,
-                           keylen=keylen),
-                expected_value)
diff --git a/wqflask/tests/wqflask/test_user_login.py b/wqflask/tests/wqflask/test_user_login.py
deleted file mode 100644
index 61cd9ab9..00000000
--- a/wqflask/tests/wqflask/test_user_login.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"""Test cases for some methods in login.py"""
-
-import unittest
-from wqflask.user_login import encode_password
-
-
-class TestUserLogin(unittest.TestCase):
-    def test_encode_password(self):
-        """
-        Test encode password
-        """
-        pass_gen_fields = {
-            "salt": "salt",
-            "hashfunc": "sha1",
-            "iterations": 4096,
-            "keylength": 20,
-        }
-        self.assertEqual(
-            encode_password(pass_gen_fields,
-                            "password").get("password"),
-            '4b007901b765489abead49d926f721d065a429c1')
diff --git a/wqflask/tests/wqflask/test_user_session.py b/wqflask/tests/wqflask/test_user_session.py
deleted file mode 100644
index ebb0334a..00000000
--- a/wqflask/tests/wqflask/test_user_session.py
+++ /dev/null
@@ -1,15 +0,0 @@
-"""Test cases for some methods in user_session.py"""
-
-import unittest
-from wqflask.user_session import verify_cookie
-
-
-class TestUserSession(unittest.TestCase):
-    def test_verify_cookie(self):
-        """
-        Test cookie verification
-        """
-        self.assertEqual(
-            "3f4c1dbf-5b56-4260-87d6-f35445bda37e",
-            verify_cookie(("3f4c1dbf-5b56-4260-87d6-"
-                           "f35445bda37e:af4fcf5eace9e7c864ce")))
diff --git a/wqflask/wqflask/templates/glossary.html b/wqflask/wqflask/templates/glossary.html
index 988297d3..80e74ceb 100644
--- a/wqflask/wqflask/templates/glossary.html
+++ b/wqflask/wqflask/templates/glossary.html
@@ -3,5 +3,5 @@
 {% block title %}Glossary{% endblock %}
 
 {% block content %}
-Test
+<p id="mytest"> Test</p>
 {% endblock %}
-- 
cgit v1.2.3


From 390dcc3c46495a8e316df36ceb57dae2089456da Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 19:14:24 +0300
Subject: Remove encoding header for file

In python3 the default encoding is utf-8 so this is redundant.
---
 wqflask/tests/unit/utility/test_hmac.py | 1 -
 wqflask/wqflask/views.py                | 4 +---
 2 files changed, 1 insertion(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_hmac.py b/wqflask/tests/unit/utility/test_hmac.py
index 4e3652f8..13d6261d 100644
--- a/wqflask/tests/unit/utility/test_hmac.py
+++ b/wqflask/tests/unit/utility/test_hmac.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """Test hmac utility functions"""
 
 import unittest
diff --git a/wqflask/wqflask/views.py b/wqflask/wqflask/views.py
index 08673f79..b7c4d142 100644
--- a/wqflask/wqflask/views.py
+++ b/wqflask/wqflask/views.py
@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-#
-# Main routing table for GN2
+"""Main routing table for GN2"""
 
 import traceback # for error page
 import os        # for error gifs
-- 
cgit v1.2.3


From 4b6d964ccf484225f568361b3bc6136a758cd475 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 20:15:39 +0300
Subject: add tests for the get_categorical_variables function

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index ec45d558..f7133292 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -155,7 +155,22 @@ class TestTraits(unittest.TestCase):
         self.assertEqual(get_categorical_variables(trait, sample_list), [])
 
     def test_get_categorical_variables_with_sample_attributes(self):
-        pass
+        this_trait=TraitObject({"data":{
+            "Gene1":TraitObject({"extra_attributes":{"ex1":"ex1value"}}),
+            "Gene2":TraitObject({"extra_attributes":{"ex2":"ex2value"}}),
+            "Gene3":TraitObject({"extra_attributes":{"ex3":"ex3value"}})
+            }})
+        sample_list=TraitObject({"attributes":{
+             "sample_attribute_1":TraitObject({"name":"ex1"}),
+             "sample_attribute_2":TraitObject({"name":"ex2"}),
+             "sample_attribute_3":TraitObject({"name":"ex3"}),
+             "sample_attribute_4":TraitObject({"name":"not_in_extra_attributes"}),
+
+
+            }})
+
+        results=get_categorical_variables(this_trait,sample_list)
+        self.assertEqual(["ex1","ex2","ex3","not_in_extra_attributes"],results)
 
     def test_get_trait_units(self):
         """test for getting trait units"""
-- 
cgit v1.2.3


From 68f71e11343789266ccac6e079dd0bc1b16d407f Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 20:23:19 +0300
Subject: add pep8 formatting

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index f7133292..f41b7288 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -155,6 +155,7 @@ class TestTraits(unittest.TestCase):
         self.assertEqual(get_categorical_variables(trait, sample_list), [])
 
     def test_get_categorical_variables_with_sample_attributes(self):
+        """test for getting categorical variable names with no samples"""
         this_trait=TraitObject({"data":{
             "Gene1":TraitObject({"extra_attributes":{"ex1":"ex1value"}}),
             "Gene2":TraitObject({"extra_attributes":{"ex2":"ex2value"}}),
@@ -169,6 +170,8 @@ class TestTraits(unittest.TestCase):
 
             }})
 
+        #
+
         results=get_categorical_variables(this_trait,sample_list)
         self.assertEqual(["ex1","ex2","ex3","not_in_extra_attributes"],results)
 
-- 
cgit v1.2.3


From 8630b727d80f52b3e846c9eb3bf7dd4e844fa626 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 3 Nov 2020 20:34:00 +0300
Subject: remove unnecessary comments

---
 .../tests/wqflask/show_trait/test_show_trait.py    | 35 +++++++++++-----------
 1 file changed, 17 insertions(+), 18 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index f41b7288..c617e9f2 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -156,24 +156,23 @@ class TestTraits(unittest.TestCase):
 
     def test_get_categorical_variables_with_sample_attributes(self):
         """test for getting categorical variable names with no samples"""
-        this_trait=TraitObject({"data":{
-            "Gene1":TraitObject({"extra_attributes":{"ex1":"ex1value"}}),
-            "Gene2":TraitObject({"extra_attributes":{"ex2":"ex2value"}}),
-            "Gene3":TraitObject({"extra_attributes":{"ex3":"ex3value"}})
-            }})
-        sample_list=TraitObject({"attributes":{
-             "sample_attribute_1":TraitObject({"name":"ex1"}),
-             "sample_attribute_2":TraitObject({"name":"ex2"}),
-             "sample_attribute_3":TraitObject({"name":"ex3"}),
-             "sample_attribute_4":TraitObject({"name":"not_in_extra_attributes"}),
-
-
-            }})
-
-        #
-
-        results=get_categorical_variables(this_trait,sample_list)
-        self.assertEqual(["ex1","ex2","ex3","not_in_extra_attributes"],results)
+        this_trait = TraitObject({"data": {
+            "Gene1": TraitObject({"extra_attributes": {"ex1": "ex1value"}}),
+            "Gene2": TraitObject({"extra_attributes": {"ex2": "ex2value"}}),
+            "Gene3": TraitObject({"extra_attributes": {"ex3": "ex3value"}})
+        }})
+        sample_list = TraitObject({"attributes": {
+            "sample_attribute_1": TraitObject({"name": "ex1"}),
+            "sample_attribute_2": TraitObject({"name": "ex2"}),
+            "sample_attribute_3": TraitObject({"name": "ex3"}),
+            "sample_attribute_4": TraitObject({"name": "not_in_extra_attributes"}),
+
+
+        }})
+
+        results = get_categorical_variables(this_trait, sample_list)
+        self.assertEqual(
+            ["ex1", "ex2", "ex3", "not_in_extra_attributes"], results)
 
     def test_get_trait_units(self):
         """test for getting trait units"""
-- 
cgit v1.2.3


From 74550ef0c76a941c473c8d024ccc0a0403631c49 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 22:03:26 +0300
Subject: Add basic structure for "/glossary" routes test

---
 wqflask/tests/integration/test_markdown_routes.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 wqflask/tests/integration/test_markdown_routes.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/integration/test_markdown_routes.py b/wqflask/tests/integration/test_markdown_routes.py
new file mode 100644
index 00000000..5e3e5045
--- /dev/null
+++ b/wqflask/tests/integration/test_markdown_routes.py
@@ -0,0 +1,21 @@
+"Integration tests for markdown routes"
+import unittest
+
+from bs4 import BeautifulSoup
+
+from wqflask import app
+
+
+class TestGenMenu(unittest.TestCase):
+    """Tests for glossary"""
+
+    def setUp(self):
+        self.app = app.test_client()
+
+    def tearDown(self):
+        pass
+
+    def test_glossary_page(self):
+        """Test that the glossary page is rendered properly"""
+        response = self.app.get('/glossary', follow_redirects=True)
+        pass
-- 
cgit v1.2.3


From bb46ab063cc86525946563c809a896532d87147a Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 22:45:44 +0300
Subject: Add basic tests for rendering_markdown

* wqflask/tests/unit/wqflask/test_markdown_routes.py: New tests.
---
 wqflask/tests/unit/wqflask/test_markdown_routes.py | 43 ++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/test_markdown_routes.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
new file mode 100644
index 00000000..8b6f7490
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -0,0 +1,43 @@
+"""Test functions in markdown utils"""
+
+import unittest
+from unittest import mock
+
+from wqflask.markdown_routes import render_markdown
+
+
+class MockRequests404:
+    @property
+    def status_code():
+        return 404
+
+class MockRequests200:
+    @property
+    def status_code():
+        return 200
+
+    @property
+    def content():
+        return """
+        # Glossary
+
+        This is some content
+
+        ## Sub-heading
+        This is another sub-heading
+        """
+
+class TestMarkdownRoutesFunctions(unittest.TestCase):
+    """Test cases for functions in markdown_routes"""
+
+    @mock.patch('wqflask.markdown_routes.requests.get')
+    def test_render_markdown(self, requests_mock):
+        requests_mock.return_value = MockRequests404
+        markdown_content = render_markdown("glossary.md")
+        requests_mock.assert_called_with(
+            "https://raw.githubusercontent.com"
+            "/genenetwork/genenetwork2/"
+            "wqflask/wqflask/static/"
+            "glossary.md")
+        self.assertEqual("<h1>Content</h1>\n",
+                         markdown_content)
-- 
cgit v1.2.3


From 3ca276a1e9d3aa29f037696b640c64b2d8629c7f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 22:50:52 +0300
Subject: Delete file

* wqflask/tests/integration/test_glossary.py: Delete it. Earlier
renamed to test_markdown_routes.
---
 wqflask/tests/integration/test_glossary.py | 28 ----------------------------
 1 file changed, 28 deletions(-)
 delete mode 100644 wqflask/tests/integration/test_glossary.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/integration/test_glossary.py b/wqflask/tests/integration/test_glossary.py
deleted file mode 100644
index c9f1e62a..00000000
--- a/wqflask/tests/integration/test_glossary.py
+++ /dev/null
@@ -1,28 +0,0 @@
-"Integration tests for glossary"
-import unittest
-
-from bs4 import BeautifulSoup
-
-from wqflask import app
-
-
-class TestGenMenu(unittest.TestCase):
-    """Tests for glossary"""
-
-    def setUp(self):
-        self.app = app.test_client()
-
-    def tearDown(self):
-        pass
-
-    def test_glossary_page(self):
-        """Test that the glossary page is rendered properly"""
-        response = self.app.get('/glossary', follow_redirects=True)
-        html_content = BeautifulSoup(response.data, "lxml")
-        self.assertEqual(html_content.find("title").get_text(),
-                         "Glossary GeneNetwork 2")
-        self.assertEqual(
-            html_content.find(
-                'p',
-                attrs={'id': 'mytest'}).get_text(),
-            "Test")
-- 
cgit v1.2.3


From 5f6756f05baeeb6be34a079726d0df749a0557ec Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 3 Nov 2020 23:04:53 +0300
Subject: Fix false-positive tests

* wqflask/tests/unit/wqflask/test_markdown_routes.py:
(MockRequests404): Pass self in all properties.
(MockRequests200): Ditto.
(test_render_markdown): Rename to
test_render_markdown_when_fetching_locally.
(test_render_markdown_when_fetching_remotely): New test.
---
 wqflask/tests/unit/wqflask/test_markdown_routes.py | 37 +++++++++++++++-------
 1 file changed, 26 insertions(+), 11 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
index 8b6f7490..3de14276 100644
--- a/wqflask/tests/unit/wqflask/test_markdown_routes.py
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -8,31 +8,30 @@ from wqflask.markdown_routes import render_markdown
 
 class MockRequests404:
     @property
-    def status_code():
+    def status_code(self):
         return 404
 
 class MockRequests200:
     @property
-    def status_code():
+    def status_code(self):
         return 200
 
     @property
-    def content():
-        return """
-        # Glossary
+    def content(self):
+        return b"""
+# Glossary
+This is some content
 
-        This is some content
-
-        ## Sub-heading
-        This is another sub-heading
+## Sub-heading
+This is another sub-heading
         """
 
 class TestMarkdownRoutesFunctions(unittest.TestCase):
     """Test cases for functions in markdown_routes"""
 
     @mock.patch('wqflask.markdown_routes.requests.get')
-    def test_render_markdown(self, requests_mock):
-        requests_mock.return_value = MockRequests404
+    def test_render_markdown_when_fetching_locally(self, requests_mock):
+        requests_mock.return_value = MockRequests404()
         markdown_content = render_markdown("glossary.md")
         requests_mock.assert_called_with(
             "https://raw.githubusercontent.com"
@@ -41,3 +40,19 @@ class TestMarkdownRoutesFunctions(unittest.TestCase):
             "glossary.md")
         self.assertEqual("<h1>Content</h1>\n",
                          markdown_content)
+
+    @mock.patch('wqflask.markdown_routes.requests.get')
+    def test_render_markdown_when_fetching_remotely(self, requests_mock):
+        requests_mock.return_value = MockRequests200()
+        markdown_content = render_markdown("glossary.md")
+        requests_mock.assert_called_with(
+            "https://raw.githubusercontent.com"
+            "/genenetwork/genenetwork2/"
+            "wqflask/wqflask/static/"
+            "glossary.md")
+        self.assertEqual("""<h1>Glossary</h1>
+<p>This is some content</p>
+<h2>Sub-heading</h2>
+<p>This is another sub-heading</p>
+""",
+                         markdown_content)
-- 
cgit v1.2.3


From 23915d8102b8a05930cf3fd16d651a460ebd2f58 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 4 Nov 2020 09:49:13 +0300
Subject: remove whitespace and assertIs

---
 .../tests/wqflask/show_trait/test_show_trait.py    | 30 ++++++++++++----------
 1 file changed, 17 insertions(+), 13 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index c617e9f2..04c68045 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -2,11 +2,15 @@
 import unittest
 from unittest import mock
 from wqflask import app
-from wqflask.show_trait.show_trait import (check_if_attr_exists, get_ncbi_summary,
-                                           has_num_cases, get_table_widths,
-                                           get_categorical_variables,
-                                           get_trait_units, get_nearest_marker, get_genotype_scales, requests)
-
+from wqflask.show_trait.show_trait import check_if_attr_exists
+from wqflask.show_trait.show_trait import  get_ncbi_summary
+from wqflask.show_trait.show_trait import has_num_cases
+from wqflask.show_trait.show_trait import get_table_widths
+from wqflask.show_trait.show_trait import get_categorical_variables
+from wqflask.show_trait.show_trait import get_trait_units
+from wqflask.show_trait.show_trait import get_nearest_marker
+from wqflask.show_trait.show_trait import get_genotype_scales
+from wqflask.show_trait.show_trait import requests
 
 class TraitObject:
     def __init__(self, obj):
@@ -29,8 +33,8 @@ class TestTraits(unittest.TestCase):
         results = check_if_attr_exists(trait_obj, "id_type")
         result2 = check_if_attr_exists(trait_obj2, "sample_name")
         self.assertIsInstance(trait_obj, TraitObject)
-        self.assertIs(results, True)
-        self.assertIs(result2, True)
+        self.assertTrue(results)
+        self.assertTrue(result2)
 
     def test_check_if_attr_exists_empty_attr(self):
         """test if attributes exists with false return"""
@@ -38,14 +42,14 @@ class TestTraits(unittest.TestCase):
         trait_obj2 = TraitObject({"group": None})
         result = check_if_attr_exists(trait_obj, "sample")
         result2 = check_if_attr_exists(trait_obj, "group")
-        self.assertIs(result, False)
-        self.assertIs(result2, False)
+        self.assertFalse(result)
+        self.assertFalse(result2)
 
     def test_check_if_attr_exists_falsey(self):
         """check if attribute exists with empty attributes"""
         trait_obj = TraitObject({})
         results = check_if_attr_exists(trait_obj, "any")
-        self.assertIs(results, False)
+        self.assertFalse(results)
 
     @mock.patch("wqflask.show_trait.show_trait.requests.get")
     @mock.patch("wqflask.show_trait.show_trait.check_if_attr_exists")
@@ -97,7 +101,7 @@ class TestTraits(unittest.TestCase):
         create_dataset = TraitObject({"type": "ProbeSet"})
         create_trait = TraitObject({"dataset": create_dataset})
 
-        self.assertIs(has_num_cases(create_trait), False)
+        self.assertFalse(has_num_cases(create_trait))
 
     def test_hash_num_cases_no_probeset(self):
         """test for hash num cases with dataset.type not Probeset"""
@@ -123,8 +127,8 @@ class TestTraits(unittest.TestCase):
 
         results = has_num_cases(create_trait)
 
-        self.assertIs(has_num_cases(create_trait), True)
-        self.assertIs(has_num_cases(create_trait2), False)
+        self.assertTrue(has_num_cases(create_trait))
+        self.assertFalse(has_num_cases(create_trait2))
 
     def test_get_table_widths(self):
         """test for getting table widths"""
-- 
cgit v1.2.3


From 9d2134202c0435ad4a18e0ac74ce4a99508f1a76 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 4 Nov 2020 09:57:35 +0300
Subject: remove whitespace

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 04c68045..f82a4c04 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -3,7 +3,7 @@ import unittest
 from unittest import mock
 from wqflask import app
 from wqflask.show_trait.show_trait import check_if_attr_exists
-from wqflask.show_trait.show_trait import  get_ncbi_summary
+from wqflask.show_trait.show_trait import get_ncbi_summary
 from wqflask.show_trait.show_trait import has_num_cases
 from wqflask.show_trait.show_trait import get_table_widths
 from wqflask.show_trait.show_trait import get_categorical_variables
@@ -12,6 +12,7 @@ from wqflask.show_trait.show_trait import get_nearest_marker
 from wqflask.show_trait.show_trait import get_genotype_scales
 from wqflask.show_trait.show_trait import requests
 
+
 class TraitObject:
     def __init__(self, obj):
         for key, value in obj.items():
@@ -169,9 +170,7 @@ class TestTraits(unittest.TestCase):
             "sample_attribute_1": TraitObject({"name": "ex1"}),
             "sample_attribute_2": TraitObject({"name": "ex2"}),
             "sample_attribute_3": TraitObject({"name": "ex3"}),
-            "sample_attribute_4": TraitObject({"name": "not_in_extra_attributes"}),
-
-
+            "sample_attribute_4": TraitObject({"name": "not_in_extra_attributes"})
         }})
 
         results = get_categorical_variables(this_trait, sample_list)
-- 
cgit v1.2.3


From 1ef7c3cd7bc148bac8a6b47f62ba02c3819bf1f3 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 4 Nov 2020 10:08:32 +0300
Subject: remove whitespace in line 119-120

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index f82a4c04..70061e2d 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -117,8 +117,6 @@ class TestTraits(unittest.TestCase):
             "nm1": TraitObject({"num_cases": False}),
             "nm2": TraitObject({"num_cases": False}),
             "nm3": TraitObject({"num_cases": False})
-
-
         }
 
         create_trait = TraitObject(
-- 
cgit v1.2.3


From f90e77fab78c4504ac9dabb188459ab5d03ac287 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 4 Nov 2020 10:15:05 +0300
Subject: remove extra whitespace

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 21 ---------------------
 1 file changed, 21 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 70061e2d..ce850c8b 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -67,11 +67,8 @@ class TestTraits(unittest.TestCase):
           }
         }
         """
-
         get_return_obj = TraitObject({"content": content_json_string})
-
         mock_get.return_value = get_return_obj
-
         results = get_ncbi_summary(trait)
         mock_exists.assert_called_once()
         mock_get.assert_called_once_with(f"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=gene&id={trait.geneid}&retmode=json")
@@ -93,7 +90,6 @@ class TestTraits(unittest.TestCase):
           }
         }
         """
-
         results = get_ncbi_summary(trait)
         self.assertEqual(results, None)
 
@@ -101,13 +97,11 @@ class TestTraits(unittest.TestCase):
         """test for hash num_cases with dataset.type set to Probeset"""
         create_dataset = TraitObject({"type": "ProbeSet"})
         create_trait = TraitObject({"dataset": create_dataset})
-
         self.assertFalse(has_num_cases(create_trait))
 
     def test_hash_num_cases_no_probeset(self):
         """test for hash num cases with dataset.type not Probeset"""
         create_dataset = TraitObject({"type": "Temp"})
-
         construct_data = {
             "nm1": TraitObject({"num_cases": False}),
             "nm2": TraitObject({"num_cases": True}),
@@ -125,7 +119,6 @@ class TestTraits(unittest.TestCase):
             {"dataset": create_dataset, "data": construct_data2})
 
         results = has_num_cases(create_trait)
-
         self.assertTrue(has_num_cases(create_trait))
         self.assertFalse(has_num_cases(create_trait2))
 
@@ -144,7 +137,6 @@ class TestTraits(unittest.TestCase):
         expected_with_numcase = (450, "750px")
         expected_no_numcase = (450, "670px")
         expected_one_sample = (250, "540px")
-
         self.assertEqual(results_with_numcase, expected_with_numcase)
         self.assertEqual(result_no_numcase, expected_no_numcase)
         self.assertEqual(results_one_sample,
@@ -154,7 +146,6 @@ class TestTraits(unittest.TestCase):
         """test for getting categorical variable names with no samples"""
         trait = TraitObject({})
         sample_list = TraitObject({"se_exists": True, "attributes": []})
-
         self.assertEqual(get_categorical_variables(trait, sample_list), [])
 
     def test_get_categorical_variables_with_sample_attributes(self):
@@ -179,9 +170,7 @@ class TestTraits(unittest.TestCase):
         """test for getting trait units"""
         trait = TraitObject(
             {"description_fmt": "[this is a description] another test [N/A]"})
-
         trait_no_unit_type = TraitObject({"description_fmt": ""})
-
         results = get_trait_units(trait)
         results_no_unit = get_trait_units(trait_no_unit_type)
         self.assertEqual(results, "this is a descriptionN/A")
@@ -195,13 +184,9 @@ class TestTraits(unittest.TestCase):
             ["Geno1", "Geno2"], ["Geno3"]]
 
         trait = TraitObject({"locus_chr": "test_chr", "locus_mb": "test_mb"})
-
         group_name = TraitObject({"name": "group_name"})
-
         this_db = TraitObject({"group": group_name})
-
         results_with_item_db = get_nearest_marker(trait, this_db)
-
         called_with_value = """SELECT Geno.Name
                FROM Geno, GenoXRef, GenoFreeze
                WHERE Geno.Chr = 'test_chr' AND
@@ -218,11 +203,9 @@ class TestTraits(unittest.TestCase):
     def test_get_nearest_marker_empty_db(self, mock_db):
         """test for getting nearest marker with empty db"""
         mock_db.db.execute.return_value.fetchall.return_value = []
-
         trait = TraitObject({"locus_chr": "test_chr", "locus_mb": "test_mb"})
         group_name = TraitObject({"name": "group_name"})
         this_db = TraitObject({"group": group_name})
-
         results_empty_db = get_nearest_marker(trait, this_db)
         mock_db.db.execute.assert_called_once()
         self.assertEqual(results_empty_db, "")
@@ -240,7 +223,6 @@ class TestTraits(unittest.TestCase):
                                        [["physic", "Mb"]]]
 
         results = get_genotype_scales(genofiles_list)
-
         expected_results = {
             "~/data/files/f1": [["morgan", "cM"]],
             "~/data/files/f2": [["morgan", "cM"]],
@@ -249,7 +231,6 @@ class TestTraits(unittest.TestCase):
 
         multiple_calls = [mock.call('~/data/files/f1'), mock.call('~/data/files/f2'),
                           mock.call('~/data/files/f3')]
-
         mock_get_scales.assert_has_calls(multiple_calls)
         self.assertEqual(results, expected_results)
 
@@ -258,8 +239,6 @@ class TestTraits(unittest.TestCase):
         """test for getting genotype scales with genofile as a string"""
         file_location = "~/another_file_location"
         mock_get_scales.return_value = [["physic", "Mb"]]
-
         expected_results = {f"{file_location}": [["physic", "Mb"]]}
-
         self.assertEqual(get_genotype_scales(file_location), expected_results)
         mock_get_scales.assert_called_once_with(file_location)
-- 
cgit v1.2.3


From 3f08f54fe3d42eca0ccf98831e4e339defa17720 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 4 Nov 2020 10:25:50 +0300
Subject: correct a typo

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index ce850c8b..24150738 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -112,7 +112,6 @@ class TestTraits(unittest.TestCase):
             "nm2": TraitObject({"num_cases": False}),
             "nm3": TraitObject({"num_cases": False})
         }
-
         create_trait = TraitObject(
             {"dataset": create_dataset, "data": construct_data})
         create_trait2 = TraitObject(
@@ -161,7 +160,6 @@ class TestTraits(unittest.TestCase):
             "sample_attribute_3": TraitObject({"name": "ex3"}),
             "sample_attribute_4": TraitObject({"name": "not_in_extra_attributes"})
         }})
-
         results = get_categorical_variables(this_trait, sample_list)
         self.assertEqual(
             ["ex1", "ex2", "ex3", "not_in_extra_attributes"], results)
-- 
cgit v1.2.3


From fa852e4a293735215e10bff9198c812fb85912ce Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 4 Nov 2020 18:04:48 +0300
Subject: Update test_markdown_routes

* wqflask/tests/unit/wqflask/test_markdown_routes.py
(test_render_markdown_when_fetching_locally): Fix failing test.
---
 wqflask/tests/unit/wqflask/test_markdown_routes.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
index 3de14276..3adf63e5 100644
--- a/wqflask/tests/unit/wqflask/test_markdown_routes.py
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -38,8 +38,8 @@ class TestMarkdownRoutesFunctions(unittest.TestCase):
             "/genenetwork/genenetwork2/"
             "wqflask/wqflask/static/"
             "glossary.md")
-        self.assertEqual("<h1>Content</h1>\n",
-                         markdown_content)
+        self.assertRegexpMatches(markdown_content,
+                                 "Glossary of Terms and Features")
 
     @mock.patch('wqflask.markdown_routes.requests.get')
     def test_render_markdown_when_fetching_remotely(self, requests_mock):
-- 
cgit v1.2.3


From 6b4bcc526c27a17f96704b54fbfa6a506b3a22f9 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 5 Nov 2020 22:30:33 +0300
Subject: add test for samplelist and show_trait

---
 wqflask/tests/wqflask/show_trait/testSampleList.py | 18 +++++++
 .../tests/wqflask/show_trait/test_show_trait.py    | 55 ++++++++++++++++++++++
 2 files changed, 73 insertions(+)
 create mode 100644 wqflask/tests/wqflask/show_trait/testSampleList.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
new file mode 100644
index 00000000..4cc8c4da
--- /dev/null
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -0,0 +1,18 @@
+import unittest
+import re
+from unittest import mock
+from wqflask.show_trait.SampleList import natural_sort
+
+
+class TestSampleList(unittest.TestCase):
+    def test_natural_sort(self):
+        "Sort the list into natural alphanumeric order."
+
+        characters_list = ["z", "f", "q", "s", "t", "a", "g"]
+        names_list = ["temp1", "publish", "Sample", "Dataset"]
+
+        natural_sort(characters_list)
+        natural_sort(names_list)
+
+        self.assertEqual(characters_list, ["a", "f", "g", "q", "s", "t", "z"])
+        self.assertEqual(names_list, ["Dataset", "Sample", "publish", "temp1"])
diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 24150738..b1a91bbe 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -11,6 +11,7 @@ from wqflask.show_trait.show_trait import get_trait_units
 from wqflask.show_trait.show_trait import get_nearest_marker
 from wqflask.show_trait.show_trait import get_genotype_scales
 from wqflask.show_trait.show_trait import requests
+from wqflask.show_trait.show_trait import get_scales_from_genofile
 
 
 class TraitObject:
@@ -240,3 +241,57 @@ class TestTraits(unittest.TestCase):
         expected_results = {f"{file_location}": [["physic", "Mb"]]}
         self.assertEqual(get_genotype_scales(file_location), expected_results)
         mock_get_scales.assert_called_once_with(file_location)
+
+    @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
+    def test_get_scales_from_genofile_found(self, mock_location_ignore):
+        # test no complete to be continued with
+        # a .geno file
+        mock_location_ignore.return_value = True
+        mock_file_with_one_line = mock.mock_open(
+            read_data="Some data from opened file")
+
+        mock_file = """#@scale and random data:is here_returned\n
+           This is second   with spaced with tabs\n  """
+        mock_file_result = mock.mock_open(read_data=mock_file)
+
+        with mock.patch("builtins.open", mock_file_with_one_line):
+            result = get_scales_from_genofile("~/data/file")
+            self.assertEqual(result, [['morgan', 'cM']])
+
+        with mock.patch("builtins.open", mock_file_result):
+            results = get_scales_from_genofile("~data/file_geno")
+            self.assertEqual(results, [['physic', 'Mb']])
+
+    @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
+    def test_get_scales_from_genofile_found(self, mock_ingore_location):
+        """"add test for get scales from genofile where file is found"""
+        mock_ingore_location.return_value = True
+        geno_file = """
+                #sample line    with no  @scales:other\n
+                #sample line     @scales and :separated   by semicolon\n
+                This attempts    to check whether\n
+                """
+
+        geno_file_string = "@line start with  @ and has @scale:morgan"
+
+        file_location = "~/data/file.geno"
+
+        mock_open_geno_file = mock.mock_open(read_data=geno_file)
+        with mock.patch("builtins.open", mock_open_geno_file):
+            results = get_scales_from_genofile(file_location)
+            self.assertEqual(results, [["morgan", "cM"]])
+
+        mock_open_string = mock.mock_open(read_data=geno_file_string)
+
+        with mock.patch("builtins.open", mock_open_string):
+            result2 = get_scales_from_genofile(file_location)
+            self.assertEqual([['morgan', 'cM']], result2)
+
+    @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
+    def test_get_scales_from_genofile_not_found(self, mock_location_ignore):
+        mock_location_ignore.return_value = False
+
+        expected_results = [["physic", "Mb"]]
+        results = get_scales_from_genofile("~/data/file")
+        mock_location_ignore.assert_called_once_with("~/data/file", "genotype")
+        self.assertEqual(results, expected_results)
-- 
cgit v1.2.3


From 162e3e1acc1fea2548f7caa71fa3fc425c0a4ccd Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 5 Nov 2020 22:47:30 +0300
Subject: remove duplicates

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 19 -------------------
 1 file changed, 19 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index b1a91bbe..600baefb 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -242,25 +242,6 @@ class TestTraits(unittest.TestCase):
         self.assertEqual(get_genotype_scales(file_location), expected_results)
         mock_get_scales.assert_called_once_with(file_location)
 
-    @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
-    def test_get_scales_from_genofile_found(self, mock_location_ignore):
-        # test no complete to be continued with
-        # a .geno file
-        mock_location_ignore.return_value = True
-        mock_file_with_one_line = mock.mock_open(
-            read_data="Some data from opened file")
-
-        mock_file = """#@scale and random data:is here_returned\n
-           This is second   with spaced with tabs\n  """
-        mock_file_result = mock.mock_open(read_data=mock_file)
-
-        with mock.patch("builtins.open", mock_file_with_one_line):
-            result = get_scales_from_genofile("~/data/file")
-            self.assertEqual(result, [['morgan', 'cM']])
-
-        with mock.patch("builtins.open", mock_file_result):
-            results = get_scales_from_genofile("~data/file_geno")
-            self.assertEqual(results, [['physic', 'Mb']])
 
     @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
     def test_get_scales_from_genofile_found(self, mock_ingore_location):
-- 
cgit v1.2.3


From 7078bd8a2d9d3a2ab8f31e102deeece8bc0e5fcf Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Fri, 6 Nov 2020 00:45:50 +0300
Subject: fix typo

---
 wqflask/tests/wqflask/show_trait/test_show_trait.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 600baefb..8c866874 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -244,9 +244,9 @@ class TestTraits(unittest.TestCase):
 
 
     @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
-    def test_get_scales_from_genofile_found(self, mock_ingore_location):
+    def test_get_scales_from_genofile_found(self, mock_ignore_location):
         """"add test for get scales from genofile where file is found"""
-        mock_ingore_location.return_value = True
+        mock_ignore_location.return_value = True
         geno_file = """
                 #sample line    with no  @scales:other\n
                 #sample line     @scales and :separated   by semicolon\n
-- 
cgit v1.2.3


From 6b23bf4a0698339a1c7672b8d84dfef9b9066a79 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Fri, 6 Nov 2020 10:59:12 +0300
Subject: modify tests to for changes in the natural sort function

---
 wqflask/tests/wqflask/show_trait/testSampleList.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
index 4cc8c4da..34c51e3e 100644
--- a/wqflask/tests/wqflask/show_trait/testSampleList.py
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -10,9 +10,7 @@ class TestSampleList(unittest.TestCase):
 
         characters_list = ["z", "f", "q", "s", "t", "a", "g"]
         names_list = ["temp1", "publish", "Sample", "Dataset"]
-
-        natural_sort(characters_list)
-        natural_sort(names_list)
-
-        self.assertEqual(characters_list, ["a", "f", "g", "q", "s", "t", "z"])
-        self.assertEqual(names_list, ["Dataset", "Sample", "publish", "temp1"])
+        sorted_list_a=natural_sort(characters_list)
+        sorted_list_b=natural_sort(names_list)
+        self.assertEqual(sorted_list_a, ["a", "f", "g", "q", "s", "t", "z"])
+        self.assertEqual(sorted_list_b,["Dataset", "Sample", "publish", "temp1"])
-- 
cgit v1.2.3


From 8e55eaf473d98c1d165fcaf60ab0e24abb6acd9e Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sun, 8 Nov 2020 22:00:40 +0300
Subject: add tests for marker_regression/gemma_mapping

---
 .../marker_regression/test_gemma_mapping.py        | 170 +++++++++++++++++++++
 1 file changed, 170 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
new file mode 100644
index 00000000..4a88509e
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -0,0 +1,170 @@
+#test for wqflask/marker_regression/gemma_mapping.py
+import unittest
+import random
+from unittest import mock
+from wqflask.marker_regression.gemma_mapping import run_gemma
+from wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file
+from wqflask.marker_regression.gemma_mapping import gen_covariates_file
+from wqflask.marker_regression.gemma_mapping import parse_gemma_output
+from wqflask.marker_regression.gemma_mapping import parse_loco_output
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for key, val in obj.items():
+            setattr(self, key, val)
+
+
+class MockDatasetGroup(AttributeSetter):
+    def get_samplelist(self):
+        return None
+
+
+class TestGemmaMapping(unittest.TestCase):
+    # def test_fail(self):
+    #     self.assertEqual(2,3)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
+    def setUp(self):
+    	pass
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno, mock_os):
+        chromosomes = AttributeSetter({"chromosomes": "SA"})
+        covariates = "XI:X2,X4:X3,X6:X7"
+        dataset_group = MockDatasetGroup({"genofile": "fileX"})
+        dataset = AttributeSetter(
+            {"group": dataset_group, "name": "dataset1_name", "species": chromosomes})
+        trait = AttributeSetter({"name": "trait1"})
+        mock_gen_pheno.side_effect = None
+        mock_gen_pheno.return_value = None
+        mock_os.path.isfile.return_value = True
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
+        dataset = AttributeSetter(
+            {"group": AttributeSetter({"genofile": "genofile.geno"})})
+
+        output_files = "file1"
+        use_loco = False
+        mock_parse_loco.side_effect = None
+        mock_parse_loco.return_value = []
+        this_trait = AttributeSetter({"name": "t1"})
+
+        result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
+        ], covariates="", use_loco=True, first_run=False, output_files=output_files)
+
+        expected_results = ([], "file1")
+        self.assertEqual(expected_results, result)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
+    def test_gen_pheno_txt_file(self):
+        with mock.patch("builtins.open", mock.mock_open())as mock_open:
+            gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
+                               "x", "w", "q", "we", "R"], trait_filename="fitr.re")
+
+            mock_open.assert_called_once_with(
+                '/home/user/data/gn2/fitr.re.txt', 'w')
+            filehandler = mock_open()
+            values = ["x", "w", "q", "we", "R"]
+            write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call(
+                'q\n'), mock.call('we\n'), mock.call('R\n')]
+
+            filehandler.write.assert_has_calls(write_calls)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset")
+    def test_gen_covariates_file(self, create_dataset, create_trait, flat_files):
+        covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2"
+        samplelist = ["X1", "X2", "X3", "X4"]
+        create_dataset_side_effect = []
+        create_trait_side_effect = []
+
+        for i in range(4):
+            create_dataset_side_effect.append(AttributeSetter({"name": f'name_{i}'}))
+            create_trait_side_effect.append(
+                AttributeSetter({"data": [f'data_{i}']}))
+
+        create_dataset.side_effect = create_trait_side_effect
+        create_trait.side_effect = create_trait_side_effect
+
+        group = MockDatasetGroup({"name": "group_X", "samplelist": samplelist})
+        this_dataset = AttributeSetter({"group": group})
+        flat_files.return_value = "Home/Genenetwork"
+
+        with mock.patch("builtins.open", mock.mock_open())as mock_open:
+            gen_covariates_file(this_dataset=this_dataset, covariates=covariates,
+                                samples=["x1", "x2", "X3"])
+            # test mocked methods
+
+            create_dataset.assert_has_calls(
+                [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')])
+            mock_calls = []
+            trait_names = ["X1", "Y1", "M1", "V1"]
+
+            for i, trait in enumerate(create_trait_side_effect):
+                mock_calls.append(
+                    mock.call(dataset=trait, name=trait_names[i], cellid=None))
+
+            create_trait.assert_has_calls(mock_calls)
+
+            # test writing of covariates.txt
+
+            flat_files.assert_called_once_with('mapping')
+            mock_open.assert_called_once_with(
+                'Home/Genenetwork/group_X_covariates.txt', 'w')
+            filehandler = mock_open()
+            # expected all-9
+            filehandler.write.assert_has_calls([mock.call(
+                '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
+    def test_parse_gemma_output_obj_returned(self):
+        file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+chr\tgn1\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7
+X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
+125\tgn9\t433575\tQ\tE\tA\tP\tMMB\tCDE\t0.67
+"""
+        with mock.patch("builtins.open", mock.mock_open(read_data=file)) as mock_open:
+            results = parse_gemma_output(genofile_name="gema_file")
+            expected =  [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
+
+            mock_open.assert_called_once_with(
+                "/home/user/img/gema_file_output.assoc.txt")
+
+            self.assertEqual(results, expected)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
+    def test_xparse_gemma_output_empty_return(self):
+        output_file_results = """chr\t today"""
+        with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
+            results = parse_gemma_output(genofile_name="gema_file")
+            self.assertEqual(results, [])
+
+    @mock.patch("builtins.open", mock.mock_open(read_data="chr\t"))
+    def test_parse_gemma_output_empty_return(self):
+    	#duplicate
+        string_read = parse_gemma_output(genofile_name="hdf")
+        # print(string_read)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    def test_parse_loco_output_file_found(self, mock_os):
+        mock_os.path.isfile.return_value = False
+        file_to_write = """{"files":["file_1","file_2"]}"""
+
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    def test_parse_loco_output_file_not_found(self, mock_os):
+
+        mock_os.path.isfile.return_value = False
+        file_to_write = """{"files":["file_1","file_2"]}"""
+
+        with mock.patch("builtins.open", mock.mock_open(read_data=file_to_write)) as mock_open:
+            results = parse_loco_output(
+                this_dataset={}, gwa_output_filename=".xw/")
+            self.assertEqual(results, [])
-- 
cgit v1.2.3


From 5e50e19a014efdfcf0ce1397025879d4ada4d271 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sun, 8 Nov 2020 22:04:52 +0300
Subject: add tests for marker_regression/plink_mapping.py

---
 .../marker_regression/test_plink_mapping.py        | 83 ++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_plink_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
new file mode 100644
index 00000000..b827fd0f
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
@@ -0,0 +1,83 @@
+# test for wqflask/marker_regression/plink_mapping.py
+import unittest
+from unittest import mock
+from wqflask.marker_regression.plink_mapping import build_line_list
+from wqflask.marker_regression.plink_mapping import get_samples_from_ped_file
+from wqflask.marker_regression.plink_mapping import flat_files
+from wqflask.marker_regression.plink_mapping import gen_pheno_txt_file_plink
+from wqflask.marker_regression.plink_mapping import parse_plink_output
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for key, val in obj.items():
+            setattr(self, key, val)
+
+
+class TestPlinkMapping(unittest.TestCase):
+
+    def test_build_line_list(self):
+        line_1 = "this is line one test"
+        irregular_line = "  this     is an, irregular line     "
+        exp_line1 = ["this", "is", "line", "one", "test"]
+
+        results = build_line_list(irregular_line)
+        self.assertEqual(exp_line1, build_line_list(line_1))
+        self.assertEqual([], build_line_list())
+        self.assertEqual(["this", "is", "an,", "irregular", "line"], results)
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.flat_files")
+    def test_get_samples_from_ped_file(self, mock_flat_files):
+        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
+        file_sample = """Expected_1\tline test
+Expected_2\there
+  Expected_3\tthree"""
+        mock_flat_files.return_value = "/home/user/"
+        with mock.patch("builtins.open", mock.mock_open(read_data=file_sample)) as mock_open:
+            results = get_samples_from_ped_file(dataset)
+            mock_flat_files.assert_called_once_with("mapping")
+            mock_open.assert_called_once_with("/home/user/n_1.ped", "r")
+            self.assertEqual(
+                ["Expected_1", "Expected_2", "Expected_3"], results)
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.plink_mapping.get_samples_from_ped_file")
+    def test_gen_pheno_txt_file_plink(self, mock_samples):
+        mock_samples.return_value = ["Expected_1", "Expected_2", "Expected_3"]
+
+        trait = AttributeSetter({"name": "TX"})
+        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
+        vals = ["value=K1", "value=K2", "value=K3"]
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+            results = gen_pheno_txt_file_plink(this_trait=trait, dataset=dataset,
+                                               vals=vals, pheno_filename="ph_file")
+            mock_open.assert_called_once_with(
+                "/home/user/data/ph_file.txt", "wb")
+            filehandler = mock_open()
+            calls_expected = [mock.call('FID\tIID\tTX\n'),
+                              mock.call('Expected_1\tExpected_1\tK1\nExpected_2\tExpected_2\tK2\nExpected_3\tExpected_3\tK3\n')]
+
+            filehandler.write.assert_has_calls(calls_expected)
+
+            filehandler.close.assert_called_once()
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.plink_mapping.build_line_list")
+    def test_parse_plink_output(self, mock_line_list):
+        chromosomes = [0, 34, 110, 89, 123, 23, 2]
+        species = AttributeSetter(
+            {"name": "S1", "chromosomes": AttributeSetter({"chromosomes": chromosomes})})
+
+        fake_file = """0 AACCAT T98.6  0.89\n2  AATA  B45  0.3\n121  ACG  B56.4 NA"""
+
+        mock_line_list.side_effect = [["0", "AACCAT", "T98.6", "0.89"], [
+            "2", "AATA", "B45", "0.3"], ["121", "ACG", "B56.4", "NA"]]
+        # print("sdfsfdf",species.chromosomes)
+        with mock.patch("builtins.open", mock.mock_open(read_data=fake_file)) as mock_open:
+            parse_results = parse_plink_output(
+                output_filename="P1_file", species=species)
+            mock_open.assert_called_once_with(
+                "/home/user/data/P1_file.qassoc", "rb")
+            expected = (2, {'AACCAT': 0.89, 'AATA': 0.3})
+
+            self.assertEqual(parse_results, expected)
-- 
cgit v1.2.3


From 919763173289e523d5b3c9015fc6f1117ad59581 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 13:31:42 +0300
Subject: add test for run_gemma function in marker_regression/gemma_mapping.py

---
 .../marker_regression/test_gemma_mapping.py        | 70 +++++++++++++++++-----
 1 file changed, 55 insertions(+), 15 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index 4a88509e..1b09afd6 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -1,4 +1,4 @@
-#test for wqflask/marker_regression/gemma_mapping.py
+# test for wqflask/marker_regression/gemma_mapping.py
 import unittest
 import random
 from unittest import mock
@@ -24,22 +24,62 @@ class TestGemmaMapping(unittest.TestCase):
     # def test_fail(self):
     #     self.assertEqual(2,3)
 
-    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
     def setUp(self):
-    	pass
+        pass
 
-    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.string.ascii_uppercase", "R")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.string.digits", "R")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno, mock_os):
-        chromosomes = AttributeSetter({"chromosomes": "SA"})
-        covariates = "XI:X2,X4:X3,X6:X7"
-        dataset_group = MockDatasetGroup({"genofile": "fileX"})
-        dataset = AttributeSetter(
-            {"group": dataset_group, "name": "dataset1_name", "species": chromosomes})
+    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files, mock_parse_loco):
+
+        chromosomes = []
+        for i in range(1, 5):
+            chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
+
+        chromo = AttributeSetter({"chromosomes": chromosomes})
+
+        dataset_group = MockDatasetGroup(
+            {"name": "GP1", "genofile": "file_geno"})
+
+        dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
+                                   "species": AttributeSetter({"chromosomes": chromo})})
+
         trait = AttributeSetter({"name": "trait1"})
-        mock_gen_pheno.side_effect = None
-        mock_gen_pheno.return_value = None
+        samples = []
+        mock_gen_pheno_txt.side_effect = None
+        mock_gen_pheno_txt.return_value = None
         mock_os.path.isfile.return_value = True
+        mock_os.system.return_value = None
+        mock_os.system.side_effect = None
+        mock_gen_covar.side_effect = None
+        mock_gen_covar.return_value = None
+        mock_flat_files.return_value = "/home/genotype/bimbam"
+        mock_parse_loco.side_effect = None
+        mock_parse_loco.return_value = []
+        results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
+        ], vals=[], covariates="", use_loco=True)
+        # check results
+        self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
+        mock_gen_pheno_txt.assert_called_once()
+        self.assertEqual(mock_flat_files.call_count, 4)
+
+        system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
+                        mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
+
+        mock_os.system.assert_has_calls(system_calls)
+
+        mock_os.path.isfile.assert_called_once_with(('/home/user/imgfile_output.assoc.txt')
+                                                    )
+
+        mock_parse_loco.assert_called_once_with(dataset,"GP1_GWA_RRRRRR")
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
     def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
@@ -130,7 +170,8 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
 """
         with mock.patch("builtins.open", mock.mock_open(read_data=file)) as mock_open:
             results = parse_gemma_output(genofile_name="gema_file")
-            expected =  [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
+            expected = [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812},
+                        {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
 
             mock_open.assert_called_once_with(
                 "/home/user/img/gema_file_output.assoc.txt")
@@ -146,7 +187,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
 
     @mock.patch("builtins.open", mock.mock_open(read_data="chr\t"))
     def test_parse_gemma_output_empty_return(self):
-    	#duplicate
+        # duplicate
         string_read = parse_gemma_output(genofile_name="hdf")
         # print(string_read)
 
@@ -156,7 +197,6 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
         mock_os.path.isfile.return_value = False
         file_to_write = """{"files":["file_1","file_2"]}"""
 
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_not_found(self, mock_os):
-- 
cgit v1.2.3


From 74c65eb99be3f9854bd774dae15877af7c8aa4f5 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 14:03:08 +0300
Subject: mock logger in marker_regression/gemma_mapping.py

---
 .../marker_regression/test_gemma_mapping.py        | 47 +++++++++++++---------
 1 file changed, 27 insertions(+), 20 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index 1b09afd6..fd45fd65 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -27,18 +27,39 @@ class TestGemmaMapping(unittest.TestCase):
     def setUp(self):
         pass
 
+
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
+        dataset = AttributeSetter(
+            {"group": AttributeSetter({"genofile": "genofile.geno"})})
+
+        output_files = "file1"
+        use_loco = False
+        mock_parse_loco.side_effect = None
+        mock_parse_loco.return_value = []
+        this_trait = AttributeSetter({"name": "t1"})
+
+        result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
+        ], covariates="", use_loco=True, first_run=False, output_files=output_files)
+
+        expected_results = ([], "file1")
+        self.assertEqual(expected_results, result)
+
+
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
     @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
     @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data/")
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.logger")
     @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
     @mock.patch("wqflask.marker_regression.gemma_mapping.string.ascii_uppercase", "R")
     @mock.patch("wqflask.marker_regression.gemma_mapping.string.digits", "R")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files, mock_parse_loco):
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files,mock_logger,mock_parse_loco):
 
         chromosomes = []
         for i in range(1, 5):
@@ -71,32 +92,18 @@ class TestGemmaMapping(unittest.TestCase):
         mock_gen_pheno_txt.assert_called_once()
         self.assertEqual(mock_flat_files.call_count, 4)
 
+
         system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
                         mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
 
         mock_os.system.assert_has_calls(system_calls)
 
-        mock_os.path.isfile.assert_called_once_with(('/home/user/imgfile_output.assoc.txt')
-                                                    )
-
-        mock_parse_loco.assert_called_once_with(dataset,"GP1_GWA_RRRRRR")
+        mock_os.path.isfile.assert_called_once_with(('/home/user/imgfile_output.assoc.txt'))
 
-    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
-    def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
-        dataset = AttributeSetter(
-            {"group": AttributeSetter({"genofile": "genofile.geno"})})
+        self.assertEqual(mock_logger.debug.call_count,2)
+                                                    
 
-        output_files = "file1"
-        use_loco = False
-        mock_parse_loco.side_effect = None
-        mock_parse_loco.return_value = []
-        this_trait = AttributeSetter({"name": "t1"})
-
-        result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
-        ], covariates="", use_loco=True, first_run=False, output_files=output_files)
-
-        expected_results = ([], "file1")
-        self.assertEqual(expected_results, result)
+        mock_parse_loco.assert_called_once_with(dataset,"GP1_GWA_RRRRRR")
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
     def test_gen_pheno_txt_file(self):
-- 
cgit v1.2.3


From 986b20363cc84be1822588dd7cc935fca7ef7f48 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 16:53:12 +0300
Subject: add test for get_genofile_samplelist in
 marker_regression/run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py  | 36 ++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_run_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
new file mode 100644
index 00000000..0a5bc565
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -0,0 +1,36 @@
+import unittest
+from unittest import mock
+from wqflask.marker_regression.run_mapping import get_genofile_samplelist
+
+
+class AttributeSetter:
+	def __init__(self,obj):
+		for k,v in obj.items():
+			setattr(self,k,v)
+
+
+class MockDataSetGroup(AttributeSetter):
+	
+	def get_genofiles(self):
+		return [{"location":"~/genofiles/g1_file","sample_list":["S1","S2","S3","S4"]}]
+class TestRunMapping(unittest.TestCase):
+	def setUp(self):
+		self.group=MockDataSetGroup({"genofile":"~/genofiles/g1_file"})
+		self.dataset=AttributeSetter({"group":self.group})
+
+	def tearDown(self):
+		self.dataset=AttributeSetter({"group":{"location":"~/genofiles/g1_file"}})
+
+
+	def test_get_genofile_samplelist(self):
+		#location true and sample list true
+
+		results_1=get_genofile_samplelist(self.dataset)
+		self.assertEqual(results_1,["S1","S2","S3","S4"])
+		#return empty array
+		self.group.genofile="~/genofiles/g2_file"
+		result_2=get_genofile_samplelist(self.dataset)
+		self.assertEqual(result_2,[])
+
+
+
-- 
cgit v1.2.3


From e660984015e1bc6d48e9ccee5fe59691c4acd911 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 17:22:27 +0300
Subject: add  tests for geno_db_exists in marker_regression/run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py    | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index 0a5bc565..61bc8a1d 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -1,7 +1,7 @@
 import unittest
 from unittest import mock
 from wqflask.marker_regression.run_mapping import get_genofile_samplelist
-
+from wqflask.marker_regression.run_mapping import geno_db_exists
 
 class AttributeSetter:
 	def __init__(self,obj):
@@ -15,7 +15,7 @@ class MockDataSetGroup(AttributeSetter):
 		return [{"location":"~/genofiles/g1_file","sample_list":["S1","S2","S3","S4"]}]
 class TestRunMapping(unittest.TestCase):
 	def setUp(self):
-		self.group=MockDataSetGroup({"genofile":"~/genofiles/g1_file"})
+		self.group=MockDataSetGroup({"genofile":"~/genofiles/g1_file","name":"GP1_"})
 		self.dataset=AttributeSetter({"group":self.group})
 
 	def tearDown(self):
@@ -32,5 +32,21 @@ class TestRunMapping(unittest.TestCase):
 		result_2=get_genofile_samplelist(self.dataset)
 		self.assertEqual(result_2,[])
 
+	@mock.patch("wqflask.marker_regression.run_mapping.data_set")
+	def test_geno_db_exists(self,mock_data_set):
+		# mock_data_set.create_dataset_side_effect=None
+		mock_data_set.create_dataset.side_effect=[AttributeSetter({}),Exception()]
+		results_no_error=geno_db_exists(self.dataset)
+		results_with_error=geno_db_exists(self.dataset)
+
+		self.assertEqual(mock_data_set.create_dataset.call_count,2)
+		self.assertEqual(results_with_error,"False")
+		self.assertEqual(results_no_error,"True")
+
+
+
+
+
+
 
 
-- 
cgit v1.2.3


From c9c06e3e2df6d9290a7b65607dd819f68290712e Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 20:10:21 +0300
Subject: remove unnecessary side_effect set to None

---
 .../marker_regression/test_gemma_mapping.py        | 43 +++++-----------------
 1 file changed, 9 insertions(+), 34 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index fd45fd65..963c131f 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -21,13 +21,6 @@ class MockDatasetGroup(AttributeSetter):
 
 
 class TestGemmaMapping(unittest.TestCase):
-    # def test_fail(self):
-    #     self.assertEqual(2,3)
-
-    def setUp(self):
-        pass
-
-
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
     def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
@@ -36,7 +29,6 @@ class TestGemmaMapping(unittest.TestCase):
 
         output_files = "file1"
         use_loco = False
-        mock_parse_loco.side_effect = None
         mock_parse_loco.return_value = []
         this_trait = AttributeSetter({"name": "t1"})
 
@@ -46,7 +38,6 @@ class TestGemmaMapping(unittest.TestCase):
         expected_results = ([], "file1")
         self.assertEqual(expected_results, result)
 
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
     @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
     @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
@@ -59,7 +50,7 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.gemma_mapping.string.digits", "R")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files,mock_logger,mock_parse_loco):
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
 
         chromosomes = []
         for i in range(1, 5):
@@ -75,35 +66,28 @@ class TestGemmaMapping(unittest.TestCase):
 
         trait = AttributeSetter({"name": "trait1"})
         samples = []
-        mock_gen_pheno_txt.side_effect = None
+
         mock_gen_pheno_txt.return_value = None
         mock_os.path.isfile.return_value = True
-        mock_os.system.return_value = None
-        mock_os.system.side_effect = None
-        mock_gen_covar.side_effect = None
         mock_gen_covar.return_value = None
         mock_flat_files.return_value = "/home/genotype/bimbam"
-        mock_parse_loco.side_effect = None
         mock_parse_loco.return_value = []
         results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
         ], vals=[], covariates="", use_loco=True)
-        # check results
         self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
         mock_gen_pheno_txt.assert_called_once()
         self.assertEqual(mock_flat_files.call_count, 4)
-
-
         system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
                         mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
 
         mock_os.system.assert_has_calls(system_calls)
 
-        mock_os.path.isfile.assert_called_once_with(('/home/user/imgfile_output.assoc.txt'))
+        mock_os.path.isfile.assert_called_once_with(
+            ('/home/user/imgfile_output.assoc.txt'))
 
-        self.assertEqual(mock_logger.debug.call_count,2)
-                                                    
+        self.assertEqual(mock_logger.debug.call_count, 2)
 
-        mock_parse_loco.assert_called_once_with(dataset,"GP1_GWA_RRRRRR")
+        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
     def test_gen_pheno_txt_file(self):
@@ -144,7 +128,6 @@ class TestGemmaMapping(unittest.TestCase):
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
             gen_covariates_file(this_dataset=this_dataset, covariates=covariates,
                                 samples=["x1", "x2", "X3"])
-            # test mocked methods
 
             create_dataset.assert_has_calls(
                 [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')])
@@ -157,13 +140,10 @@ class TestGemmaMapping(unittest.TestCase):
 
             create_trait.assert_has_calls(mock_calls)
 
-            # test writing of covariates.txt
-
             flat_files.assert_called_once_with('mapping')
             mock_open.assert_called_once_with(
                 'Home/Genenetwork/group_X_covariates.txt', 'w')
             filehandler = mock_open()
-            # expected all-9
             filehandler.write.assert_has_calls([mock.call(
                 '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
 
@@ -186,23 +166,18 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
             self.assertEqual(results, expected)
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
-    def test_xparse_gemma_output_empty_return(self):
+    def test_parse_gemma_output_empty_return(self):
         output_file_results = """chr\t today"""
         with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
             results = parse_gemma_output(genofile_name="gema_file")
             self.assertEqual(results, [])
 
-    @mock.patch("builtins.open", mock.mock_open(read_data="chr\t"))
-    def test_parse_gemma_output_empty_return(self):
-        # duplicate
-        string_read = parse_gemma_output(genofile_name="hdf")
-        # print(string_read)
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_found(self, mock_os):
-        mock_os.path.isfile.return_value = False
+        mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
+        #incomplete
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-- 
cgit v1.2.3


From bf22cc3fbb37147b5e6c3012658fe5e43b696637 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 20:26:21 +0300
Subject: remove whitespace in marker_regression

---
 wqflask/tests/wqflask/marker_regression/test_plink_mapping.py | 3 ---
 wqflask/tests/wqflask/marker_regression/test_run_mapping.py   | 9 +--------
 2 files changed, 1 insertion(+), 11 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
index b827fd0f..a5fa0c04 100644
--- a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
@@ -12,8 +12,6 @@ class AttributeSetter:
     def __init__(self, obj):
         for key, val in obj.items():
             setattr(self, key, val)
-
-
 class TestPlinkMapping(unittest.TestCase):
 
     def test_build_line_list(self):
@@ -72,7 +70,6 @@ Expected_2\there
 
         mock_line_list.side_effect = [["0", "AACCAT", "T98.6", "0.89"], [
             "2", "AATA", "B45", "0.3"], ["121", "ACG", "B56.4", "NA"]]
-        # print("sdfsfdf",species.chromosomes)
         with mock.patch("builtins.open", mock.mock_open(read_data=fake_file)) as mock_open:
             parse_results = parse_plink_output(
                 output_filename="P1_file", species=species)
diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index 61bc8a1d..bba9de05 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -2,6 +2,7 @@ import unittest
 from unittest import mock
 from wqflask.marker_regression.run_mapping import get_genofile_samplelist
 from wqflask.marker_regression.run_mapping import geno_db_exists
+from wqflask.marker_regression.run_mapping import write_input_for_browser
 
 class AttributeSetter:
 	def __init__(self,obj):
@@ -21,20 +22,16 @@ class TestRunMapping(unittest.TestCase):
 	def tearDown(self):
 		self.dataset=AttributeSetter({"group":{"location":"~/genofiles/g1_file"}})
 
-
 	def test_get_genofile_samplelist(self):
-		#location true and sample list true
 
 		results_1=get_genofile_samplelist(self.dataset)
 		self.assertEqual(results_1,["S1","S2","S3","S4"])
-		#return empty array
 		self.group.genofile="~/genofiles/g2_file"
 		result_2=get_genofile_samplelist(self.dataset)
 		self.assertEqual(result_2,[])
 
 	@mock.patch("wqflask.marker_regression.run_mapping.data_set")
 	def test_geno_db_exists(self,mock_data_set):
-		# mock_data_set.create_dataset_side_effect=None
 		mock_data_set.create_dataset.side_effect=[AttributeSetter({}),Exception()]
 		results_no_error=geno_db_exists(self.dataset)
 		results_with_error=geno_db_exists(self.dataset)
@@ -46,7 +43,3 @@ class TestRunMapping(unittest.TestCase):
 
 
 
-
-
-
-
-- 
cgit v1.2.3


From 3ccc964fc466467c1c65f000fa7b43a38e10987a Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 21:15:24 +0300
Subject: refactor test_run_gemma function

---
 wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index 963c131f..bc0cb4e0 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -46,11 +46,10 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.gemma_mapping.logger")
     @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.string.ascii_uppercase", "R")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.string.digits", "R")
+    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os,mock_choice,mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
 
         chromosomes = []
         for i in range(1, 5):
@@ -70,6 +69,7 @@ class TestGemmaMapping(unittest.TestCase):
         mock_gen_pheno_txt.return_value = None
         mock_os.path.isfile.return_value = True
         mock_gen_covar.return_value = None
+        mock_choice.return_value="R"
         mock_flat_files.return_value = "/home/genotype/bimbam"
         mock_parse_loco.return_value = []
         results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
@@ -177,7 +177,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
     def test_parse_loco_output_file_found(self, mock_os):
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
-        #incomplete
+        # incomplete
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-- 
cgit v1.2.3


From ba065fa885841dc39681d0e420ac06df1ea846ae Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 9 Nov 2020 21:27:54 +0300
Subject: correct typo and variable naming

---
 .../marker_regression/test_gemma_mapping.py        | 30 +++++-----------------
 1 file changed, 7 insertions(+), 23 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index bc0cb4e0..06ce55d8 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -49,52 +49,41 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os,mock_choice,mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
-
+    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
         chromosomes = []
         for i in range(1, 5):
             chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
-
         chromo = AttributeSetter({"chromosomes": chromosomes})
-
         dataset_group = MockDatasetGroup(
             {"name": "GP1", "genofile": "file_geno"})
-
         dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
                                    "species": AttributeSetter({"chromosomes": chromo})})
-
         trait = AttributeSetter({"name": "trait1"})
         samples = []
-
         mock_gen_pheno_txt.return_value = None
         mock_os.path.isfile.return_value = True
         mock_gen_covar.return_value = None
-        mock_choice.return_value="R"
+        mock_choice.return_value = "R"
         mock_flat_files.return_value = "/home/genotype/bimbam"
         mock_parse_loco.return_value = []
         results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
         ], vals=[], covariates="", use_loco=True)
-        self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
-        mock_gen_pheno_txt.assert_called_once()
-        self.assertEqual(mock_flat_files.call_count, 4)
         system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
                         mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
-
         mock_os.system.assert_has_calls(system_calls)
-
+        mock_gen_pheno_txt.assert_called_once()
+        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
         mock_os.path.isfile.assert_called_once_with(
             ('/home/user/imgfile_output.assoc.txt'))
-
         self.assertEqual(mock_logger.debug.call_count, 2)
-
-        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
+        self.assertEqual(mock_flat_files.call_count, 4)
+        self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
     def test_gen_pheno_txt_file(self):
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
             gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
                                "x", "w", "q", "we", "R"], trait_filename="fitr.re")
-
             mock_open.assert_called_once_with(
                 '/home/user/data/gn2/fitr.re.txt', 'w')
             filehandler = mock_open()
@@ -159,26 +148,21 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
             results = parse_gemma_output(genofile_name="gema_file")
             expected = [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812},
                         {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
-
             mock_open.assert_called_once_with(
                 "/home/user/img/gema_file_output.assoc.txt")
-
             self.assertEqual(results, expected)
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
     def test_parse_gemma_output_empty_return(self):
         output_file_results = """chr\t today"""
         with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
             results = parse_gemma_output(genofile_name="gema_file")
             self.assertEqual(results, [])
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_found(self, mock_os):
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
-        # incomplete
-
+        pass
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_not_found(self, mock_os):
-- 
cgit v1.2.3


From 137dff191dd8b78e8207e6c5adc4e1c421a75ff0 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 10 Nov 2020 13:57:24 +0300
Subject: add tests for export_mapping_results in
 marker_regression/run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py  | 192 ++++++++++++++++++---
 1 file changed, 167 insertions(+), 25 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index bba9de05..e925ad28 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -1,45 +1,187 @@
 import unittest
+import datetime
 from unittest import mock
+
 from wqflask.marker_regression.run_mapping import get_genofile_samplelist
 from wqflask.marker_regression.run_mapping import geno_db_exists
 from wqflask.marker_regression.run_mapping import write_input_for_browser
+from wqflask.marker_regression.run_mapping import export_mapping_results
+from wqflask.marker_regression.run_mapping import trim_markers_for_figure
+
 
 class AttributeSetter:
-	def __init__(self,obj):
-		for k,v in obj.items():
-			setattr(self,k,v)
+    def __init__(self, obj):
+        for k, v in obj.items():
+            setattr(self, k, v)
 
 
 class MockDataSetGroup(AttributeSetter):
-	
-	def get_genofiles(self):
-		return [{"location":"~/genofiles/g1_file","sample_list":["S1","S2","S3","S4"]}]
+
+    def get_genofiles(self):
+        return [{"location": "~/genofiles/g1_file", "sample_list": ["S1", "S2", "S3", "S4"]}]
+
+
 class TestRunMapping(unittest.TestCase):
-	def setUp(self):
-		self.group=MockDataSetGroup({"genofile":"~/genofiles/g1_file","name":"GP1_"})
-		self.dataset=AttributeSetter({"group":self.group})
+    def setUp(self):
+        self.group = MockDataSetGroup(
+            {"genofile": "~/genofiles/g1_file", "name": "GP1_","species":"Human"})
+        self.dataset = AttributeSetter({"fullname":"dataser_1","group": self.group,"type":"ProbeSet"})
+        self.trait=AttributeSetter({"symbol":"IGFI","chr":"X1","mb":123313})
+
+    def tearDown(self):
+        self.dataset = AttributeSetter(
+            {"group": {"location": "~/genofiles/g1_file"}})
+
+    def test_get_genofile_samplelist(self):
+
+        results_1 = get_genofile_samplelist(self.dataset)
+        self.assertEqual(results_1, ["S1", "S2", "S3", "S4"])
+        self.group.genofile = "~/genofiles/g2_file"
+        result_2 = get_genofile_samplelist(self.dataset)
+        self.assertEqual(result_2, [])
+
+    @mock.patch("wqflask.marker_regression.run_mapping.data_set")
+    def test_geno_db_exists(self, mock_data_set):
+        mock_data_set.create_dataset.side_effect = [
+            AttributeSetter({}), Exception()]
+        results_no_error = geno_db_exists(self.dataset)
+        results_with_error = geno_db_exists(self.dataset)
+
+        self.assertEqual(mock_data_set.create_dataset.call_count, 2)
+        self.assertEqual(results_with_error, "False")
+        self.assertEqual(results_no_error, "True")
+
+    
+    def test_trim_markers_for_figure(self):
 
-	def tearDown(self):
-		self.dataset=AttributeSetter({"group":{"location":"~/genofiles/g1_file"}})
 
-	def test_get_genofile_samplelist(self):
+    	markers=[{
+    	"name":"MK1",
+    	"chr":"C1",
+    	"cM":"1",
+    	"Mb":"12000",
+    	"genotypes":[],
+    	"dominance":"TT",
+    	"additive":"VA",
+    	"lod_score":0.5
+    	},
+    	{
+    	"name":"MK2",
+    	"chr":"C2",
+    	"cM":"15",
+    	"Mb":"10000",
+    	"genotypes":[],
+    	"lod_score":0.7
+    	},
+    	{
+    	"name":"MK1",
+    	"chr":"C3",
+    	"cM":"45",
+    	"Mb":"1",
+    	"genotypes":[],
+    	"dominance":"Tt",
+    	"additive":"VE",
+    	"lod_score":1
+    	}]
 
-		results_1=get_genofile_samplelist(self.dataset)
-		self.assertEqual(results_1,["S1","S2","S3","S4"])
-		self.group.genofile="~/genofiles/g2_file"
-		result_2=get_genofile_samplelist(self.dataset)
-		self.assertEqual(result_2,[])
+    	marker_2=[{
+    	"name":"MK1",
+    	"chr":"C1",
+    	"cM":"1",
+    	"Mb":"12000",
+    	"genotypes":[],
+    	"dominance":"TT",
+    	"additive":"VA",
+    	"p_wald":4.6
+    	}]
+    	results=trim_markers_for_figure(markers)
+    	result_2=trim_markers_for_figure(marker_2)
+    	expected=[
+    	{
+    	"name":"MK1",
+    	"chr":"C1",
+    	"cM":"1",
+    	"Mb":"12000",
+    	"genotypes":[],
+    	"dominance":"TT",
+    	"additive":"VA",
+    	"lod_score":0.5
+    	},
+    	{
+    	"name":"MK1",
+    	"chr":"C3",
+    	"cM":"45",
+    	"Mb":"1",
+    	"genotypes":[],
+    	"dominance":"Tt",
+    	"additive":"VE",
+    	"lod_score":1
+    	}
 
-	@mock.patch("wqflask.marker_regression.run_mapping.data_set")
-	def test_geno_db_exists(self,mock_data_set):
-		mock_data_set.create_dataset.side_effect=[AttributeSetter({}),Exception()]
-		results_no_error=geno_db_exists(self.dataset)
-		results_with_error=geno_db_exists(self.dataset)
+    	]
+    	self.assertEqual(results,expected)
+    	self.assertEqual(result_2,marker_2)
 
-		self.assertEqual(mock_data_set.create_dataset.call_count,2)
-		self.assertEqual(results_with_error,"False")
-		self.assertEqual(results_no_error,"True")
+    def test_export_mapping_results(self):
+    	datetime_mock=mock.Mock(wraps=datetime.datetime)
+    	datetime_mock.now.return_value=datetime.datetime(2019,9,1,10,12,12)
 
+    	markers=[{
+    	"name":"MK1",
+    	"chr":"C1",
+    	"cM":"1",
+    	"Mb":"12000",
+    	"genotypes":[],
+    	"dominance":"TT",
+    	"additive":"VA",
+    	"lod_score":3
+    	},
+    	{
+    	"name":"MK2",
+    	"chr":"C2",
+    	"cM":"15",
+    	"Mb":"10000",
+    	"genotypes":[],
+    	"lod_score":7
+    	},
+    	{
+    	"name":"MK1",
+    	"chr":"C3",
+    	"cM":"45",
+    	"Mb":"1",
+    	"genotypes":[],
+    	"dominance":"Tt",
+    	"additive":"VE",
+    	"lod_score":7
+    	}]
 
+    	with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+    		
+    		# mock_open.assert_called_once_with("~/results","w+")
+    		# filehandler=mock_open()
+    		with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime",new=datetime_mock):
+    			export_mapping_results(dataset=self.dataset,trait=self.trait,markers=markers,results_path="~/results",mapping_scale="physic",score_type="-log(p)")
 
+    		
+	    		write_calls=[
+	    		mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
+	    		 mock.call('Population: Human GP1_\n'),mock.call('Data Set: dataser_1\n'),
+				 mock.call('Gene Symbol: IGFI\n'), mock.call('Location: X1 @ 123313 Mb\n'),
+				 mock.call('\n'), mock.call('Name,Chr,'),
+				 mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
+				 mock.call(',Additive'),mock.call(',Dominance'),
+				 mock.call('\n'),mock.call('MK1,C1,'),
+				 mock.call('12000,'), mock.call('1,'),
+				 mock.call('3'), mock.call(',VA'),
+				 mock.call(',TT'),mock.call('\n'),
+				 mock.call('MK2,C2,'),mock.call('10000,'),
+				 mock.call('15,'), mock.call('7'),
+				 mock.call('\n'), mock.call('MK1,C3,'),
+				 mock.call('1,'),mock.call('45,'),
+				 mock.call('7'), mock.call(',VE'),
+				 mock.call(',Tt')
 
+	    		]
+	    		mock_open.assert_called_once_with("~/results","w+")
+	    		filehandler=mock_open()
+	    		filehandler.write.assert_has_calls(write_calls)
\ No newline at end of file
-- 
cgit v1.2.3


From 96dd0a10f0bfe66afab9701dd028f169d63cdae5 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 10 Nov 2020 19:56:07 +0300
Subject: add tests for write input for browser in
 marker_regression/run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py  | 277 +++++++++++----------
 1 file changed, 144 insertions(+), 133 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index e925ad28..6521c41d 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -24,9 +24,11 @@ class MockDataSetGroup(AttributeSetter):
 class TestRunMapping(unittest.TestCase):
     def setUp(self):
         self.group = MockDataSetGroup(
-            {"genofile": "~/genofiles/g1_file", "name": "GP1_","species":"Human"})
-        self.dataset = AttributeSetter({"fullname":"dataser_1","group": self.group,"type":"ProbeSet"})
-        self.trait=AttributeSetter({"symbol":"IGFI","chr":"X1","mb":123313})
+            {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
+        self.dataset = AttributeSetter(
+            {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
+        self.trait = AttributeSetter(
+            {"symbol": "IGFI", "chr": "X1", "mb": 123313})
 
     def tearDown(self):
         self.dataset = AttributeSetter(
@@ -51,137 +53,146 @@ class TestRunMapping(unittest.TestCase):
         self.assertEqual(results_with_error, "False")
         self.assertEqual(results_no_error, "True")
 
-    
     def test_trim_markers_for_figure(self):
 
-
-    	markers=[{
-    	"name":"MK1",
-    	"chr":"C1",
-    	"cM":"1",
-    	"Mb":"12000",
-    	"genotypes":[],
-    	"dominance":"TT",
-    	"additive":"VA",
-    	"lod_score":0.5
-    	},
-    	{
-    	"name":"MK2",
-    	"chr":"C2",
-    	"cM":"15",
-    	"Mb":"10000",
-    	"genotypes":[],
-    	"lod_score":0.7
-    	},
-    	{
-    	"name":"MK1",
-    	"chr":"C3",
-    	"cM":"45",
-    	"Mb":"1",
-    	"genotypes":[],
-    	"dominance":"Tt",
-    	"additive":"VE",
-    	"lod_score":1
-    	}]
-
-    	marker_2=[{
-    	"name":"MK1",
-    	"chr":"C1",
-    	"cM":"1",
-    	"Mb":"12000",
-    	"genotypes":[],
-    	"dominance":"TT",
-    	"additive":"VA",
-    	"p_wald":4.6
-    	}]
-    	results=trim_markers_for_figure(markers)
-    	result_2=trim_markers_for_figure(marker_2)
-    	expected=[
-    	{
-    	"name":"MK1",
-    	"chr":"C1",
-    	"cM":"1",
-    	"Mb":"12000",
-    	"genotypes":[],
-    	"dominance":"TT",
-    	"additive":"VA",
-    	"lod_score":0.5
-    	},
-    	{
-    	"name":"MK1",
-    	"chr":"C3",
-    	"cM":"45",
-    	"Mb":"1",
-    	"genotypes":[],
-    	"dominance":"Tt",
-    	"additive":"VE",
-    	"lod_score":1
-    	}
-
-    	]
-    	self.assertEqual(results,expected)
-    	self.assertEqual(result_2,marker_2)
+        markers = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "lod_score":0.5
+        },
+            {
+            "name": "MK2",
+            "chr": "C2",
+            "cM": "15",
+            "Mb": "10000",
+            "genotypes": [],
+            "lod_score":0.7
+        },
+            {
+            "name": "MK1",
+            "chr": "C3",
+            "cM": "45",
+            "Mb": "1",
+            "genotypes": [],
+            "dominance":"Tt",
+            "additive":"VE",
+            "lod_score":1
+        }]
+
+        marker_2 = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "p_wald":4.6
+        }]
+        results = trim_markers_for_figure(markers)
+        result_2 = trim_markers_for_figure(marker_2)
+        expected = [
+            {
+                "name": "MK1",
+                "chr": "C1",
+                "cM": "1",
+                "Mb": "12000",
+                "genotypes": [],
+                "dominance":"TT",
+                "additive":"VA",
+                "lod_score":0.5
+            },
+            {
+                "name": "MK1",
+                "chr": "C3",
+                "cM": "45",
+                "Mb": "1",
+                "genotypes": [],
+                "dominance":"Tt",
+                "additive":"VE",
+                "lod_score":1
+            }
+
+        ]
+        self.assertEqual(results, expected)
+        self.assertEqual(result_2, marker_2)
 
     def test_export_mapping_results(self):
-    	datetime_mock=mock.Mock(wraps=datetime.datetime)
-    	datetime_mock.now.return_value=datetime.datetime(2019,9,1,10,12,12)
-
-    	markers=[{
-    	"name":"MK1",
-    	"chr":"C1",
-    	"cM":"1",
-    	"Mb":"12000",
-    	"genotypes":[],
-    	"dominance":"TT",
-    	"additive":"VA",
-    	"lod_score":3
-    	},
-    	{
-    	"name":"MK2",
-    	"chr":"C2",
-    	"cM":"15",
-    	"Mb":"10000",
-    	"genotypes":[],
-    	"lod_score":7
-    	},
-    	{
-    	"name":"MK1",
-    	"chr":"C3",
-    	"cM":"45",
-    	"Mb":"1",
-    	"genotypes":[],
-    	"dominance":"Tt",
-    	"additive":"VE",
-    	"lod_score":7
-    	}]
-
-    	with mock.patch("builtins.open", mock.mock_open()) as mock_open:
-    		
-    		# mock_open.assert_called_once_with("~/results","w+")
-    		# filehandler=mock_open()
-    		with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime",new=datetime_mock):
-    			export_mapping_results(dataset=self.dataset,trait=self.trait,markers=markers,results_path="~/results",mapping_scale="physic",score_type="-log(p)")
-
-    		
-	    		write_calls=[
-	    		mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
-	    		 mock.call('Population: Human GP1_\n'),mock.call('Data Set: dataser_1\n'),
-				 mock.call('Gene Symbol: IGFI\n'), mock.call('Location: X1 @ 123313 Mb\n'),
-				 mock.call('\n'), mock.call('Name,Chr,'),
-				 mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
-				 mock.call(',Additive'),mock.call(',Dominance'),
-				 mock.call('\n'),mock.call('MK1,C1,'),
-				 mock.call('12000,'), mock.call('1,'),
-				 mock.call('3'), mock.call(',VA'),
-				 mock.call(',TT'),mock.call('\n'),
-				 mock.call('MK2,C2,'),mock.call('10000,'),
-				 mock.call('15,'), mock.call('7'),
-				 mock.call('\n'), mock.call('MK1,C3,'),
-				 mock.call('1,'),mock.call('45,'),
-				 mock.call('7'), mock.call(',VE'),
-				 mock.call(',Tt')
-
-	    		]
-	    		mock_open.assert_called_once_with("~/results","w+")
-	    		filehandler=mock_open()
-	    		filehandler.write.assert_has_calls(write_calls)
\ No newline at end of file
+        datetime_mock = mock.Mock(wraps=datetime.datetime)
+        datetime_mock.now.return_value = datetime.datetime(
+            2019, 9, 1, 10, 12, 12)
+
+        markers = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "lod_score":3
+        },
+            {
+            "name": "MK2",
+            "chr": "C2",
+            "cM": "15",
+            "Mb": "10000",
+            "genotypes": [],
+            "lod_score":7
+        },
+            {
+            "name": "MK1",
+            "chr": "C3",
+            "cM": "45",
+            "Mb": "1",
+            "genotypes": [],
+            "dominance":"Tt",
+            "additive":"VE",
+            "lod_score":7
+        }]
+
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+
+            with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
+                export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
+                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)")
+
+                write_calls = [
+                    mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
+                    mock.call('Population: Human GP1_\n'), mock.call(
+                        'Data Set: dataser_1\n'),
+                    mock.call('Gene Symbol: IGFI\n'), mock.call(
+                        'Location: X1 @ 123313 Mb\n'),
+                    mock.call('\n'), mock.call('Name,Chr,'),
+                    mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
+                    mock.call(',Additive'), mock.call(',Dominance'),
+                    mock.call('\n'), mock.call('MK1,C1,'),
+                    mock.call('12000,'), mock.call('1,'),
+                    mock.call('3'), mock.call(',VA'),
+                    mock.call(',TT'), mock.call('\n'),
+                    mock.call('MK2,C2,'), mock.call('10000,'),
+                    mock.call('15,'), mock.call('7'),
+                    mock.call('\n'), mock.call('MK1,C3,'),
+                    mock.call('1,'), mock.call('45,'),
+                    mock.call('7'), mock.call(',VE'),
+                    mock.call(',Tt')
+
+                ]
+                mock_open.assert_called_once_with("~/results", "w+")
+                filehandler = mock_open()
+                filehandler.write.assert_has_calls(write_calls)
+
+
+    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
+    def test_write_input_for_browser(self,mock_choice):
+    	mock_choice.side_effect=["F","i","l","e","s","x"]
+    	with mock.patch("builtins.open",mock.mock_open()) as mock_open:
+    		expected=['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
+
+    		results=write_input_for_browser(this_dataset=self.dataset,gwas_results={},annotations={})
+    		self.assertEqual(results,expected)
-- 
cgit v1.2.3


From 424f44c0656da8f99dce0fa0a00bd5e6ba9bace3 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 11 Nov 2020 23:05:17 +0300
Subject: add tests for marker_regression/gemma_mapping.py

---
 wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index 06ce55d8..ed72cb33 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -151,18 +151,21 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
             mock_open.assert_called_once_with(
                 "/home/user/img/gema_file_output.assoc.txt")
             self.assertEqual(results, expected)
+
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
     def test_parse_gemma_output_empty_return(self):
         output_file_results = """chr\t today"""
         with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
             results = parse_gemma_output(genofile_name="gema_file")
             self.assertEqual(results, [])
+
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_found(self, mock_os):
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
         pass
+
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_not_found(self, mock_os):
-- 
cgit v1.2.3


From 3396e1f008f3605439b38837f7a50407588d1f9b Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 11 Nov 2020 23:06:27 +0300
Subject: add tests for marker_regression/run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py  | 85 ++++++++++++++++++++++
 1 file changed, 85 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index 6521c41d..be6e6e48 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -7,6 +7,8 @@ from wqflask.marker_regression.run_mapping import geno_db_exists
 from wqflask.marker_regression.run_mapping import write_input_for_browser
 from wqflask.marker_regression.run_mapping import export_mapping_results
 from wqflask.marker_regression.run_mapping import trim_markers_for_figure
+from wqflask.marker_regression.run_mapping import get_perm_strata
+from wqflask.marker_regression.run_mapping import get_chr_lengths
 
 
 class AttributeSetter:
@@ -23,10 +25,27 @@ class MockDataSetGroup(AttributeSetter):
 
 class TestRunMapping(unittest.TestCase):
     def setUp(self):
+
         self.group = MockDataSetGroup(
             {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
+        chromosomes={
+    	 "3":AttributeSetter({
+    	 "name":"C1",
+    	 "length":"0.04"
+    	 }),
+    	  "4":AttributeSetter({
+    	 "name":"C2",
+    	 "length":"0.03"
+    	 }),
+    	  "5":AttributeSetter({
+    	 "name":"C4",
+    	 "length":"0.01"
+    	 })
+    	}
         self.dataset = AttributeSetter(
             {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
+
+        self.chromosomes=AttributeSetter({"chromosomes":chromosomes})
         self.trait = AttributeSetter(
             {"symbol": "IGFI", "chr": "X1", "mb": 123313})
 
@@ -196,3 +215,69 @@ class TestRunMapping(unittest.TestCase):
 
     		results=write_input_for_browser(this_dataset=self.dataset,gwas_results={},annotations={})
     		self.assertEqual(results,expected)
+
+
+    def test_get_perm_strata(self):
+    	categorical_vars=["C1","C2","W1"]
+    	used_samples=["S1","S2"]
+    	sample_list=AttributeSetter({"sample_attribute_values":{
+    		"S1":{
+    		 "C1":"c1_value",
+    		 "C2":"c2_value",
+    		 "W1":"w1_value"
+
+    		},
+    		"S2":{
+    		"W1":"w2_value",
+    		 "W2":"w2_value"
+
+    		},
+    		"S3":{
+
+    		"C1":"c1_value",
+    		"C2":"c2_value"
+
+    		},
+    		
+    		}})
+
+    	results=get_perm_strata(this_trait={},sample_list=sample_list,categorical_vars=categorical_vars,used_samples=used_samples)
+    	self.assertEqual(results,[2,1])
+
+
+    def test_get_chr_length(self):
+    	chromosomes=AttributeSetter({"chromosomes":self.chromosomes})
+    	dataset=AttributeSetter({"species":chromosomes})
+    	results=get_chr_lengths(mapping_scale="physic",mapping_method="reaper",dataset=dataset,qtl_results=[])
+    	chr_lengths=[]
+    	for key,chromo in self.chromosomes.chromosomes.items():
+    		chr_lengths.append({"chr":chromo.name,"size":chromo.length})
+
+    	self.assertEqual(chr_lengths,results)
+
+    	qtl_results=[{
+    	"chr":"16",
+    	"cM":"0.2"
+    	},
+    	{
+    	"chr":"12",
+    	"cM":"0.5"
+    	},
+    	{
+    	"chr":"18",
+    	"cM":"0.1"
+    	},
+    	{
+    	"chr":"22",
+    	"cM":"0.4"
+    	},
+    	]
+
+
+
+    	result_with_other_mapping_scale=get_chr_lengths(mapping_scale="other",mapping_method="reaper",dataset=dataset,qtl_results=qtl_results)
+    	expected_value= [{'chr': '1', 'size': '0'}, {'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
+
+    	self.assertEqual(result_with_other_mapping_scale,expected_value)    	
+
+
-- 
cgit v1.2.3


From 8f85c96b2094a9ce722b93a0e375ec3de90c959a Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 11 Nov 2020 23:08:14 +0300
Subject: add tests for marker_regression/qtlreaper_mapping.py

---
 .../marker_regression/test_qtlreaper_mapping.py    | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
new file mode 100644
index 00000000..7ece663a
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -0,0 +1,22 @@
+import unittest
+from unittest import  mock
+from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
+from wqflask.marker_regression.qtlreaper_mapping import  natural_sort
+
+#issues some methods in genofile object are not defined
+#modify samples should equal to vals
+class TestQtlReaperMapping(unittest.TestCase):
+	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
+	def  test_gen_pheno_txt_file(self):
+		vals=["V1","x","V4","V3","x"]
+		samples=["S1","S2","S3","S4","S5"]
+		trait_filename="trait_file"
+		with mock.patch("builtins.open", mock.mock_open())as mock_open:
+			gen_pheno_txt_file(samples=samples,vals=vals,trait_filename=trait_filename)
+			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt","w")
+			filehandler=mock_open()
+			write_calls= [mock.call('Trait\t'),mock.call('S1\tS3\tS4\n'),mock.call('T1\t'),mock.call('V1\tV4\tV3')]
+
+			filehandler.write.assert_has_calls(write_calls)
+
+	                                                                                                                    
-- 
cgit v1.2.3


From e63e85868ed7b63bbe784368b3c1babf0d1f2088 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Wed, 11 Nov 2020 23:09:01 +0300
Subject: add tests for marker_regression/rqtl_mapping.py

---
 .../wqflask/marker_regression/test_rqtl_mapping.py | 55 ++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
new file mode 100644
index 00000000..641644cc
--- /dev/null
+++ b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
@@ -0,0 +1,55 @@
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
+
+class TestRqtlMapping(unittest.TestCase):
+
+	def setUp(self):
+		self.app_context=app.app_context()
+		self.app_context.push()
+
+	def tearDown(self):
+		self.app_context.pop()
+
+
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
+	def test_get_trait_data_type_found(self,mock_logger,mock_db):
+		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+		results=get_trait_data_type("traid_id")
+		mock_db.db.execute.assert_called_with(caller_value)
+		self.assertEqual(results,"fer434f")
+
+
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
+	def test_get_trait_data_type_not_found(self,mock_logger,mock_db):
+		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+		results=get_trait_data_type("other")
+		mock_db.db.execute.assert_called_with(caller_value)
+		self.assertEqual(results,"numeric")
+
+	def test_sanitize_rqtl_phenotype(self):
+		vals=['f',"x","r","x","x"]
+		results=sanitize_rqtl_phenotype(vals)
+		expected_phenotype_string='c(f,NA,r,NA,NA)'
+
+		self.assertEqual(results,expected_phenotype_string)
+
+	def test_sanitize_rqtl_names(self):
+		vals=['f',"x","r","x","x"]
+		expected_sanitized_name="c('f',NA,'r',NA,NA)"
+		results=sanitize_rqtl_names(vals)
+		self.assertEqual(expected_sanitized_name,results)
+
+
+		
+		
+
+
+
-- 
cgit v1.2.3


From f4dbdc51102d942079c7159ac48071282ec995ea Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 12 Nov 2020 00:45:03 +0300
Subject: modify tests  for marker regression

---
 .../marker_regression/test_gemma_mapping.py        |   8 ++
 .../marker_regression/test_plink_mapping.py        |   4 +
 .../marker_regression/test_qtlreaper_mapping.py    |   3 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |  13 +-
 .../wqflask/marker_regression/test_run_mapping.py  | 153 +++++++++++----------
 5 files changed, 93 insertions(+), 88 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index ed72cb33..e47c8335 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -24,6 +24,7 @@ class TestGemmaMapping(unittest.TestCase):
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
     def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
+        """add tests for gemma function where  first run is set to false"""
         dataset = AttributeSetter(
             {"group": AttributeSetter({"genofile": "genofile.geno"})})
 
@@ -50,6 +51,7 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
     def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
+        """add tests for run_gemma where first run is set to true"""
         chromosomes = []
         for i in range(1, 5):
             chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
@@ -81,6 +83,7 @@ class TestGemmaMapping(unittest.TestCase):
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
     def test_gen_pheno_txt_file(self):
+        """add tests for generating pheno txt file"""
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
             gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
                                "x", "w", "q", "we", "R"], trait_filename="fitr.re")
@@ -97,6 +100,7 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait")
     @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset")
     def test_gen_covariates_file(self, create_dataset, create_trait, flat_files):
+        """add tests for generating covariates files"""
         covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2"
         samplelist = ["X1", "X2", "X3", "X4"]
         create_dataset_side_effect = []
@@ -138,6 +142,7 @@ class TestGemmaMapping(unittest.TestCase):
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
     def test_parse_gemma_output_obj_returned(self):
+        """add test for generating gemma output with obj returned"""
         file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
 X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
 chr\tgn1\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7
@@ -154,6 +159,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
     def test_parse_gemma_output_empty_return(self):
+        """add tests for parse gemma output where nothing returned"""
         output_file_results = """chr\t today"""
         with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
             results = parse_gemma_output(genofile_name="gema_file")
@@ -162,6 +168,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_found(self, mock_os):
+        """add tests for parse loco output file found"""
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
         pass
@@ -169,6 +176,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     def test_parse_loco_output_file_not_found(self, mock_os):
+        """add tests for parse loco output file not found"""
 
         mock_os.path.isfile.return_value = False
         file_to_write = """{"files":["file_1","file_2"]}"""
diff --git a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
index a5fa0c04..428f45b9 100644
--- a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
@@ -15,6 +15,7 @@ class AttributeSetter:
 class TestPlinkMapping(unittest.TestCase):
 
     def test_build_line_list(self):
+        """testing for building line list"""
         line_1 = "this is line one test"
         irregular_line = "  this     is an, irregular line     "
         exp_line1 = ["this", "is", "line", "one", "test"]
@@ -26,6 +27,7 @@ class TestPlinkMapping(unittest.TestCase):
 
     @mock.patch("wqflask.marker_regression.plink_mapping.flat_files")
     def test_get_samples_from_ped_file(self, mock_flat_files):
+        """test for getting samples from ped file"""
         dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
         file_sample = """Expected_1\tline test
 Expected_2\there
@@ -41,6 +43,7 @@ Expected_2\there
     @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
     @mock.patch("wqflask.marker_regression.plink_mapping.get_samples_from_ped_file")
     def test_gen_pheno_txt_file_plink(self, mock_samples):
+        """test for getting gen_pheno txt file"""
         mock_samples.return_value = ["Expected_1", "Expected_2", "Expected_3"]
 
         trait = AttributeSetter({"name": "TX"})
@@ -62,6 +65,7 @@ Expected_2\there
     @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
     @mock.patch("wqflask.marker_regression.plink_mapping.build_line_list")
     def test_parse_plink_output(self, mock_line_list):
+        """test for parsing plink output"""
         chromosomes = [0, 34, 110, 89, 123, 23, 2]
         species = AttributeSetter(
             {"name": "S1", "chromosomes": AttributeSetter({"chromosomes": chromosomes})})
diff --git a/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
index 7ece663a..b47f877a 100644
--- a/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -1,13 +1,12 @@
 import unittest
 from unittest import  mock
 from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
-from wqflask.marker_regression.qtlreaper_mapping import  natural_sort
 
 #issues some methods in genofile object are not defined
 #modify samples should equal to vals
 class TestQtlReaperMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
-	def  test_gen_pheno_txt_file(self):
+	def  test_gen_pheno_txt_file(self):                   
 		vals=["V1","x","V4","V3","x"]
 		samples=["S1","S2","S3","S4","S5"]
 		trait_filename="trait_file"
diff --git a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
index 641644cc..9fd32a30 100644
--- a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
@@ -18,23 +18,15 @@ class TestRqtlMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
 	def test_get_trait_data_type_found(self,mock_logger,mock_db):
+		"""test for getting trait data_type return True"""
 		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
 		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
 		results=get_trait_data_type("traid_id")
 		mock_db.db.execute.assert_called_with(caller_value)
 		self.assertEqual(results,"fer434f")
 
-
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-	def test_get_trait_data_type_not_found(self,mock_logger,mock_db):
-		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
-		results=get_trait_data_type("other")
-		mock_db.db.execute.assert_called_with(caller_value)
-		self.assertEqual(results,"numeric")
-
 	def test_sanitize_rqtl_phenotype(self):
+		"""test for sanitizing rqtl phenotype"""
 		vals=['f',"x","r","x","x"]
 		results=sanitize_rqtl_phenotype(vals)
 		expected_phenotype_string='c(f,NA,r,NA,NA)'
@@ -42,6 +34,7 @@ class TestRqtlMapping(unittest.TestCase):
 		self.assertEqual(results,expected_phenotype_string)
 
 	def test_sanitize_rqtl_names(self):
+		"""test for sanitzing rqtl names"""
 		vals=['f',"x","r","x","x"]
 		expected_sanitized_name="c('f',NA,'r',NA,NA)"
 		results=sanitize_rqtl_names(vals)
diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index be6e6e48..2af4c3e3 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -28,24 +28,24 @@ class TestRunMapping(unittest.TestCase):
 
         self.group = MockDataSetGroup(
             {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
-        chromosomes={
-    	 "3":AttributeSetter({
-    	 "name":"C1",
-    	 "length":"0.04"
-    	 }),
-    	  "4":AttributeSetter({
-    	 "name":"C2",
-    	 "length":"0.03"
-    	 }),
-    	  "5":AttributeSetter({
-    	 "name":"C4",
-    	 "length":"0.01"
-    	 })
-    	}
+        chromosomes = {
+            "3": AttributeSetter({
+                "name": "C1",
+                "length": "0.04"
+            }),
+            "4": AttributeSetter({
+                "name": "C2",
+                "length": "0.03"
+            }),
+            "5": AttributeSetter({
+                "name": "C4",
+                "length": "0.01"
+            })
+        }
         self.dataset = AttributeSetter(
             {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
 
-        self.chromosomes=AttributeSetter({"chromosomes":chromosomes})
+        self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
         self.trait = AttributeSetter(
             {"symbol": "IGFI", "chr": "X1", "mb": 123313})
 
@@ -142,6 +142,7 @@ class TestRunMapping(unittest.TestCase):
         self.assertEqual(result_2, marker_2)
 
     def test_export_mapping_results(self):
+        """test for exporting mapping results"""
         datetime_mock = mock.Mock(wraps=datetime.datetime)
         datetime_mock.now.return_value = datetime.datetime(
             2019, 9, 1, 10, 12, 12)
@@ -206,78 +207,78 @@ class TestRunMapping(unittest.TestCase):
                 filehandler = mock_open()
                 filehandler.write.assert_has_calls(write_calls)
 
-
     @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
-    def test_write_input_for_browser(self,mock_choice):
-    	mock_choice.side_effect=["F","i","l","e","s","x"]
-    	with mock.patch("builtins.open",mock.mock_open()) as mock_open:
-    		expected=['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
-
-    		results=write_input_for_browser(this_dataset=self.dataset,gwas_results={},annotations={})
-    		self.assertEqual(results,expected)
+    def test_write_input_for_browser(self, mock_choice):
+        """test for writing input for browser"""
+        mock_choice.side_effect = ["F", "i", "l", "e", "s", "x"]
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+            expected = ['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
 
+            results = write_input_for_browser(
+                this_dataset=self.dataset, gwas_results={}, annotations={})
+            self.assertEqual(results, expected)
 
     def test_get_perm_strata(self):
-    	categorical_vars=["C1","C2","W1"]
-    	used_samples=["S1","S2"]
-    	sample_list=AttributeSetter({"sample_attribute_values":{
-    		"S1":{
-    		 "C1":"c1_value",
-    		 "C2":"c2_value",
-    		 "W1":"w1_value"
+        categorical_vars = ["C1", "C2", "W1"]
+        used_samples = ["S1", "S2"]
+        sample_list = AttributeSetter({"sample_attribute_values": {
+            "S1": {
+                "C1": "c1_value",
+                "C2": "c2_value",
+                "W1": "w1_value"
 
-    		},
-    		"S2":{
-    		"W1":"w2_value",
-    		 "W2":"w2_value"
+            },
+            "S2": {
+                "W1": "w2_value",
+                "W2": "w2_value"
 
-    		},
-    		"S3":{
+            },
+            "S3": {
 
-    		"C1":"c1_value",
-    		"C2":"c2_value"
+                "C1": "c1_value",
+                "C2": "c2_value"
 
-    		},
-    		
-    		}})
+            },
 
-    	results=get_perm_strata(this_trait={},sample_list=sample_list,categorical_vars=categorical_vars,used_samples=used_samples)
-    	self.assertEqual(results,[2,1])
+        }})
 
+        results = get_perm_strata(this_trait={}, sample_list=sample_list,
+                                  categorical_vars=categorical_vars, used_samples=used_samples)
+        self.assertEqual(results, [2, 1])
 
     def test_get_chr_length(self):
-    	chromosomes=AttributeSetter({"chromosomes":self.chromosomes})
-    	dataset=AttributeSetter({"species":chromosomes})
-    	results=get_chr_lengths(mapping_scale="physic",mapping_method="reaper",dataset=dataset,qtl_results=[])
-    	chr_lengths=[]
-    	for key,chromo in self.chromosomes.chromosomes.items():
-    		chr_lengths.append({"chr":chromo.name,"size":chromo.length})
-
-    	self.assertEqual(chr_lengths,results)
-
-    	qtl_results=[{
-    	"chr":"16",
-    	"cM":"0.2"
-    	},
-    	{
-    	"chr":"12",
-    	"cM":"0.5"
-    	},
-    	{
-    	"chr":"18",
-    	"cM":"0.1"
-    	},
-    	{
-    	"chr":"22",
-    	"cM":"0.4"
-    	},
-    	]
-
-
-
-    	result_with_other_mapping_scale=get_chr_lengths(mapping_scale="other",mapping_method="reaper",dataset=dataset,qtl_results=qtl_results)
-    	expected_value= [{'chr': '1', 'size': '0'}, {'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
-
-    	self.assertEqual(result_with_other_mapping_scale,expected_value)    	
+        """test for getting chromosome length"""
+        chromosomes = AttributeSetter({"chromosomes": self.chromosomes})
+        dataset = AttributeSetter({"species": chromosomes})
+        results = get_chr_lengths(
+            mapping_scale="physic", mapping_method="reaper", dataset=dataset, qtl_results=[])
+        chr_lengths = []
+        for key, chromo in self.chromosomes.chromosomes.items():
+            chr_lengths.append({"chr": chromo.name, "size": chromo.length})
+
+        self.assertEqual(chr_lengths, results)
+
+        qtl_results = [{
+            "chr": "16",
+            "cM": "0.2"
+        },
+            {
+            "chr": "12",
+            "cM": "0.5"
+        },
+            {
+            "chr": "18",
+            "cM": "0.1"
+        },
+            {
+            "chr": "22",
+            "cM": "0.4"
+        },
+        ]
 
+        result_with_other_mapping_scale = get_chr_lengths(
+            mapping_scale="other", mapping_method="reaper", dataset=dataset, qtl_results=qtl_results)
+        expected_value = [{'chr': '1', 'size': '0'}, {
+            'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
 
+        self.assertEqual(result_with_other_mapping_scale, expected_value)
-- 
cgit v1.2.3


From a48e8d5e652551eb2d57953304ea0ec3587217ce Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 12 Nov 2020 21:11:28 +0300
Subject: add test for parse gemma output in marker_regression/gemma_mapping.py

---
 .../marker_regression/test_gemma_mapping.py        | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index e47c8335..bcc5dab9 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -167,11 +167,29 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    def test_parse_loco_output_file_found(self, mock_os):
+    @mock.patch("wqflask.marker_regression.gemma_mapping.json")
+    def test_parse_loco_output_file_found(self,mock_json,mock_os):
         """add tests for parse loco output file found"""
+        mock_json.load.return_value={
+        "files":[["file_name","user","~/file1"],
+        ["file_name","user","~/file2"]]
+        }
+        return_file_1="""X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+X/Y\tL2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
+        return_file_2="""chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
-        pass
+        with mock.patch("builtins.open") as mock_open:
+
+            handles=(mock.mock_open(read_data="gwas").return_value,mock.mock_open(read_data=return_file_1).return_value,mock.mock_open(read_data=return_file_2).return_value)
+            mock_open.side_effect=handles
+            results = parse_loco_output(
+                this_dataset={}, gwa_output_filename=".xw/")
+            expected_results= [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
+
+            self.assertEqual(expected_results,results)
+
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-- 
cgit v1.2.3


From da794df7cf9094fc81edbcf007149db86bf68d01 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 12 Nov 2020 21:12:48 +0300
Subject: add pep8 fixes in marker_regression/gemma_mapping.py

---
 .../marker_regression/test_gemma_mapping.py        | 23 +++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index bcc5dab9..a44ccb00 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -168,28 +168,29 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.json")
-    def test_parse_loco_output_file_found(self,mock_json,mock_os):
+    def test_parse_loco_output_file_found(self, mock_json, mock_os):
         """add tests for parse loco output file found"""
-        mock_json.load.return_value={
-        "files":[["file_name","user","~/file1"],
-        ["file_name","user","~/file2"]]
+        mock_json.load.return_value = {
+            "files": [["file_name", "user", "~/file1"],
+                      ["file_name", "user", "~/file2"]]
         }
-        return_file_1="""X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+        return_file_1 = """X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
 X/Y\tL2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
 chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
-        return_file_2="""chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
+        return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
         with mock.patch("builtins.open") as mock_open:
 
-            handles=(mock.mock_open(read_data="gwas").return_value,mock.mock_open(read_data=return_file_1).return_value,mock.mock_open(read_data=return_file_2).return_value)
-            mock_open.side_effect=handles
+            handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open(
+                read_data=return_file_1).return_value, mock.mock_open(read_data=return_file_2).return_value)
+            mock_open.side_effect = handles
             results = parse_loco_output(
                 this_dataset={}, gwa_output_filename=".xw/")
-            expected_results= [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
-
-            self.assertEqual(expected_results,results)
+            expected_results = [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {
+                'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
 
+            self.assertEqual(expected_results, results)
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-- 
cgit v1.2.3


From d4b3e8f43c4f4b10fb9614d80cb9d4e2a723c879 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Thu, 12 Nov 2020 21:40:49 +0300
Subject: refactor code

---
 wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index a44ccb00..af20c1b8 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -28,13 +28,12 @@ class TestGemmaMapping(unittest.TestCase):
         dataset = AttributeSetter(
             {"group": AttributeSetter({"genofile": "genofile.geno"})})
 
-        output_files = "file1"
-        use_loco = False
+        output_file = "file1"
         mock_parse_loco.return_value = []
         this_trait = AttributeSetter({"name": "t1"})
 
         result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
-        ], covariates="", use_loco=True, first_run=False, output_files=output_files)
+        ], covariates="", use_loco=True, first_run=False, output_files=output_file)
 
         expected_results = ([], "file1")
         self.assertEqual(expected_results, result)
-- 
cgit v1.2.3


From ceeae6fd087d91637c5007e0433ce347048fa96d Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Tue, 17 Nov 2020 22:31:10 +0300
Subject: use better function names

---
 .../tests/wqflask/marker_regression/test_gemma_mapping.py  | 14 +++++++-------
 .../tests/wqflask/marker_regression/test_rqtl_mapping.py   |  2 +-
 .../tests/wqflask/marker_regression/test_run_mapping.py    |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
index af20c1b8..4fafd95a 100644
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
@@ -23,7 +23,7 @@ class MockDatasetGroup(AttributeSetter):
 class TestGemmaMapping(unittest.TestCase):
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
-    def test_run_gemma_first_run_loco_set_false(self, mock_parse_loco):
+    def test_run_gemma_firstrun_set_false(self, mock_parse_loco):
         """add tests for gemma function where  first run is set to false"""
         dataset = AttributeSetter(
             {"group": AttributeSetter({"genofile": "genofile.geno"})})
@@ -49,7 +49,7 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_first_run_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
+    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
         """add tests for run_gemma where first run is set to true"""
         chromosomes = []
         for i in range(1, 5):
@@ -140,7 +140,7 @@ class TestGemmaMapping(unittest.TestCase):
                 '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
-    def test_parse_gemma_output_obj_returned(self):
+    def test_parse_gemma_output(self):
         """add test for generating gemma output with obj returned"""
         file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
 X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
@@ -157,7 +157,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
             self.assertEqual(results, expected)
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
-    def test_parse_gemma_output_empty_return(self):
+    def test_parse_gemma_output_with_empty_return(self):
         """add tests for parse gemma output where nothing returned"""
         output_file_results = """chr\t today"""
         with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
@@ -167,7 +167,7 @@ X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.json")
-    def test_parse_loco_output_file_found(self, mock_json, mock_os):
+    def test_parse_loco_outputfile_found(self, mock_json, mock_os):
         """add tests for parse loco output file found"""
         mock_json.load.return_value = {
             "files": [["file_name", "user", "~/file1"],
@@ -193,8 +193,8 @@ chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
 
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    def test_parse_loco_output_file_not_found(self, mock_os):
-        """add tests for parse loco output file not found"""
+    def test_parse_loco_outputfile_not_found(self, mock_os):
+        """add tests for parse loco output where  output file not found"""
 
         mock_os.path.isfile.return_value = False
         file_to_write = """{"files":["file_1","file_2"]}"""
diff --git a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
index 9fd32a30..69f53721 100644
--- a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
@@ -17,7 +17,7 @@ class TestRqtlMapping(unittest.TestCase):
 
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-	def test_get_trait_data_type_found(self,mock_logger,mock_db):
+	def test_get_trait_data(self,mock_logger,mock_db):
 		"""test for getting trait data_type return True"""
 		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
 		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
index 2af4c3e3..a134f551 100644
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
@@ -62,7 +62,7 @@ class TestRunMapping(unittest.TestCase):
         self.assertEqual(result_2, [])
 
     @mock.patch("wqflask.marker_regression.run_mapping.data_set")
-    def test_geno_db_exists(self, mock_data_set):
+    def test_if_geno_db_exists(self, mock_data_set):
         mock_data_set.create_dataset.side_effect = [
             AttributeSetter({}), Exception()]
         results_no_error = geno_db_exists(self.dataset)
-- 
cgit v1.2.3


From e323c52889cfbab7f152e4969f6e2b528768587a Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 20 Nov 2020 20:00:29 +0300
Subject: Update tests to use new gn2-docs url

---
 wqflask/tests/unit/wqflask/test_markdown_routes.py | 24 ++++++++++------------
 1 file changed, 11 insertions(+), 13 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
index 3adf63e5..2d403d04 100644
--- a/wqflask/tests/unit/wqflask/test_markdown_routes.py
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -23,8 +23,7 @@ class MockRequests200:
 This is some content
 
 ## Sub-heading
-This is another sub-heading
-        """
+This is another sub-heading"""
 
 class TestMarkdownRoutesFunctions(unittest.TestCase):
     """Test cases for functions in markdown_routes"""
@@ -32,27 +31,26 @@ class TestMarkdownRoutesFunctions(unittest.TestCase):
     @mock.patch('wqflask.markdown_routes.requests.get')
     def test_render_markdown_when_fetching_locally(self, requests_mock):
         requests_mock.return_value = MockRequests404()
-        markdown_content = render_markdown("glossary.md")
+        markdown_content = render_markdown("general/glossary/glossary.md")
         requests_mock.assert_called_with(
             "https://raw.githubusercontent.com"
-            "/genenetwork/genenetwork2/"
-            "wqflask/wqflask/static/"
-            "glossary.md")
+            "/genenetwork/gn-docs/"
+            "master/general/"
+            "glossary/glossary.md")
         self.assertRegexpMatches(markdown_content,
-                                 "Glossary of Terms and Features")
+                                 "Content for general/glossary/glossary.md not available.")
 
     @mock.patch('wqflask.markdown_routes.requests.get')
     def test_render_markdown_when_fetching_remotely(self, requests_mock):
         requests_mock.return_value = MockRequests200()
-        markdown_content = render_markdown("glossary.md")
+        markdown_content = render_markdown("general/glossary/glossary.md")
         requests_mock.assert_called_with(
             "https://raw.githubusercontent.com"
-            "/genenetwork/genenetwork2/"
-            "wqflask/wqflask/static/"
-            "glossary.md")
+            "/genenetwork/gn-docs/"
+            "master/general/"
+            "glossary/glossary.md")
         self.assertEqual("""<h1>Glossary</h1>
 <p>This is some content</p>
 <h2>Sub-heading</h2>
-<p>This is another sub-heading</p>
-""",
+<p>This is another sub-heading</p>""",
                          markdown_content)
-- 
cgit v1.2.3


From 8fc58655c9b98e816f31e4a4f99b6879fe304bca Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 20 Nov 2020 20:03:23 +0300
Subject: Replace mockobject with dataclasses

* wqflask/tests/unit/wqflask/test_markdown_routes.py
(MockRequests404): Use dataclasses.
(MockRequests200): Ditto.
---
 wqflask/tests/unit/wqflask/test_markdown_routes.py | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
index 2d403d04..90e0f17c 100644
--- a/wqflask/tests/unit/wqflask/test_markdown_routes.py
+++ b/wqflask/tests/unit/wqflask/test_markdown_routes.py
@@ -3,28 +3,26 @@
 import unittest
 from unittest import mock
 
+from dataclasses import dataclass
 from wqflask.markdown_routes import render_markdown
 
 
+@dataclass
 class MockRequests404:
-    @property
-    def status_code(self):
-        return 404
+    status_code: int = 404
 
-class MockRequests200:
-    @property
-    def status_code(self):
-        return 200
 
-    @property
-    def content(self):
-        return b"""
+@dataclass
+class MockRequests200:
+    status_code: int = 200
+    content: str = b"""
 # Glossary
 This is some content
 
 ## Sub-heading
 This is another sub-heading"""
 
+
 class TestMarkdownRoutesFunctions(unittest.TestCase):
     """Test cases for functions in markdown_routes"""
 
-- 
cgit v1.2.3


From 7f35213b64707e7c61affb6fa376f561200ac1d6 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Fri, 27 Nov 2020 19:59:17 +0300
Subject: move tests to unit folder

---
 .../marker_regression/test_gemma_mapping.py        | 205 +++++++++++++++
 .../marker_regression/test_plink_mapping.py        |  84 ++++++
 .../marker_regression/test_qtlreaper_mapping.py    |  21 ++
 .../wqflask/marker_regression/test_rqtl_mapping.py |  48 ++++
 .../wqflask/marker_regression/test_run_mapping.py  | 284 +++++++++++++++++++++
 .../marker_regression/test_gemma_mapping.py        | 205 ---------------
 .../marker_regression/test_plink_mapping.py        |  84 ------
 .../marker_regression/test_qtlreaper_mapping.py    |  21 --
 .../wqflask/marker_regression/test_rqtl_mapping.py |  48 ----
 .../wqflask/marker_regression/test_run_mapping.py  | 284 ---------------------
 10 files changed, 642 insertions(+), 642 deletions(-)
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
 create mode 100644 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
 delete mode 100644 wqflask/tests/wqflask/marker_regression/test_run_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
new file mode 100644
index 00000000..5b621264
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -0,0 +1,205 @@
+# test for wqflask/marker_regression/gemma_mapping.py
+import unittest
+import random
+from unittest import mock
+from wqflask.marker_regression.gemma_mapping import run_gemma
+from wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file
+from wqflask.marker_regression.gemma_mapping import gen_covariates_file
+from wqflask.marker_regression.gemma_mapping import parse_gemma_output
+from wqflask.marker_regression.gemma_mapping import parse_loco_output
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for key, val in obj.items():
+            setattr(self, key, val)
+
+
+class MockGroup(AttributeSetter):
+    def get_samplelist(self):
+        return None
+
+
+class TestGemmaMapping(unittest.TestCase):
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    def test_run_gemma_firstrun_set_false(self, mock_parse_loco):
+        """add tests for gemma function where  first run is set to false"""
+        dataset = AttributeSetter(
+            {"group": AttributeSetter({"genofile": "genofile.geno"})})
+
+        output_file = "file1"
+        mock_parse_loco.return_value = []
+        this_trait = AttributeSetter({"name": "t1"})
+
+        result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
+        ], covariates="", use_loco=True, first_run=False, output_files=output_file)
+
+        expected_results = ([], "file1")
+        self.assertEqual(expected_results, result)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.logger")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
+    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
+    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
+        """add tests for run_gemma where first run is set to true"""
+        chromosomes = []
+        for i in range(1, 5):
+            chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
+        chromo = AttributeSetter({"chromosomes": chromosomes})
+        dataset_group = MockGroup(
+            {"name": "GP1", "genofile": "file_geno"})
+        dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
+                                   "species": AttributeSetter({"chromosomes": chromo})})
+        trait = AttributeSetter({"name": "trait1"})
+        samples = []
+        mock_gen_pheno_txt.return_value = None
+        mock_os.path.isfile.return_value = True
+        mock_gen_covar.return_value = None
+        mock_choice.return_value = "R"
+        mock_flat_files.return_value = "/home/genotype/bimbam"
+        mock_parse_loco.return_value = []
+        results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
+        ], vals=[], covariates="", use_loco=True)
+        system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
+                        mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
+        mock_os.system.assert_has_calls(system_calls)
+        mock_gen_pheno_txt.assert_called_once()
+        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
+        mock_os.path.isfile.assert_called_once_with(
+            ('/home/user/imgfile_output.assoc.txt'))
+        self.assertEqual(mock_logger.debug.call_count, 2)
+        self.assertEqual(mock_flat_files.call_count, 4)
+        self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
+    def test_gen_pheno_txt_file(self):
+        """add tests for generating pheno txt file"""
+        with mock.patch("builtins.open", mock.mock_open())as mock_open:
+            gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
+                               "x", "w", "q", "we", "R"], trait_filename="fitr.re")
+            mock_open.assert_called_once_with(
+                '/home/user/data/gn2/fitr.re.txt', 'w')
+            filehandler = mock_open()
+            values = ["x", "w", "q", "we", "R"]
+            write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call(
+                'q\n'), mock.call('we\n'), mock.call('R\n')]
+
+            filehandler.write.assert_has_calls(write_calls)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset")
+    def test_gen_covariates_file(self, create_dataset, create_trait, flat_files):
+        """add tests for generating covariates files"""
+        covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2"
+        samplelist = ["X1", "X2", "X3", "X4"]
+        create_dataset_side_effect = []
+        create_trait_side_effect = []
+
+        for i in range(4):
+            create_dataset_side_effect.append(AttributeSetter({"name": f'name_{i}'}))
+            create_trait_side_effect.append(
+                AttributeSetter({"data": [f'data_{i}']}))
+
+        create_dataset.side_effect = create_trait_side_effect
+        create_trait.side_effect = create_trait_side_effect
+
+        group = MockGroup({"name": "group_X", "samplelist": samplelist})
+        this_dataset = AttributeSetter({"group": group})
+        flat_files.return_value = "Home/Genenetwork"
+
+        with mock.patch("builtins.open", mock.mock_open())as mock_open:
+            gen_covariates_file(this_dataset=this_dataset, covariates=covariates,
+                                samples=["x1", "x2", "X3"])
+
+            create_dataset.assert_has_calls(
+                [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')])
+            mock_calls = []
+            trait_names = ["X1", "Y1", "M1", "V1"]
+
+            for i, trait in enumerate(create_trait_side_effect):
+                mock_calls.append(
+                    mock.call(dataset=trait, name=trait_names[i], cellid=None))
+
+            create_trait.assert_has_calls(mock_calls)
+
+            flat_files.assert_called_once_with('mapping')
+            mock_open.assert_called_once_with(
+                'Home/Genenetwork/group_X_covariates.txt', 'w')
+            filehandler = mock_open()
+            filehandler.write.assert_has_calls([mock.call(
+                '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
+    def test_parse_gemma_output(self):
+        """add test for generating gemma output with obj returned"""
+        file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+chr\tgn1\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7
+X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
+125\tgn9\t433575\tQ\tE\tA\tP\tMMB\tCDE\t0.67
+"""
+        with mock.patch("builtins.open", mock.mock_open(read_data=file)) as mock_open:
+            results = parse_gemma_output(genofile_name="gema_file")
+            expected = [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812},
+                        {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
+            mock_open.assert_called_once_with(
+                "/home/user/img/gema_file_output.assoc.txt")
+            self.assertEqual(results, expected)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
+    def test_parse_gemma_output_with_empty_return(self):
+        """add tests for parse gemma output where nothing returned"""
+        output_file_results = """chr\t today"""
+        with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
+            results = parse_gemma_output(genofile_name="gema_file")
+            self.assertEqual(results, [])
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.json")
+    def test_parse_loco_outputfile_found(self, mock_json, mock_os):
+        """add tests for parse loco output file found"""
+        mock_json.load.return_value = {
+            "files": [["file_name", "user", "~/file1"],
+                      ["file_name", "user", "~/file2"]]
+        }
+        return_file_1 = """X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+X/Y\tL2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
+chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
+        return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
+        mock_os.path.isfile.return_value = True
+        file_to_write = """{"files":["file_1","file_2"]}"""
+        with mock.patch("builtins.open") as mock_open:
+
+            handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open(
+                read_data=return_file_1).return_value, mock.mock_open(read_data=return_file_2).return_value)
+            mock_open.side_effect = handles
+            results = parse_loco_output(
+                this_dataset={}, gwa_output_filename=".xw/")
+            expected_results = [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {
+                'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
+
+            self.assertEqual(expected_results, results)
+
+    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
+    def test_parse_loco_outputfile_not_found(self, mock_os):
+        """add tests for parse loco output where  output file not found"""
+
+        mock_os.path.isfile.return_value = False
+        file_to_write = """{"files":["file_1","file_2"]}"""
+
+        with mock.patch("builtins.open", mock.mock_open(read_data=file_to_write)) as mock_open:
+            results = parse_loco_output(
+                this_dataset={}, gwa_output_filename=".xw/")
+            self.assertEqual(results, [])
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
new file mode 100644
index 00000000..428f45b9
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -0,0 +1,84 @@
+# test for wqflask/marker_regression/plink_mapping.py
+import unittest
+from unittest import mock
+from wqflask.marker_regression.plink_mapping import build_line_list
+from wqflask.marker_regression.plink_mapping import get_samples_from_ped_file
+from wqflask.marker_regression.plink_mapping import flat_files
+from wqflask.marker_regression.plink_mapping import gen_pheno_txt_file_plink
+from wqflask.marker_regression.plink_mapping import parse_plink_output
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for key, val in obj.items():
+            setattr(self, key, val)
+class TestPlinkMapping(unittest.TestCase):
+
+    def test_build_line_list(self):
+        """testing for building line list"""
+        line_1 = "this is line one test"
+        irregular_line = "  this     is an, irregular line     "
+        exp_line1 = ["this", "is", "line", "one", "test"]
+
+        results = build_line_list(irregular_line)
+        self.assertEqual(exp_line1, build_line_list(line_1))
+        self.assertEqual([], build_line_list())
+        self.assertEqual(["this", "is", "an,", "irregular", "line"], results)
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.flat_files")
+    def test_get_samples_from_ped_file(self, mock_flat_files):
+        """test for getting samples from ped file"""
+        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
+        file_sample = """Expected_1\tline test
+Expected_2\there
+  Expected_3\tthree"""
+        mock_flat_files.return_value = "/home/user/"
+        with mock.patch("builtins.open", mock.mock_open(read_data=file_sample)) as mock_open:
+            results = get_samples_from_ped_file(dataset)
+            mock_flat_files.assert_called_once_with("mapping")
+            mock_open.assert_called_once_with("/home/user/n_1.ped", "r")
+            self.assertEqual(
+                ["Expected_1", "Expected_2", "Expected_3"], results)
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.plink_mapping.get_samples_from_ped_file")
+    def test_gen_pheno_txt_file_plink(self, mock_samples):
+        """test for getting gen_pheno txt file"""
+        mock_samples.return_value = ["Expected_1", "Expected_2", "Expected_3"]
+
+        trait = AttributeSetter({"name": "TX"})
+        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
+        vals = ["value=K1", "value=K2", "value=K3"]
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+            results = gen_pheno_txt_file_plink(this_trait=trait, dataset=dataset,
+                                               vals=vals, pheno_filename="ph_file")
+            mock_open.assert_called_once_with(
+                "/home/user/data/ph_file.txt", "wb")
+            filehandler = mock_open()
+            calls_expected = [mock.call('FID\tIID\tTX\n'),
+                              mock.call('Expected_1\tExpected_1\tK1\nExpected_2\tExpected_2\tK2\nExpected_3\tExpected_3\tK3\n')]
+
+            filehandler.write.assert_has_calls(calls_expected)
+
+            filehandler.close.assert_called_once()
+
+    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
+    @mock.patch("wqflask.marker_regression.plink_mapping.build_line_list")
+    def test_parse_plink_output(self, mock_line_list):
+        """test for parsing plink output"""
+        chromosomes = [0, 34, 110, 89, 123, 23, 2]
+        species = AttributeSetter(
+            {"name": "S1", "chromosomes": AttributeSetter({"chromosomes": chromosomes})})
+
+        fake_file = """0 AACCAT T98.6  0.89\n2  AATA  B45  0.3\n121  ACG  B56.4 NA"""
+
+        mock_line_list.side_effect = [["0", "AACCAT", "T98.6", "0.89"], [
+            "2", "AATA", "B45", "0.3"], ["121", "ACG", "B56.4", "NA"]]
+        with mock.patch("builtins.open", mock.mock_open(read_data=fake_file)) as mock_open:
+            parse_results = parse_plink_output(
+                output_filename="P1_file", species=species)
+            mock_open.assert_called_once_with(
+                "/home/user/data/P1_file.qassoc", "rb")
+            expected = (2, {'AACCAT': 0.89, 'AATA': 0.3})
+
+            self.assertEqual(parse_results, expected)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
new file mode 100644
index 00000000..b47f877a
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -0,0 +1,21 @@
+import unittest
+from unittest import  mock
+from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
+
+#issues some methods in genofile object are not defined
+#modify samples should equal to vals
+class TestQtlReaperMapping(unittest.TestCase):
+	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
+	def  test_gen_pheno_txt_file(self):                   
+		vals=["V1","x","V4","V3","x"]
+		samples=["S1","S2","S3","S4","S5"]
+		trait_filename="trait_file"
+		with mock.patch("builtins.open", mock.mock_open())as mock_open:
+			gen_pheno_txt_file(samples=samples,vals=vals,trait_filename=trait_filename)
+			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt","w")
+			filehandler=mock_open()
+			write_calls= [mock.call('Trait\t'),mock.call('S1\tS3\tS4\n'),mock.call('T1\t'),mock.call('V1\tV4\tV3')]
+
+			filehandler.write.assert_has_calls(write_calls)
+
+	                                                                                                                    
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
new file mode 100644
index 00000000..69f53721
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -0,0 +1,48 @@
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
+from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
+
+class TestRqtlMapping(unittest.TestCase):
+
+	def setUp(self):
+		self.app_context=app.app_context()
+		self.app_context.push()
+
+	def tearDown(self):
+		self.app_context.pop()
+
+
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
+	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
+	def test_get_trait_data(self,mock_logger,mock_db):
+		"""test for getting trait data_type return True"""
+		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+		results=get_trait_data_type("traid_id")
+		mock_db.db.execute.assert_called_with(caller_value)
+		self.assertEqual(results,"fer434f")
+
+	def test_sanitize_rqtl_phenotype(self):
+		"""test for sanitizing rqtl phenotype"""
+		vals=['f',"x","r","x","x"]
+		results=sanitize_rqtl_phenotype(vals)
+		expected_phenotype_string='c(f,NA,r,NA,NA)'
+
+		self.assertEqual(results,expected_phenotype_string)
+
+	def test_sanitize_rqtl_names(self):
+		"""test for sanitzing rqtl names"""
+		vals=['f',"x","r","x","x"]
+		expected_sanitized_name="c('f',NA,'r',NA,NA)"
+		results=sanitize_rqtl_names(vals)
+		self.assertEqual(expected_sanitized_name,results)
+
+
+		
+		
+
+
+
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
new file mode 100644
index 00000000..4129cc0c
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -0,0 +1,284 @@
+import unittest
+import datetime
+from unittest import mock
+
+from wqflask.marker_regression.run_mapping import get_genofile_samplelist
+from wqflask.marker_regression.run_mapping import geno_db_exists
+from wqflask.marker_regression.run_mapping import write_input_for_browser
+from wqflask.marker_regression.run_mapping import export_mapping_results
+from wqflask.marker_regression.run_mapping import trim_markers_for_figure
+from wqflask.marker_regression.run_mapping import get_perm_strata
+from wqflask.marker_regression.run_mapping import get_chr_lengths
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for k, v in obj.items():
+            setattr(self, k, v)
+
+
+class MockGroup(AttributeSetter):
+
+    def get_genofiles(self):
+        return [{"location": "~/genofiles/g1_file", "sample_list": ["S1", "S2", "S3", "S4"]}]
+
+
+class TestRunMapping(unittest.TestCase):
+    def setUp(self):
+
+        self.group = MockGroup(
+            {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
+        chromosomes = {
+            "3": AttributeSetter({
+                "name": "C1",
+                "length": "0.04"
+            }),
+            "4": AttributeSetter({
+                "name": "C2",
+                "length": "0.03"
+            }),
+            "5": AttributeSetter({
+                "name": "C4",
+                "length": "0.01"
+            })
+        }
+        self.dataset = AttributeSetter(
+            {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
+
+        self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
+        self.trait = AttributeSetter(
+            {"symbol": "IGFI", "chr": "X1", "mb": 123313})
+
+    def tearDown(self):
+        self.dataset = AttributeSetter(
+            {"group": {"location": "~/genofiles/g1_file"}})
+
+    def test_get_genofile_samplelist(self):
+
+        results_1 = get_genofile_samplelist(self.dataset)
+        self.assertEqual(results_1, ["S1", "S2", "S3", "S4"])
+        self.group.genofile = "~/genofiles/g2_file"
+        result_2 = get_genofile_samplelist(self.dataset)
+        self.assertEqual(result_2, [])
+
+    @mock.patch("wqflask.marker_regression.run_mapping.data_set")
+    def test_if_geno_db_exists(self, mock_data_set):
+        mock_data_set.create_dataset.side_effect = [
+            AttributeSetter({}), Exception()]
+        results_no_error = geno_db_exists(self.dataset)
+        results_with_error = geno_db_exists(self.dataset)
+
+        self.assertEqual(mock_data_set.create_dataset.call_count, 2)
+        self.assertEqual(results_with_error, "False")
+        self.assertEqual(results_no_error, "True")
+
+    def test_trim_markers_for_figure(self):
+
+        markers = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "lod_score":0.5
+        },
+            {
+            "name": "MK2",
+            "chr": "C2",
+            "cM": "15",
+            "Mb": "10000",
+            "genotypes": [],
+            "lod_score":0.7
+        },
+            {
+            "name": "MK1",
+            "chr": "C3",
+            "cM": "45",
+            "Mb": "1",
+            "genotypes": [],
+            "dominance":"Tt",
+            "additive":"VE",
+            "lod_score":1
+        }]
+
+        marker_2 = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "p_wald":4.6
+        }]
+        results = trim_markers_for_figure(markers)
+        result_2 = trim_markers_for_figure(marker_2)
+        expected = [
+            {
+                "name": "MK1",
+                "chr": "C1",
+                "cM": "1",
+                "Mb": "12000",
+                "genotypes": [],
+                "dominance":"TT",
+                "additive":"VA",
+                "lod_score":0.5
+            },
+            {
+                "name": "MK1",
+                "chr": "C3",
+                "cM": "45",
+                "Mb": "1",
+                "genotypes": [],
+                "dominance":"Tt",
+                "additive":"VE",
+                "lod_score":1
+            }
+
+        ]
+        self.assertEqual(results, expected)
+        self.assertEqual(result_2, marker_2)
+
+    def test_export_mapping_results(self):
+        """test for exporting mapping results"""
+        datetime_mock = mock.Mock(wraps=datetime.datetime)
+        datetime_mock.now.return_value = datetime.datetime(
+            2019, 9, 1, 10, 12, 12)
+
+        markers = [{
+            "name": "MK1",
+            "chr": "C1",
+            "cM": "1",
+            "Mb": "12000",
+            "genotypes": [],
+            "dominance":"TT",
+            "additive":"VA",
+            "lod_score":3
+        },
+            {
+            "name": "MK2",
+            "chr": "C2",
+            "cM": "15",
+            "Mb": "10000",
+            "genotypes": [],
+            "lod_score":7
+        },
+            {
+            "name": "MK1",
+            "chr": "C3",
+            "cM": "45",
+            "Mb": "1",
+            "genotypes": [],
+            "dominance":"Tt",
+            "additive":"VE",
+            "lod_score":7
+        }]
+
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+
+            with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
+                export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
+                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)")
+
+                write_calls = [
+                    mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
+                    mock.call('Population: Human GP1_\n'), mock.call(
+                        'Data Set: dataser_1\n'),
+                    mock.call('Gene Symbol: IGFI\n'), mock.call(
+                        'Location: X1 @ 123313 Mb\n'),
+                    mock.call('\n'), mock.call('Name,Chr,'),
+                    mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
+                    mock.call(',Additive'), mock.call(',Dominance'),
+                    mock.call('\n'), mock.call('MK1,C1,'),
+                    mock.call('12000,'), mock.call('1,'),
+                    mock.call('3'), mock.call(',VA'),
+                    mock.call(',TT'), mock.call('\n'),
+                    mock.call('MK2,C2,'), mock.call('10000,'),
+                    mock.call('15,'), mock.call('7'),
+                    mock.call('\n'), mock.call('MK1,C3,'),
+                    mock.call('1,'), mock.call('45,'),
+                    mock.call('7'), mock.call(',VE'),
+                    mock.call(',Tt')
+
+                ]
+                mock_open.assert_called_once_with("~/results", "w+")
+                filehandler = mock_open()
+                filehandler.write.assert_has_calls(write_calls)
+
+    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
+    def test_write_input_for_browser(self, mock_choice):
+        """test for writing input for browser"""
+        mock_choice.side_effect = ["F", "i", "l", "e", "s", "x"]
+        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
+            expected = ['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
+
+            results = write_input_for_browser(
+                this_dataset=self.dataset, gwas_results={}, annotations={})
+            self.assertEqual(results, expected)
+
+    def test_get_perm_strata(self):
+        categorical_vars = ["C1", "C2", "W1"]
+        used_samples = ["S1", "S2"]
+        sample_list = AttributeSetter({"sample_attribute_values": {
+            "S1": {
+                "C1": "c1_value",
+                "C2": "c2_value",
+                "W1": "w1_value"
+
+            },
+            "S2": {
+                "W1": "w2_value",
+                "W2": "w2_value"
+
+            },
+            "S3": {
+
+                "C1": "c1_value",
+                "C2": "c2_value"
+
+            },
+
+        }})
+
+        results = get_perm_strata(this_trait={}, sample_list=sample_list,
+                                  categorical_vars=categorical_vars, used_samples=used_samples)
+        self.assertEqual(results, [2, 1])
+
+    def test_get_chr_length(self):
+        """test for getting chromosome length"""
+        chromosomes = AttributeSetter({"chromosomes": self.chromosomes})
+        dataset = AttributeSetter({"species": chromosomes})
+        results = get_chr_lengths(
+            mapping_scale="physic", mapping_method="reaper", dataset=dataset, qtl_results=[])
+        chr_lengths = []
+        for key, chromo in self.chromosomes.chromosomes.items():
+            chr_lengths.append({"chr": chromo.name, "size": chromo.length})
+
+        self.assertEqual(chr_lengths, results)
+
+        qtl_results = [{
+            "chr": "16",
+            "cM": "0.2"
+        },
+            {
+            "chr": "12",
+            "cM": "0.5"
+        },
+            {
+            "chr": "18",
+            "cM": "0.1"
+        },
+            {
+            "chr": "22",
+            "cM": "0.4"
+        },
+        ]
+
+        result_with_other_mapping_scale = get_chr_lengths(
+            mapping_scale="other", mapping_method="reaper", dataset=dataset, qtl_results=qtl_results)
+        expected_value = [{'chr': '1', 'size': '0'}, {
+            'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
+
+        self.assertEqual(result_with_other_mapping_scale, expected_value)
diff --git a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
deleted file mode 100644
index 4fafd95a..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_gemma_mapping.py
+++ /dev/null
@@ -1,205 +0,0 @@
-# test for wqflask/marker_regression/gemma_mapping.py
-import unittest
-import random
-from unittest import mock
-from wqflask.marker_regression.gemma_mapping import run_gemma
-from wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file
-from wqflask.marker_regression.gemma_mapping import gen_covariates_file
-from wqflask.marker_regression.gemma_mapping import parse_gemma_output
-from wqflask.marker_regression.gemma_mapping import parse_loco_output
-
-
-class AttributeSetter:
-    def __init__(self, obj):
-        for key, val in obj.items():
-            setattr(self, key, val)
-
-
-class MockDatasetGroup(AttributeSetter):
-    def get_samplelist(self):
-        return None
-
-
-class TestGemmaMapping(unittest.TestCase):
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
-    def test_run_gemma_firstrun_set_false(self, mock_parse_loco):
-        """add tests for gemma function where  first run is set to false"""
-        dataset = AttributeSetter(
-            {"group": AttributeSetter({"genofile": "genofile.geno"})})
-
-        output_file = "file1"
-        mock_parse_loco.return_value = []
-        this_trait = AttributeSetter({"name": "t1"})
-
-        result = run_gemma(this_trait=this_trait, this_dataset=dataset, samples=[], vals=[
-        ], covariates="", use_loco=True, first_run=False, output_files=output_file)
-
-        expected_results = ([], "file1")
-        self.assertEqual(expected_results, result)
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMAOPTS", "-debug")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data/")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.logger")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
-    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
-        """add tests for run_gemma where first run is set to true"""
-        chromosomes = []
-        for i in range(1, 5):
-            chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
-        chromo = AttributeSetter({"chromosomes": chromosomes})
-        dataset_group = MockDatasetGroup(
-            {"name": "GP1", "genofile": "file_geno"})
-        dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
-                                   "species": AttributeSetter({"chromosomes": chromo})})
-        trait = AttributeSetter({"name": "trait1"})
-        samples = []
-        mock_gen_pheno_txt.return_value = None
-        mock_os.path.isfile.return_value = True
-        mock_gen_covar.return_value = None
-        mock_choice.return_value = "R"
-        mock_flat_files.return_value = "/home/genotype/bimbam"
-        mock_parse_loco.return_value = []
-        results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
-        ], vals=[], covariates="", use_loco=True)
-        system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
-                        mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
-        mock_os.system.assert_has_calls(system_calls)
-        mock_gen_pheno_txt.assert_called_once()
-        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
-        mock_os.path.isfile.assert_called_once_with(
-            ('/home/user/imgfile_output.assoc.txt'))
-        self.assertEqual(mock_logger.debug.call_count, 2)
-        self.assertEqual(mock_flat_files.call_count, 4)
-        self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data")
-    def test_gen_pheno_txt_file(self):
-        """add tests for generating pheno txt file"""
-        with mock.patch("builtins.open", mock.mock_open())as mock_open:
-            gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
-                               "x", "w", "q", "we", "R"], trait_filename="fitr.re")
-            mock_open.assert_called_once_with(
-                '/home/user/data/gn2/fitr.re.txt', 'w')
-            filehandler = mock_open()
-            values = ["x", "w", "q", "we", "R"]
-            write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call(
-                'q\n'), mock.call('we\n'), mock.call('R\n')]
-
-            filehandler.write.assert_has_calls(write_calls)
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.create_trait")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.create_dataset")
-    def test_gen_covariates_file(self, create_dataset, create_trait, flat_files):
-        """add tests for generating covariates files"""
-        covariates = "X1:X2,Y1:Y2,M1:M3,V1:V2"
-        samplelist = ["X1", "X2", "X3", "X4"]
-        create_dataset_side_effect = []
-        create_trait_side_effect = []
-
-        for i in range(4):
-            create_dataset_side_effect.append(AttributeSetter({"name": f'name_{i}'}))
-            create_trait_side_effect.append(
-                AttributeSetter({"data": [f'data_{i}']}))
-
-        create_dataset.side_effect = create_trait_side_effect
-        create_trait.side_effect = create_trait_side_effect
-
-        group = MockDatasetGroup({"name": "group_X", "samplelist": samplelist})
-        this_dataset = AttributeSetter({"group": group})
-        flat_files.return_value = "Home/Genenetwork"
-
-        with mock.patch("builtins.open", mock.mock_open())as mock_open:
-            gen_covariates_file(this_dataset=this_dataset, covariates=covariates,
-                                samples=["x1", "x2", "X3"])
-
-            create_dataset.assert_has_calls(
-                [mock.call('X2'), mock.call('Y2'), mock.call('M3'), mock.call('V2')])
-            mock_calls = []
-            trait_names = ["X1", "Y1", "M1", "V1"]
-
-            for i, trait in enumerate(create_trait_side_effect):
-                mock_calls.append(
-                    mock.call(dataset=trait, name=trait_names[i], cellid=None))
-
-            create_trait.assert_has_calls(mock_calls)
-
-            flat_files.assert_called_once_with('mapping')
-            mock_open.assert_called_once_with(
-                'Home/Genenetwork/group_X_covariates.txt', 'w')
-            filehandler = mock_open()
-            filehandler.write.assert_has_calls([mock.call(
-                '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
-    def test_parse_gemma_output(self):
-        """add test for generating gemma output with obj returned"""
-        file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-chr\tgn1\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7
-X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
-125\tgn9\t433575\tQ\tE\tA\tP\tMMB\tCDE\t0.67
-"""
-        with mock.patch("builtins.open", mock.mock_open(read_data=file)) as mock_open:
-            results = parse_gemma_output(genofile_name="gema_file")
-            expected = [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812},
-                        {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
-            mock_open.assert_called_once_with(
-                "/home/user/img/gema_file_output.assoc.txt")
-            self.assertEqual(results, expected)
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
-    def test_parse_gemma_output_with_empty_return(self):
-        """add tests for parse gemma output where nothing returned"""
-        output_file_results = """chr\t today"""
-        with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
-            results = parse_gemma_output(genofile_name="gema_file")
-            self.assertEqual(results, [])
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.json")
-    def test_parse_loco_outputfile_found(self, mock_json, mock_os):
-        """add tests for parse loco output file found"""
-        mock_json.load.return_value = {
-            "files": [["file_name", "user", "~/file1"],
-                      ["file_name", "user", "~/file2"]]
-        }
-        return_file_1 = """X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-X/Y\tL2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
-        return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
-        mock_os.path.isfile.return_value = True
-        file_to_write = """{"files":["file_1","file_2"]}"""
-        with mock.patch("builtins.open") as mock_open:
-
-            handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open(
-                read_data=return_file_1).return_value, mock.mock_open(read_data=return_file_2).return_value)
-            mock_open.side_effect = handles
-            results = parse_loco_output(
-                this_dataset={}, gwa_output_filename=".xw/")
-            expected_results = [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {
-                'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
-
-            self.assertEqual(expected_results, results)
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.os")
-    def test_parse_loco_outputfile_not_found(self, mock_os):
-        """add tests for parse loco output where  output file not found"""
-
-        mock_os.path.isfile.return_value = False
-        file_to_write = """{"files":["file_1","file_2"]}"""
-
-        with mock.patch("builtins.open", mock.mock_open(read_data=file_to_write)) as mock_open:
-            results = parse_loco_output(
-                this_dataset={}, gwa_output_filename=".xw/")
-            self.assertEqual(results, [])
diff --git a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
deleted file mode 100644
index 428f45b9..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_plink_mapping.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# test for wqflask/marker_regression/plink_mapping.py
-import unittest
-from unittest import mock
-from wqflask.marker_regression.plink_mapping import build_line_list
-from wqflask.marker_regression.plink_mapping import get_samples_from_ped_file
-from wqflask.marker_regression.plink_mapping import flat_files
-from wqflask.marker_regression.plink_mapping import gen_pheno_txt_file_plink
-from wqflask.marker_regression.plink_mapping import parse_plink_output
-
-
-class AttributeSetter:
-    def __init__(self, obj):
-        for key, val in obj.items():
-            setattr(self, key, val)
-class TestPlinkMapping(unittest.TestCase):
-
-    def test_build_line_list(self):
-        """testing for building line list"""
-        line_1 = "this is line one test"
-        irregular_line = "  this     is an, irregular line     "
-        exp_line1 = ["this", "is", "line", "one", "test"]
-
-        results = build_line_list(irregular_line)
-        self.assertEqual(exp_line1, build_line_list(line_1))
-        self.assertEqual([], build_line_list())
-        self.assertEqual(["this", "is", "an,", "irregular", "line"], results)
-
-    @mock.patch("wqflask.marker_regression.plink_mapping.flat_files")
-    def test_get_samples_from_ped_file(self, mock_flat_files):
-        """test for getting samples from ped file"""
-        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
-        file_sample = """Expected_1\tline test
-Expected_2\there
-  Expected_3\tthree"""
-        mock_flat_files.return_value = "/home/user/"
-        with mock.patch("builtins.open", mock.mock_open(read_data=file_sample)) as mock_open:
-            results = get_samples_from_ped_file(dataset)
-            mock_flat_files.assert_called_once_with("mapping")
-            mock_open.assert_called_once_with("/home/user/n_1.ped", "r")
-            self.assertEqual(
-                ["Expected_1", "Expected_2", "Expected_3"], results)
-
-    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
-    @mock.patch("wqflask.marker_regression.plink_mapping.get_samples_from_ped_file")
-    def test_gen_pheno_txt_file_plink(self, mock_samples):
-        """test for getting gen_pheno txt file"""
-        mock_samples.return_value = ["Expected_1", "Expected_2", "Expected_3"]
-
-        trait = AttributeSetter({"name": "TX"})
-        dataset = AttributeSetter({"group": AttributeSetter({"name": "n_1"})})
-        vals = ["value=K1", "value=K2", "value=K3"]
-        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
-            results = gen_pheno_txt_file_plink(this_trait=trait, dataset=dataset,
-                                               vals=vals, pheno_filename="ph_file")
-            mock_open.assert_called_once_with(
-                "/home/user/data/ph_file.txt", "wb")
-            filehandler = mock_open()
-            calls_expected = [mock.call('FID\tIID\tTX\n'),
-                              mock.call('Expected_1\tExpected_1\tK1\nExpected_2\tExpected_2\tK2\nExpected_3\tExpected_3\tK3\n')]
-
-            filehandler.write.assert_has_calls(calls_expected)
-
-            filehandler.close.assert_called_once()
-
-    @mock.patch("wqflask.marker_regression.plink_mapping.TMPDIR", "/home/user/data/")
-    @mock.patch("wqflask.marker_regression.plink_mapping.build_line_list")
-    def test_parse_plink_output(self, mock_line_list):
-        """test for parsing plink output"""
-        chromosomes = [0, 34, 110, 89, 123, 23, 2]
-        species = AttributeSetter(
-            {"name": "S1", "chromosomes": AttributeSetter({"chromosomes": chromosomes})})
-
-        fake_file = """0 AACCAT T98.6  0.89\n2  AATA  B45  0.3\n121  ACG  B56.4 NA"""
-
-        mock_line_list.side_effect = [["0", "AACCAT", "T98.6", "0.89"], [
-            "2", "AATA", "B45", "0.3"], ["121", "ACG", "B56.4", "NA"]]
-        with mock.patch("builtins.open", mock.mock_open(read_data=fake_file)) as mock_open:
-            parse_results = parse_plink_output(
-                output_filename="P1_file", species=species)
-            mock_open.assert_called_once_with(
-                "/home/user/data/P1_file.qassoc", "rb")
-            expected = (2, {'AACCAT': 0.89, 'AATA': 0.3})
-
-            self.assertEqual(parse_results, expected)
diff --git a/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
deleted file mode 100644
index b47f877a..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import unittest
-from unittest import  mock
-from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
-
-#issues some methods in genofile object are not defined
-#modify samples should equal to vals
-class TestQtlReaperMapping(unittest.TestCase):
-	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
-	def  test_gen_pheno_txt_file(self):                   
-		vals=["V1","x","V4","V3","x"]
-		samples=["S1","S2","S3","S4","S5"]
-		trait_filename="trait_file"
-		with mock.patch("builtins.open", mock.mock_open())as mock_open:
-			gen_pheno_txt_file(samples=samples,vals=vals,trait_filename=trait_filename)
-			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt","w")
-			filehandler=mock_open()
-			write_calls= [mock.call('Trait\t'),mock.call('S1\tS3\tS4\n'),mock.call('T1\t'),mock.call('V1\tV4\tV3')]
-
-			filehandler.write.assert_has_calls(write_calls)
-
-	                                                                                                                    
diff --git a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
deleted file mode 100644
index 69f53721..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_rqtl_mapping.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import unittest
-from unittest import mock
-from wqflask import app
-from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
-from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
-from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
-
-class TestRqtlMapping(unittest.TestCase):
-
-	def setUp(self):
-		self.app_context=app.app_context()
-		self.app_context.push()
-
-	def tearDown(self):
-		self.app_context.pop()
-
-
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-	def test_get_trait_data(self,mock_logger,mock_db):
-		"""test for getting trait data_type return True"""
-		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
-		results=get_trait_data_type("traid_id")
-		mock_db.db.execute.assert_called_with(caller_value)
-		self.assertEqual(results,"fer434f")
-
-	def test_sanitize_rqtl_phenotype(self):
-		"""test for sanitizing rqtl phenotype"""
-		vals=['f',"x","r","x","x"]
-		results=sanitize_rqtl_phenotype(vals)
-		expected_phenotype_string='c(f,NA,r,NA,NA)'
-
-		self.assertEqual(results,expected_phenotype_string)
-
-	def test_sanitize_rqtl_names(self):
-		"""test for sanitzing rqtl names"""
-		vals=['f',"x","r","x","x"]
-		expected_sanitized_name="c('f',NA,'r',NA,NA)"
-		results=sanitize_rqtl_names(vals)
-		self.assertEqual(expected_sanitized_name,results)
-
-
-		
-		
-
-
-
diff --git a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
deleted file mode 100644
index a134f551..00000000
--- a/wqflask/tests/wqflask/marker_regression/test_run_mapping.py
+++ /dev/null
@@ -1,284 +0,0 @@
-import unittest
-import datetime
-from unittest import mock
-
-from wqflask.marker_regression.run_mapping import get_genofile_samplelist
-from wqflask.marker_regression.run_mapping import geno_db_exists
-from wqflask.marker_regression.run_mapping import write_input_for_browser
-from wqflask.marker_regression.run_mapping import export_mapping_results
-from wqflask.marker_regression.run_mapping import trim_markers_for_figure
-from wqflask.marker_regression.run_mapping import get_perm_strata
-from wqflask.marker_regression.run_mapping import get_chr_lengths
-
-
-class AttributeSetter:
-    def __init__(self, obj):
-        for k, v in obj.items():
-            setattr(self, k, v)
-
-
-class MockDataSetGroup(AttributeSetter):
-
-    def get_genofiles(self):
-        return [{"location": "~/genofiles/g1_file", "sample_list": ["S1", "S2", "S3", "S4"]}]
-
-
-class TestRunMapping(unittest.TestCase):
-    def setUp(self):
-
-        self.group = MockDataSetGroup(
-            {"genofile": "~/genofiles/g1_file", "name": "GP1_", "species": "Human"})
-        chromosomes = {
-            "3": AttributeSetter({
-                "name": "C1",
-                "length": "0.04"
-            }),
-            "4": AttributeSetter({
-                "name": "C2",
-                "length": "0.03"
-            }),
-            "5": AttributeSetter({
-                "name": "C4",
-                "length": "0.01"
-            })
-        }
-        self.dataset = AttributeSetter(
-            {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
-
-        self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
-        self.trait = AttributeSetter(
-            {"symbol": "IGFI", "chr": "X1", "mb": 123313})
-
-    def tearDown(self):
-        self.dataset = AttributeSetter(
-            {"group": {"location": "~/genofiles/g1_file"}})
-
-    def test_get_genofile_samplelist(self):
-
-        results_1 = get_genofile_samplelist(self.dataset)
-        self.assertEqual(results_1, ["S1", "S2", "S3", "S4"])
-        self.group.genofile = "~/genofiles/g2_file"
-        result_2 = get_genofile_samplelist(self.dataset)
-        self.assertEqual(result_2, [])
-
-    @mock.patch("wqflask.marker_regression.run_mapping.data_set")
-    def test_if_geno_db_exists(self, mock_data_set):
-        mock_data_set.create_dataset.side_effect = [
-            AttributeSetter({}), Exception()]
-        results_no_error = geno_db_exists(self.dataset)
-        results_with_error = geno_db_exists(self.dataset)
-
-        self.assertEqual(mock_data_set.create_dataset.call_count, 2)
-        self.assertEqual(results_with_error, "False")
-        self.assertEqual(results_no_error, "True")
-
-    def test_trim_markers_for_figure(self):
-
-        markers = [{
-            "name": "MK1",
-            "chr": "C1",
-            "cM": "1",
-            "Mb": "12000",
-            "genotypes": [],
-            "dominance":"TT",
-            "additive":"VA",
-            "lod_score":0.5
-        },
-            {
-            "name": "MK2",
-            "chr": "C2",
-            "cM": "15",
-            "Mb": "10000",
-            "genotypes": [],
-            "lod_score":0.7
-        },
-            {
-            "name": "MK1",
-            "chr": "C3",
-            "cM": "45",
-            "Mb": "1",
-            "genotypes": [],
-            "dominance":"Tt",
-            "additive":"VE",
-            "lod_score":1
-        }]
-
-        marker_2 = [{
-            "name": "MK1",
-            "chr": "C1",
-            "cM": "1",
-            "Mb": "12000",
-            "genotypes": [],
-            "dominance":"TT",
-            "additive":"VA",
-            "p_wald":4.6
-        }]
-        results = trim_markers_for_figure(markers)
-        result_2 = trim_markers_for_figure(marker_2)
-        expected = [
-            {
-                "name": "MK1",
-                "chr": "C1",
-                "cM": "1",
-                "Mb": "12000",
-                "genotypes": [],
-                "dominance":"TT",
-                "additive":"VA",
-                "lod_score":0.5
-            },
-            {
-                "name": "MK1",
-                "chr": "C3",
-                "cM": "45",
-                "Mb": "1",
-                "genotypes": [],
-                "dominance":"Tt",
-                "additive":"VE",
-                "lod_score":1
-            }
-
-        ]
-        self.assertEqual(results, expected)
-        self.assertEqual(result_2, marker_2)
-
-    def test_export_mapping_results(self):
-        """test for exporting mapping results"""
-        datetime_mock = mock.Mock(wraps=datetime.datetime)
-        datetime_mock.now.return_value = datetime.datetime(
-            2019, 9, 1, 10, 12, 12)
-
-        markers = [{
-            "name": "MK1",
-            "chr": "C1",
-            "cM": "1",
-            "Mb": "12000",
-            "genotypes": [],
-            "dominance":"TT",
-            "additive":"VA",
-            "lod_score":3
-        },
-            {
-            "name": "MK2",
-            "chr": "C2",
-            "cM": "15",
-            "Mb": "10000",
-            "genotypes": [],
-            "lod_score":7
-        },
-            {
-            "name": "MK1",
-            "chr": "C3",
-            "cM": "45",
-            "Mb": "1",
-            "genotypes": [],
-            "dominance":"Tt",
-            "additive":"VE",
-            "lod_score":7
-        }]
-
-        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
-
-            with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
-                export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
-                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)")
-
-                write_calls = [
-                    mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
-                    mock.call('Population: Human GP1_\n'), mock.call(
-                        'Data Set: dataser_1\n'),
-                    mock.call('Gene Symbol: IGFI\n'), mock.call(
-                        'Location: X1 @ 123313 Mb\n'),
-                    mock.call('\n'), mock.call('Name,Chr,'),
-                    mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
-                    mock.call(',Additive'), mock.call(',Dominance'),
-                    mock.call('\n'), mock.call('MK1,C1,'),
-                    mock.call('12000,'), mock.call('1,'),
-                    mock.call('3'), mock.call(',VA'),
-                    mock.call(',TT'), mock.call('\n'),
-                    mock.call('MK2,C2,'), mock.call('10000,'),
-                    mock.call('15,'), mock.call('7'),
-                    mock.call('\n'), mock.call('MK1,C3,'),
-                    mock.call('1,'), mock.call('45,'),
-                    mock.call('7'), mock.call(',VE'),
-                    mock.call(',Tt')
-
-                ]
-                mock_open.assert_called_once_with("~/results", "w+")
-                filehandler = mock_open()
-                filehandler.write.assert_has_calls(write_calls)
-
-    @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
-    def test_write_input_for_browser(self, mock_choice):
-        """test for writing input for browser"""
-        mock_choice.side_effect = ["F", "i", "l", "e", "s", "x"]
-        with mock.patch("builtins.open", mock.mock_open()) as mock_open:
-            expected = ['GP1__Filesx_GWAS', 'GP1__Filesx_ANNOT']
-
-            results = write_input_for_browser(
-                this_dataset=self.dataset, gwas_results={}, annotations={})
-            self.assertEqual(results, expected)
-
-    def test_get_perm_strata(self):
-        categorical_vars = ["C1", "C2", "W1"]
-        used_samples = ["S1", "S2"]
-        sample_list = AttributeSetter({"sample_attribute_values": {
-            "S1": {
-                "C1": "c1_value",
-                "C2": "c2_value",
-                "W1": "w1_value"
-
-            },
-            "S2": {
-                "W1": "w2_value",
-                "W2": "w2_value"
-
-            },
-            "S3": {
-
-                "C1": "c1_value",
-                "C2": "c2_value"
-
-            },
-
-        }})
-
-        results = get_perm_strata(this_trait={}, sample_list=sample_list,
-                                  categorical_vars=categorical_vars, used_samples=used_samples)
-        self.assertEqual(results, [2, 1])
-
-    def test_get_chr_length(self):
-        """test for getting chromosome length"""
-        chromosomes = AttributeSetter({"chromosomes": self.chromosomes})
-        dataset = AttributeSetter({"species": chromosomes})
-        results = get_chr_lengths(
-            mapping_scale="physic", mapping_method="reaper", dataset=dataset, qtl_results=[])
-        chr_lengths = []
-        for key, chromo in self.chromosomes.chromosomes.items():
-            chr_lengths.append({"chr": chromo.name, "size": chromo.length})
-
-        self.assertEqual(chr_lengths, results)
-
-        qtl_results = [{
-            "chr": "16",
-            "cM": "0.2"
-        },
-            {
-            "chr": "12",
-            "cM": "0.5"
-        },
-            {
-            "chr": "18",
-            "cM": "0.1"
-        },
-            {
-            "chr": "22",
-            "cM": "0.4"
-        },
-        ]
-
-        result_with_other_mapping_scale = get_chr_lengths(
-            mapping_scale="other", mapping_method="reaper", dataset=dataset, qtl_results=qtl_results)
-        expected_value = [{'chr': '1', 'size': '0'}, {
-            'chr': '16', 'size': '500000.0'}, {'chr': '18', 'size': '400000.0'}]
-
-        self.assertEqual(result_with_other_mapping_scale, expected_value)
-- 
cgit v1.2.3


From c96c1db5660367f1f86cfa76309c87866e79bf79 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Sat, 28 Nov 2020 16:23:53 +0300
Subject: modify test for plink mapping and  rqtl_mapping

---
 wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py | 3 ++-
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py  | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
index 428f45b9..5eec93f1 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -14,8 +14,9 @@ class AttributeSetter:
             setattr(self, key, val)
 class TestPlinkMapping(unittest.TestCase):
 
+
     def test_build_line_list(self):
-        """testing for building line list"""
+        """test for building line list"""
         line_1 = "this is line one test"
         irregular_line = "  this     is an, irregular line     "
         exp_line1 = ["this", "is", "line", "one", "test"]
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 69f53721..c585f1df 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -19,10 +19,10 @@ class TestRqtlMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
 	def test_get_trait_data(self,mock_logger,mock_db):
 		"""test for getting trait data_type return True"""
-		caller_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+		query_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
 		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
 		results=get_trait_data_type("traid_id")
-		mock_db.db.execute.assert_called_with(caller_value)
+		mock_db.db.execute.assert_called_with(query_value)
 		self.assertEqual(results,"fer434f")
 
 	def test_sanitize_rqtl_phenotype(self):
-- 
cgit v1.2.3


From 6b885b0b4dcdfed744b1996bd767bb9f20fdf633 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Sat, 5 Dec 2020 13:35:43 +0300
Subject: modify tests for run_gemma

---
 .../unit/wqflask/marker_regression/test_gemma_mapping.py      | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index 5b621264..3d00dd7c 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -43,18 +43,18 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.gemma_mapping.GEMMA_WRAPPER_COMMAND", "ghc")
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/user/data/")
     @mock.patch("wqflask.marker_regression.gemma_mapping.parse_loco_output")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.logger")
     @mock.patch("wqflask.marker_regression.gemma_mapping.flat_files")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_covariates_file")
     @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_logger, mock_parse_loco):
+    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files,mock_parse_loco):
         """add tests for run_gemma where first run is set to true"""
-        chromosomes = []
+        this_chromosomes={}
         for i in range(1, 5):
-            chromosomes.append(AttributeSetter({"name": f"CH{i}"}))
-        chromo = AttributeSetter({"chromosomes": chromosomes})
+            this_chromosomes[f'CH{i}']=(AttributeSetter({"name": f"CH{i}"}))
+        chromo = AttributeSetter({"chromosomes": this_chromosomes})
+
         dataset_group = MockGroup(
             {"name": "GP1", "genofile": "file_geno"})
         dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
@@ -76,7 +76,6 @@ class TestGemmaMapping(unittest.TestCase):
         mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
         mock_os.path.isfile.assert_called_once_with(
             ('/home/user/imgfile_output.assoc.txt'))
-        self.assertEqual(mock_logger.debug.call_count, 2)
         self.assertEqual(mock_flat_files.call_count, 4)
         self.assertEqual(results, ([], "GP1_GWA_RRRRRR"))
 
-- 
cgit v1.2.3


From 54fc88f3f0f4966608fccdba76b49871eef50553 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Sat, 5 Dec 2020 13:43:23 +0300
Subject: add pep8 formatting

---
 wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index 3d00dd7c..b8c13ab4 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -53,12 +53,12 @@ class TestGemmaMapping(unittest.TestCase):
         this_chromosomes={}
         for i in range(1, 5):
             this_chromosomes[f'CH{i}']=(AttributeSetter({"name": f"CH{i}"}))
-        chromo = AttributeSetter({"chromosomes": this_chromosomes})
+        chromosomes = AttributeSetter({"chromosomes": this_chromosomes})
 
         dataset_group = MockGroup(
             {"name": "GP1", "genofile": "file_geno"})
         dataset = AttributeSetter({"group": dataset_group, "name": "dataset1_name",
-                                   "species": AttributeSetter({"chromosomes": chromo})})
+                                   "species": AttributeSetter({"chromosomes": chromosomes})})
         trait = AttributeSetter({"name": "trait1"})
         samples = []
         mock_gen_pheno_txt.return_value = None
-- 
cgit v1.2.3


From d080436fa5640522c45b1d8bb90e9ca20ba06d5d Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Thu, 17 Dec 2020 01:26:47 +0300
Subject: remove  test for parse_gemma_output  and modify run_gemma tests
 (#533)

---
 .../marker_regression/test_gemma_mapping.py        | 32 ++--------------------
 1 file changed, 2 insertions(+), 30 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index b8c13ab4..eab6afe6 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -5,7 +5,6 @@ from unittest import mock
 from wqflask.marker_regression.gemma_mapping import run_gemma
 from wqflask.marker_regression.gemma_mapping import gen_pheno_txt_file
 from wqflask.marker_regression.gemma_mapping import gen_covariates_file
-from wqflask.marker_regression.gemma_mapping import parse_gemma_output
 from wqflask.marker_regression.gemma_mapping import parse_loco_output
 
 
@@ -69,11 +68,9 @@ class TestGemmaMapping(unittest.TestCase):
         mock_parse_loco.return_value = []
         results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
         ], vals=[], covariates="", use_loco=True)
-        system_calls = [mock.call('ghc --json -- -debug -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt -a /home/genotype/bimbam/file_snps.txt -gk > /home/user/data//gn2/GP1_K_RRRRRR.json'),
-                        mock.call('ghc --json --input /home/user/data//gn2/GP1_K_RRRRRR.json -- -debug -a /home/genotype/bimbam/file_snps.txt -lmm 2 -g /home/genotype/bimbam/file_geno.txt -p /home/user/data//gn2/trait1_dataset1_name_pheno.txt > /home/user/data//gn2/GP1_GWA_RRRRRR.json')]
-        mock_os.system.assert_has_calls(system_calls)
+        self.assertEqual(mock_os.system.call_count,2)
         mock_gen_pheno_txt.assert_called_once()
-        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR")
+        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR",True)
         mock_os.path.isfile.assert_called_once_with(
             ('/home/user/imgfile_output.assoc.txt'))
         self.assertEqual(mock_flat_files.call_count, 4)
@@ -138,31 +135,6 @@ class TestGemmaMapping(unittest.TestCase):
             filehandler.write.assert_has_calls([mock.call(
                 '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
 
-    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img/")
-    def test_parse_gemma_output(self):
-        """add test for generating gemma output with obj returned"""
-        file = """X/Y\t gn2\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-X/Y\tgn2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-chr\tgn1\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7
-X\tgn7\t2324424\tQ\tE\tA\tP\tMMB\tCDE\t0.4
-125\tgn9\t433575\tQ\tE\tA\tP\tMMB\tCDE\t0.67
-"""
-        with mock.patch("builtins.open", mock.mock_open(read_data=file)) as mock_open:
-            results = parse_gemma_output(genofile_name="gema_file")
-            expected = [{'name': ' gn2', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {'name': 'gn2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812},
-                        {'name': 'gn7', 'chr': 'X', 'Mb': 2.324424, 'p_value': 0.4, 'lod_score': 0.3979400086720376}, {'name': 'gn9', 'chr': 125, 'Mb': 0.433575, 'p_value': 0.67, 'lod_score': 0.17392519729917352}]
-            mock_open.assert_called_once_with(
-                "/home/user/img/gema_file_output.assoc.txt")
-            self.assertEqual(results, expected)
-
-    @mock.patch("wqflask.marker_regression.gemma_mapping.webqtlConfig.GENERATED_IMAGE_DIR", "/home/user/img")
-    def test_parse_gemma_output_with_empty_return(self):
-        """add tests for parse gemma output where nothing returned"""
-        output_file_results = """chr\t today"""
-        with mock.patch("builtins.open", mock.mock_open(read_data=output_file_results)) as mock_open:
-            results = parse_gemma_output(genofile_name="gema_file")
-            self.assertEqual(results, [])
-
     @mock.patch("wqflask.marker_regression.gemma_mapping.TEMPDIR", "/home/tmp")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.json")
-- 
cgit v1.2.3


From dd2c510ea09ea3169cac3685b299640226d5606a Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Sun, 27 Dec 2020 23:17:36 +0300
Subject: update tests for run gemma

---
 .../wqflask/marker_regression/test_gemma_mapping.py   | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index eab6afe6..fe2569b8 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -144,21 +144,26 @@ class TestGemmaMapping(unittest.TestCase):
             "files": [["file_name", "user", "~/file1"],
                       ["file_name", "user", "~/file2"]]
         }
-        return_file_1 = """X/Y\t L1\t21\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-X/Y\tL2\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5
-chr\tL3\t12312\tQ\tE\tA\tP\tMMB\tCDE\t0.7"""
-        return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5"""
+        return_file="""X/Y\tM1\t28.457155\tQ\tE\tA\tMMB\t23.3\tW\t0.9\t0.85\t
+chr4\tM2\t12\tQ\tE\tMMB\tR\t24\tW\t0.87\t0.5
+Y\tM4\t12\tQ\tE\tMMB\tR\t11.6\tW\t0.21\t0.7
+X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
+
+        return_file_2 = """chr\tother\t21322\tQ\tE\tA\tP\tMMB\tCDE\t0.5\t0.4"""
         mock_os.path.isfile.return_value = True
         file_to_write = """{"files":["file_1","file_2"]}"""
         with mock.patch("builtins.open") as mock_open:
 
             handles = (mock.mock_open(read_data="gwas").return_value, mock.mock_open(
-                read_data=return_file_1).return_value, mock.mock_open(read_data=return_file_2).return_value)
+                read_data=return_file).return_value, mock.mock_open(read_data=return_file_2).return_value)
             mock_open.side_effect = handles
             results = parse_loco_output(
                 this_dataset={}, gwa_output_filename=".xw/")
-            expected_results = [{'name': ' L1', 'chr': 'X/Y', 'Mb': 2.1e-05, 'p_value': 0.5, 'lod_score': 0.3010299956639812}, {
-                'name': 'L2', 'chr': 'X/Y', 'Mb': 0.021322, 'p_value': 0.5, 'lod_score': 0.3010299956639812}]
+            expected_results= [
+            {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85, 'additive': 23.3, 'lod_score': 0.07058107428570727},
+            {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5, 'additive': 24.0, 'lod_score': 0.3010299956639812},
+            {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7, 'additive': 11.6, 'lod_score': 0.1549019599857432},
+            {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': 21.1, 'lod_score': 0.22184874961635637}]
 
             self.assertEqual(expected_results, results)
 
-- 
cgit v1.2.3


From 7032f7b05deac0bbd2e868ffd3fe42dd1c97fb7d Mon Sep 17 00:00:00 2001
From: uditgulati
Date: Tue, 5 Jan 2021 13:14:08 -0600
Subject: add server side class unit tests

---
 wqflask/tests/unit/wqflask/test_server_side.py | 31 ++++++++++++++++++++++++++
 wqflask/wqflask/server_side.py                 | 16 ++++++-------
 2 files changed, 39 insertions(+), 8 deletions(-)
 create mode 100644 wqflask/tests/unit/wqflask/test_server_side.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
new file mode 100644
index 00000000..4f91d8ca
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -0,0 +1,31 @@
+import unittest
+
+from wqflask.server_side import ServerSideTable
+
+
+class TestServerSideTableTests(unittest.TestCase):
+    """
+    Test the ServerSideTable class
+
+    test table:
+        first, second, third
+        'd', 4, 'zz'
+        'b', 2, 'aa'
+        'c', 1, 'ss'
+    """
+
+    def test_get_page(self):
+        rows_count = 3
+        table_rows = [
+            {'first': 'd', 'second': 4, 'third': 'zz'}, 
+            {'first': 'b', 'second': 2, 'third': 'aa'}, 
+            {'first': 'c', 'second': 1, 'third': 'ss'},
+        ]
+        headers = ['first', 'second', 'third']
+        request_args = {'sEcho': '1', 'iSortCol_0': '1', 'iSortingCols': '1', 'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'}
+
+        test_page = ServerSideTable(rows_count, table_rows, headers, request_args).get_page()
+        self.assertEqual(test_page['sEcho'], '1')
+        self.assertEqual(test_page['iTotalRecords'], 'nan')
+        self.assertEqual(test_page['iTotalDisplayRecords'], '3')
+        self.assertEqual(test_page['data'], [{'first': 'b', 'second': 2, 'third': 'aa'}, {'first': 'c', 'second': 1, 'third': 'ss'}, {'first': 'd', 'second': 4, 'third': 'zz'}])
diff --git a/wqflask/wqflask/server_side.py b/wqflask/wqflask/server_side.py
index 824b00aa..5f764767 100644
--- a/wqflask/wqflask/server_side.py
+++ b/wqflask/wqflask/server_side.py
@@ -3,7 +3,7 @@
 
 
 class ServerSideTable(object):
-    '''
+    """
         This class is used to do server-side processing
         on the DataTables table such as paginating, sorting,
         filtering(not implemented) etc. This takes the load off
@@ -22,7 +22,7 @@ class ServerSideTable(object):
 
         Have a look at snp_browser_table() function in 
         wqflask/wqflask/views.py for reference use.
-    '''
+    """
 
     def __init__(self, rows_count, table_rows, header_data_names, request_values):
         self.request_values = request_values
@@ -36,12 +36,12 @@ class ServerSideTable(object):
         self.paginate_rows()
 
     def sort_rows(self):
-        '''
+        """
         Sorts the rows taking in to account the column (or columns) that the
         user has selected.
-        '''
+        """
         def is_reverse(str_direction):
-            ''' Maps the 'desc' and 'asc' words to True or False. '''
+            """ Maps the 'desc' and 'asc' words to True or False. """
             return True if str_direction == 'desc' else False
 
         if (self.request_values['iSortCol_0'] != "") and (int(self.request_values['iSortingCols']) > 0):
@@ -54,12 +54,12 @@ class ServerSideTable(object):
                               reverse=is_reverse(sort_direction))
 
     def paginate_rows(self):
-        '''
+        """
         Selects a subset of the filtered and sorted data based on if the table
         has pagination, the current page and the size of each page.
-        '''
+        """
         def requires_pagination():
-            ''' Check if the table is going to be paginated '''
+            """ Check if the table is going to be paginated """
             if self.request_values['iDisplayStart'] != "":
                 if int(self.request_values['iDisplayLength']) != -1:
                     return True
-- 
cgit v1.2.3


From 2bd74f8f4e4e72a11c77d4f3e8532c303503ca11 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 16 Nov 2020 13:46:57 +0300
Subject: add unit tests for api/mapping.py

---
 wqflask/tests/unit/wqflask/api/test_mapping.py | 114 +++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/api/test_mapping.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
new file mode 100644
index 00000000..87b18e84
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -0,0 +1,114 @@
+import unittest
+from unittest import mock
+from wqflask.api.mapping import initialize_parameters
+
+
+class AttributeSetter:
+	def __init__(self,obj):
+		for key,value in obj.items():
+			setattr(self,key,value)
+
+class MockGroup(AttributeSetter):
+	def get_marker(self):
+		return None
+class TestMock(unittest.TestCase):
+	
+ #    @mock.patch("wqflask.api.mapping.gemma_mapping")
+ #    @mock.patch("wqflask.api.mapping.nitialize_parameters")
+ #    @mock.patch("wqflask.api.mapping.retrieve_sample_data")
+ #    @mock.patch("wqflask.api.mapping.create_trait")
+ #    @mock.patch("wqflask.api.mapping.data_set")
+	# def test_do_mapping_for_api(self,mock_dataset,mock_create_trait,mock_retrieve_data,mock_gemma):
+
+		# start_vars={
+		# "db":"sql_uri/db_web1",
+		# "trait_id":"idsui332rh3ui2t",
+		# "limit_to":32.1,
+		# }
+		# group_samplelist=["S1","S2","S3","S4"]
+		# dataset_group=MockGroup({"samplelist":group_samplelist})
+		# dataset=AttributeSetter({"type":"Temp","group":dataset_group})
+
+		# this_trait_data={
+		#   "Item1":AttributeSetter({
+		#     "name":"S1",
+		#     "value":"V1"
+		#   }),
+
+		#   "Item2":AttributeSetter({
+		#     "name":"S2",
+		#     "value":"V2"
+		#   }),
+
+		#   "Item3":AttributeSetter({
+		#     "name":"SX",
+		#     "value":"VX"
+		#   })
+		# }
+
+		# this_trait=AttributeSetter({"data":this_trait_data})
+
+
+		# mock_dataset.create_dataset.return_value=dataset
+
+		# mock_create_trait.return_value=this_trait
+		# mock_retrieve_data.return_value=this_trait
+
+		# mock_initialize_params={
+		#  "format":"json",
+		#   "limit_to":32.1,
+		#   "mapping_method":"gemma",
+		#   "maf":0.01,
+		#   "use_loco":True,
+		#   "num_perm":0,
+		#   "perm_check":False
+
+		# }
+
+		# mock_gemma.return_value=[ ,"filename"]
+		# pass
+
+	def test_initialize_parameters(self):
+		expected_results={
+		 "format":"json",
+		 "limit_to":False,
+		 "mapping_method":"gemma",
+		 "maf":0.01,
+		 "use_loco":True,
+		 "num_perm":0,
+		 "perm_check":False
+		}
+
+		results=initialize_parameters(start_vars={},dataset={},this_trait={})
+		self.assertEqual(results,expected_results)
+
+		start_vars={
+		"format":"F1",
+		"limit_to":"1",
+		"mapping_method":"rqtl",
+		"control_marker":True,
+		"pair_scan":"true",
+		"interval_mapping":"true",
+		"use_loco":"true",
+		"num_perm":"14"
+
+		}
+
+		results_2=initialize_parameters(start_vars=start_vars,dataset={},this_trait={})
+		expected_results={
+		"format":"F1",
+		"limit_to":1,
+		"mapping_method":"gemma",
+		"maf":0.01,
+		"use_loco":True,
+		"num_perm":14,
+		"perm_check":"ON"
+		}
+
+		self.assertEqual(results_2,expected_results)
+		
+
+
+
+
+
-- 
cgit v1.2.3


From df2c3f9ee43dd055f7766eedee32d76090ad80b2 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Mon, 16 Nov 2020 13:47:40 +0300
Subject: add unit testsfor api/correlation.py

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 83 ++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/api/test_correlation.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
new file mode 100644
index 00000000..482dec67
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -0,0 +1,83 @@
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.api.correlation import init_corr_params
+from wqflask.api.correlation import convert_to_mouse_gene_id
+from wqflask.api.correlation import do_literature_correlation_for_all_traits
+
+
+class AttributeSetter:
+    def __init__(self, obj):
+        for k, v in obj.items():
+            setattr(self, k, v)
+
+
+class TestCorrelations(unittest.TestCase):
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    def test_init_corr_params(self):
+        start_vars = {
+            "return_count": "3",
+            "type": "T1",
+            "method": "spearman"
+        }
+
+        corr_params_results = init_corr_params(start_vars=start_vars)
+        expected_results = {
+            "return_count": 3,
+            "type": "T1",
+            "method": "spearman"
+        }
+
+        self.assertEqual(corr_params_results, expected_results)
+
+    @mock.patch("wqflask.api.correlation.g")
+    def test_convert_to_mouse_gene_id(self, mock_db):
+
+        results = convert_to_mouse_gene_id(species="Other", gene_id="")
+        self.assertEqual(results, None)
+
+        rat_species_results = convert_to_mouse_gene_id(
+            species="rat", gene_id="GH1")
+
+        mock_db.db.execute.return_value.fetchone.side_effect = [AttributeSetter({"mouse": "MG-1"}),AttributeSetter({"mouse":"MG-2"})]
+                                          
+        self.assertEqual(convert_to_mouse_gene_id(
+            species="mouse", gene_id="MG-4"), "MG-4")
+        self.assertEqual(convert_to_mouse_gene_id(
+            species="rat", gene_id="R1"), "MG-1")
+        self.assertEqual(convert_to_mouse_gene_id(
+            species="human", gene_id="H1"), "MG-2")
+
+    
+    
+    @mock.patch("wqflask.api.correlation.g")
+    @mock.patch("wqflask.api.correlation.convert_to_mouse_gene_id")
+    def test_do_literature_correlation_for_all_traits(self,mock_convert_to_mouse_geneid,mock_db):
+    	mock_convert_to_mouse_geneid.side_effect=["MG-1","MG-2;","MG-3","MG-4"]
+   
+
+    	trait_geneid_dict={
+    	 "TT-1":"GH-1",
+    	 "TT-2":"GH-2",
+    	 "TT-3":"GH-3"
+
+    	}
+    	mock_db.db.execute.return_value.fetchone.side_effect=[AttributeSetter({"value":"V1"}),AttributeSetter({"value":"V2"}),AttributeSetter({"value":"V3"})]
+
+
+    	this_trait=AttributeSetter({"geneid":"GH-1"})
+
+    	target_dataset=AttributeSetter({"group":AttributeSetter({"species":"rat"})})
+    	results=do_literature_correlation_for_all_traits(this_trait=this_trait,target_dataset=target_dataset,trait_geneid_dict=trait_geneid_dict,corr_params={})
+
+    	expected_results={'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 'V1'], 'TT-3': ['GH-3', 'V2']}
+    	self.assertEqual(results,expected_results)
+
+
+
-- 
cgit v1.2.3


From 3eda2b13e10937cbd661d6d411286c5b84bcd7cf Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sat, 28 Nov 2020 15:00:00 +0300
Subject: add correlation test

---
 .../correlation/test_correlation_functions.py      | 21 +++++
 .../wqflask/correlation/test_show_corr_results.py  | 95 ++++++++++++++++++++++
 2 files changed, 116 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
 create mode 100644 wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
new file mode 100644
index 00000000..db449eb1
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -0,0 +1,21 @@
+import unittest
+from unittest import mock
+from wqflask.correlation.correlation_functions import get_trait_symbol_and_tissue_values
+from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_tiss
+
+
+class TestCorrelationFunctions(unittest.TestCase):
+
+
+    @mock.patch("wqflask.correlation.correlation_functions.MrnaAssayTissueData")
+    def test_get_trait_symbol_and_tissue_values(self, mock_class):
+        """test for getting trait symbol and tissue_values"""
+        mock_class_instance = mock_class.return_value
+        mock_class_instance.gene_symbols = ["k1", "k2", "k3"]
+        mock_class_instance.get_symbol_values_pairs.return_value = {
+            "k1": ["v1", "v2", "v3"], "k2": ["v2", "v3"], "k3": ["k3"]}
+        results = get_trait_symbol_and_tissue_values(
+            symbol_list=["k1", "k2", "k3"])
+        mock_class.assert_called_with(gene_symbols=['k1', 'k2', 'k3'])
+        self.assertEqual({"k1": ["v1", "v2", "v3"], "k2": [
+                         "v2", "v3"], "k3": ["k3"]}, results)
diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
new file mode 100644
index 00000000..4e63207e
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -0,0 +1,95 @@
+import unittest
+from unittest import mock
+from wqflask.correlation.show_corr_results import get_header_fields
+from wqflask.correlation.show_corr_results import generate_corr_json
+from wqflask.correlation.show_corr_results import do_bicor
+
+
+class Trait:
+	def __init__(self,trait_obj):
+		for key,value in trait_obj.items():
+			setattr(self,key,value)
+
+class TestShowCorrResults(unittest.TestCase):
+
+	def test_process_samples(self):
+		pass
+	def test_get_header_fields(self):
+		expected=[
+		                    ['Index',
+                                'Record',
+                                'Symbol',
+                                'Description',
+                                'Location',
+                                'Mean',
+                                'Sample rho',
+                                'N',
+                                'Sample p(rho)',
+                                'Lit rho',
+                                'Tissue rho',
+                                'Tissue p(rho)',
+                                'Max LRS',
+                                'Max LRS Location',
+                                'Additive Effect'],
+
+                            ['Index',
+                                 'ID',
+                                 'Location',
+                                 'Sample r',
+                                 'N',
+                                 'Sample p(r)']
+
+		]
+		result1=get_header_fields("ProbeSet","spearman")
+		result2=get_header_fields("Other","Other")
+		self.assertEqual(result1,expected[0])
+		self.assertEqual(result2,expected[1])
+
+
+
+
+	def test_generate_corr_json(self):
+		this_trait=Trait({"name":"trait_test"})
+		dataset=Trait({"name":"the_name"})
+		target_dataset=Trait({"type":"Publish"})
+	
+		trait_with_publish={
+		"description_display":"Trait 2 description",
+		"authors":"trait_2 ",
+		"pubmed_id":"34n4nn31hn43",
+		"lrs_location":"N/A",
+		"additive":"",
+		"sample_r":100,
+		"num_overlap":3.2,
+		"view":True,
+		"name":"trait_1",
+		"pubmed_text":"2016",
+		"additive":"",
+		"sample_r":10.5,
+		"LRS_score_repr":"N/A",
+		"LRS_location_repr":"N/A",
+		"sample_p":5,
+		"num_overlap":"num_1"
+
+
+
+		}
+		expected_results="""[{"trait_id": "trait_1", "description": "Trait 2 description", "authors": "trait_2 ", "pubmed_id": "34n4nn31hn43", "year": "2016", "lrs_score": "N/A", "lrs_location": "N/A", "additive": "N/A", "sample_r": "10.500", "num_overlap": "num_1", "sample_p": "5.000e+00"}]"""
+
+		corr_results=[Trait(trait_with_publish)]
+		results=generate_corr_json(corr_results=corr_results,this_trait=this_trait,dataset=dataset,target_dataset=target_dataset,for_api=True)
+		self.assertEqual(results,expected_results)
+		
+		
+
+	def test_generate_corr_json_view_false(self):
+		trait=Trait({"view":False})
+		corr_results=[trait]
+		this_trait=Trait({"name":"trait_test"})
+		dataset=Trait({"name":"the_name"})
+		
+
+		results_where_view_is_false=generate_corr_json(corr_results=corr_results,this_trait=this_trait,dataset={},target_dataset={},for_api=False)
+
+		# self.assertEqual(results,[])
+		self.assertEqual(results_where_view_is_false,"[]")
\ No newline at end of file
-- 
cgit v1.2.3


From 1666f8d50df090e9a14dbf0f4f195bac079de058 Mon Sep 17 00:00:00 2001
From: Alexanderlacuna
Date: Sat, 28 Nov 2020 15:11:06 +0300
Subject: add test in   api/mapping

---
 wqflask/tests/unit/wqflask/api/test_mapping.py | 55 --------------------------
 1 file changed, 55 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
index 87b18e84..4da1725f 100644
--- a/wqflask/tests/unit/wqflask/api/test_mapping.py
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -13,61 +13,6 @@ class MockGroup(AttributeSetter):
 		return None
 class TestMock(unittest.TestCase):
 	
- #    @mock.patch("wqflask.api.mapping.gemma_mapping")
- #    @mock.patch("wqflask.api.mapping.nitialize_parameters")
- #    @mock.patch("wqflask.api.mapping.retrieve_sample_data")
- #    @mock.patch("wqflask.api.mapping.create_trait")
- #    @mock.patch("wqflask.api.mapping.data_set")
-	# def test_do_mapping_for_api(self,mock_dataset,mock_create_trait,mock_retrieve_data,mock_gemma):
-
-		# start_vars={
-		# "db":"sql_uri/db_web1",
-		# "trait_id":"idsui332rh3ui2t",
-		# "limit_to":32.1,
-		# }
-		# group_samplelist=["S1","S2","S3","S4"]
-		# dataset_group=MockGroup({"samplelist":group_samplelist})
-		# dataset=AttributeSetter({"type":"Temp","group":dataset_group})
-
-		# this_trait_data={
-		#   "Item1":AttributeSetter({
-		#     "name":"S1",
-		#     "value":"V1"
-		#   }),
-
-		#   "Item2":AttributeSetter({
-		#     "name":"S2",
-		#     "value":"V2"
-		#   }),
-
-		#   "Item3":AttributeSetter({
-		#     "name":"SX",
-		#     "value":"VX"
-		#   })
-		# }
-
-		# this_trait=AttributeSetter({"data":this_trait_data})
-
-
-		# mock_dataset.create_dataset.return_value=dataset
-
-		# mock_create_trait.return_value=this_trait
-		# mock_retrieve_data.return_value=this_trait
-
-		# mock_initialize_params={
-		#  "format":"json",
-		#   "limit_to":32.1,
-		#   "mapping_method":"gemma",
-		#   "maf":0.01,
-		#   "use_loco":True,
-		#   "num_perm":0,
-		#   "perm_check":False
-
-		# }
-
-		# mock_gemma.return_value=[ ,"filename"]
-		# pass
-
 	def test_initialize_parameters(self):
 		expected_results={
 		 "format":"json",
-- 
cgit v1.2.3


From e535eeeff92bcfa6d6524e44591164de72d38482 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Fri, 4 Dec 2020 18:43:35 +0300
Subject: add test for map_api in api/test_mapping.py

---
 wqflask/tests/unit/wqflask/api/test_mapping.py | 145 +++++++++++++++++--------
 1 file changed, 99 insertions(+), 46 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
index 4da1725f..5455b215 100644
--- a/wqflask/tests/unit/wqflask/api/test_mapping.py
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -1,57 +1,110 @@
 import unittest
 from unittest import mock
 from wqflask.api.mapping import initialize_parameters
+from wqflask.api.mapping import do_mapping_for_api
 
 
 class AttributeSetter:
-	def __init__(self,obj):
-		for key,value in obj.items():
-			setattr(self,key,value)
+    def __init__(self,obj):
+        for key,value in obj.items():
+            setattr(self,key,value)
 
 class MockGroup(AttributeSetter):
-	def get_marker(self):
-		return None
-class TestMock(unittest.TestCase):
-	
-	def test_initialize_parameters(self):
-		expected_results={
-		 "format":"json",
-		 "limit_to":False,
-		 "mapping_method":"gemma",
-		 "maf":0.01,
-		 "use_loco":True,
-		 "num_perm":0,
-		 "perm_check":False
-		}
-
-		results=initialize_parameters(start_vars={},dataset={},this_trait={})
-		self.assertEqual(results,expected_results)
-
-		start_vars={
-		"format":"F1",
-		"limit_to":"1",
-		"mapping_method":"rqtl",
-		"control_marker":True,
-		"pair_scan":"true",
-		"interval_mapping":"true",
-		"use_loco":"true",
-		"num_perm":"14"
-
-		}
-
-		results_2=initialize_parameters(start_vars=start_vars,dataset={},this_trait={})
-		expected_results={
-		"format":"F1",
-		"limit_to":1,
-		"mapping_method":"gemma",
-		"maf":0.01,
-		"use_loco":True,
-		"num_perm":14,
-		"perm_check":"ON"
-		}
-
-		self.assertEqual(results_2,expected_results)
-		
+    def get_marker(self):
+        self.markers=[]
+class TestMapping(unittest.TestCase):
+    
+    def test_initialize_parameters(self):
+        expected_results={
+         "format":"json",
+         "limit_to":False,
+         "mapping_method":"gemma",
+         "maf":0.01,
+         "use_loco":True,
+         "num_perm":0,
+         "perm_check":False
+        }
+
+        results=initialize_parameters(start_vars={},dataset={},this_trait={})
+        self.assertEqual(results,expected_results)
+
+        start_vars={
+        "format":"F1",
+        "limit_to":"1",
+        "mapping_method":"rqtl",
+        "control_marker":True,
+        "pair_scan":"true",
+        "interval_mapping":"true",
+        "use_loco":"true",
+        "num_perm":"14"
+
+        }
+
+        results_2=initialize_parameters(start_vars=start_vars,dataset={},this_trait={})
+        expected_results={
+        "format":"F1",
+        "limit_to":1,
+        "mapping_method":"gemma",
+        "maf":0.01,
+        "use_loco":True,
+        "num_perm":14,
+        "perm_check":"ON"
+        }
+
+        self.assertEqual(results_2,expected_results)
+
+    
+    @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl_geno")
+    @mock.patch("wqflask.api.mapping.gemma_mapping.run_gemma")
+    @mock.patch("wqflask.api.mapping.initialize_parameters")
+    @mock.patch("wqflask.api.mapping.retrieve_sample_data")
+    @mock.patch("wqflask.api.mapping.create_trait")
+    @mock.patch("wqflask.api.mapping.data_set.create_dataset")
+    def test_do_mapping_for_api(self,mock_create_dataset,mock_trait,mock_retrieve_sample,mock_param,run_gemma
+        ,run_rqtl_geno):
+        start_vars={
+        "db":"Temp",
+        "trait_id":"dewf3232rff2",
+        "format":"F1",
+        "mapping_method":"gemma",
+        "use_loco":True
+
+        }
+        sampleList=["S1","S2","S3","S4"]
+        samplelist=["S1","S2","S4"]
+        dataset=AttributeSetter({"group":samplelist})
+        this_trait=AttributeSetter({})
+        trait_data=AttributeSetter({
+            "data":{
+            "item1":AttributeSetter({"name":"S1","value":"S1_value"}),
+            "item2":AttributeSetter({"name":"S2","value":"S2_value"}),
+            "item3":AttributeSetter({"name":"S3","value":"S3_value"}),
+
+            }
+            })
+        trait=AttributeSetter({
+            "data":trait_data
+            })
+
+        dataset.return_value=dataset
+        mock_trait.return_value=this_trait
+
+        mock_retrieve_sample.return_value=trait
+        mock_param.return_value={
+        "format":"F1",
+        "limit_to":False,
+        "mapping_method":"gemma",
+        "maf":0.01,
+        "use_loco":"True",
+        "num_perm":14,
+        "perm_check":"ON"
+        }
+
+        run_gemma.return_value=["results"]
+        results=do_mapping_for_api(start_vars=start_vars)
+        self.assertEqual(results,("results",None))
+
+        
 
 
 
-- 
cgit v1.2.3


From e80e793455d2fc6b51dbe95414a3ba8e72652a83 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Sat, 12 Dec 2020 21:21:53 +0300
Subject: add tests for getting sample_r and p values

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 38 ++++++++++++++++++++++
 .../wqflask/correlation/test_show_corr_results.py  |  2 --
 2 files changed, 38 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index 482dec67..077f7fa9 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -4,6 +4,7 @@ from wqflask import app
 from wqflask.api.correlation import init_corr_params
 from wqflask.api.correlation import convert_to_mouse_gene_id
 from wqflask.api.correlation import do_literature_correlation_for_all_traits
+from wqflask.api.correlation import get_sample_r_and_p_values
 
 
 class AttributeSetter:
@@ -79,5 +80,42 @@ class TestCorrelations(unittest.TestCase):
     	expected_results={'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 'V1'], 'TT-3': ['GH-3', 'V2']}
     	self.assertEqual(results,expected_results)
 
+    @mock.patch("wqflask.api.correlation.corr_result_helpers.normalize_values")
+    def test_get_sample_r_and_p_values(self,mock_normalize):
+
+        group=AttributeSetter({"samplelist":["S1","S2","S3","S4","S5","S6","S7"]})
+        target_dataset=AttributeSetter({"group":group})
+
+        target_vals=[3.4, 6.2, 4.1,3.4,1.2,5.6]
+        trait_data={"S1":AttributeSetter({"value":2.3}),"S2":AttributeSetter({"value":1.1}),"S3":AttributeSetter({"value":6.3}),"S4":AttributeSetter({"value":3.6}),"S5":AttributeSetter({"value":4.1}),"S6":AttributeSetter({"value":5.0})}
+        this_trait=AttributeSetter({"data":trait_data})
+        mock_normalize.return_value=([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6)
+        mock_normalize.side_effect=[([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6),([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6),([2.3,1.1,1.4], [3.4,6.2,4.1], 3)]
+
+        results_pearsonr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
+        results_spearmanr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="spearman")
+        results_num_overlap=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
+        self.assertEqual(mock_normalize.call_count,3)
+        
+        self.assertEqual(results_pearsonr,[-0.21618688834430866, 0.680771605997119, 6])
+        self.assertEqual(results_spearmanr,[-0.11595420713048969, 0.826848213385815, 6])
+        self.assertEqual(results_num_overlap,None)
+
+    def test_calculate_results(self):
+        corr_params={
+        "type":"pearson"
+        }
+        trait_data={
+         "T1":3.4,
+         "T2":6.2,
+         "T3":4.1,
+         "T4":3.4,
+         "T5":1.2,
+         "T6":5.6
+        }
+        target_vals=[3.4, 6.2, 4.1,3.4,1.2,5.6]
+
+
+            
 
 
diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
index 4e63207e..969a84f5 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -12,8 +12,6 @@ class Trait:
 
 class TestShowCorrResults(unittest.TestCase):
 
-	def test_process_samples(self):
-		pass
 	def test_get_header_fields(self):
 		expected=[
 		                    ['Index',
-- 
cgit v1.2.3


From 0adae692f2f0ce509b32d6654438213deb3da89b Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Sat, 12 Dec 2020 23:09:04 +0300
Subject: add test for calculating correlation results

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 44 +++++++++++++++-------
 1 file changed, 31 insertions(+), 13 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index 077f7fa9..11c7d82b 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -1,10 +1,12 @@
 import unittest
 from unittest import mock
 from wqflask import app
+from collections import OrderedDict 
 from wqflask.api.correlation import init_corr_params
 from wqflask.api.correlation import convert_to_mouse_gene_id
 from wqflask.api.correlation import do_literature_correlation_for_all_traits
 from wqflask.api.correlation import get_sample_r_and_p_values
+from wqflask.api.correlation import calculate_results
 
 
 class AttributeSetter:
@@ -12,6 +14,17 @@ class AttributeSetter:
         for k, v in obj.items():
             setattr(self, k, v)
 
+class MockDataset(AttributeSetter):
+    def get_trait_data(self):
+        return None
+    def retrieve_genes(self,id=None):
+        return {
+         "TT-1":"GH-1",
+         "TT-2":"GH-2",
+         "TT-3":"GH-3"
+
+        }
+
 
 class TestCorrelations(unittest.TestCase):
     def setUp(self):
@@ -101,19 +114,24 @@ class TestCorrelations(unittest.TestCase):
         self.assertEqual(results_spearmanr,[-0.11595420713048969, 0.826848213385815, 6])
         self.assertEqual(results_num_overlap,None)
 
-    def test_calculate_results(self):
-        corr_params={
-        "type":"pearson"
-        }
-        trait_data={
-         "T1":3.4,
-         "T2":6.2,
-         "T3":4.1,
-         "T4":3.4,
-         "T5":1.2,
-         "T6":5.6
-        }
-        target_vals=[3.4, 6.2, 4.1,3.4,1.2,5.6]
+    @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
+    def test_calculate_results(self,literature_correlation):
+ 
+        literature_correlation.return_value={'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1]}
+
+
+
+        this_dataset=MockDataset({"group":AttributeSetter({"species":"rat"})})
+        target_dataset=MockDataset({"group":AttributeSetter({"species":"rat"})})
+        this_trait=AttributeSetter({"geneid":"GH-1"})
+        corr_params={"type":"literature"}
+        sorted_results=calculate_results(this_trait=this_trait,this_dataset=this_dataset,target_dataset=target_dataset,corr_params=corr_params)
+        expected_results={'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1], 'TT-1': ['GH-1', 0]}
+
+        self.assertTrue(isinstance(sorted_results,OrderedDict))
+        self.assertEqual(type(sorted_results),OrderedDict)
+
+
 
 
             
-- 
cgit v1.2.3


From b7e2d17536febbeb47dc91015781cc6fc4647905 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Sat, 12 Dec 2020 23:36:27 +0300
Subject: replace assertEqual with assertAlmostEqual for floats

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index 11c7d82b..9fa848a4 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -108,10 +108,12 @@ class TestCorrelations(unittest.TestCase):
         results_pearsonr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
         results_spearmanr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="spearman")
         results_num_overlap=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
-        self.assertEqual(mock_normalize.call_count,3)
-        
-        self.assertEqual(results_pearsonr,[-0.21618688834430866, 0.680771605997119, 6])
-        self.assertEqual(results_spearmanr,[-0.11595420713048969, 0.826848213385815, 6])
+        expected_pearsonr=[-0.21618688834430866, 0.680771605997119, 6]
+        expected_spearmanr=[-0.11595420713048969, 0.826848213385815, 6]
+        for i,val in enumerate(expected_pearsonr):
+            self.assertAlmostEqual(val,results_pearsonr[i])
+        for i,val in enumerate(expected_spearmanr):
+            self.assertAlmostEqual(val,results_spearmanr[i])
         self.assertEqual(results_num_overlap,None)
 
     @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
@@ -133,7 +135,6 @@ class TestCorrelations(unittest.TestCase):
 
 
 
-
             
 
 
-- 
cgit v1.2.3


From c3bfc7c07bba06c9334350111df0b9444b85b31b Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Sat, 12 Dec 2020 23:56:26 +0300
Subject: modify tests for calculate correlation results

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index 9fa848a4..cbcd006d 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -131,7 +131,7 @@ class TestCorrelations(unittest.TestCase):
         expected_results={'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1], 'TT-1': ['GH-1', 0]}
 
         self.assertTrue(isinstance(sorted_results,OrderedDict))
-        self.assertEqual(type(sorted_results),OrderedDict)
+        self.assertEqual(dict(sorted_results),expected_results)
 
 
 
-- 
cgit v1.2.3


From d10b6a9bc3ed4d3f824a0dfd115f05ed647aa8c3 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Mon, 14 Dec 2020 20:08:41 +0300
Subject: pep8 formatting and refactoring tests

---
 wqflask/tests/unit/wqflask/api/test_correlation.py | 145 +++++++++++----------
 1 file changed, 79 insertions(+), 66 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index cbcd006d..d0264b87 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -1,7 +1,7 @@
 import unittest
 from unittest import mock
 from wqflask import app
-from collections import OrderedDict 
+from collections import OrderedDict
 from wqflask.api.correlation import init_corr_params
 from wqflask.api.correlation import convert_to_mouse_gene_id
 from wqflask.api.correlation import do_literature_correlation_for_all_traits
@@ -14,14 +14,16 @@ class AttributeSetter:
         for k, v in obj.items():
             setattr(self, k, v)
 
+
 class MockDataset(AttributeSetter):
     def get_trait_data(self):
         return None
-    def retrieve_genes(self,id=None):
+
+    def retrieve_genes(self, id=None):
         return {
-         "TT-1":"GH-1",
-         "TT-2":"GH-2",
-         "TT-3":"GH-3"
+            "TT-1": "GH-1",
+            "TT-2": "GH-2",
+            "TT-3": "GH-3"
 
         }
 
@@ -59,8 +61,9 @@ class TestCorrelations(unittest.TestCase):
         rat_species_results = convert_to_mouse_gene_id(
             species="rat", gene_id="GH1")
 
-        mock_db.db.execute.return_value.fetchone.side_effect = [AttributeSetter({"mouse": "MG-1"}),AttributeSetter({"mouse":"MG-2"})]
-                                          
+        mock_db.db.execute.return_value.fetchone.side_effect = [
+            AttributeSetter({"mouse": "MG-1"}), AttributeSetter({"mouse": "MG-2"})]
+
         self.assertEqual(convert_to_mouse_gene_id(
             species="mouse", gene_id="MG-4"), "MG-4")
         self.assertEqual(convert_to_mouse_gene_id(
@@ -68,73 +71,83 @@ class TestCorrelations(unittest.TestCase):
         self.assertEqual(convert_to_mouse_gene_id(
             species="human", gene_id="H1"), "MG-2")
 
-    
-    
     @mock.patch("wqflask.api.correlation.g")
     @mock.patch("wqflask.api.correlation.convert_to_mouse_gene_id")
-    def test_do_literature_correlation_for_all_traits(self,mock_convert_to_mouse_geneid,mock_db):
-    	mock_convert_to_mouse_geneid.side_effect=["MG-1","MG-2;","MG-3","MG-4"]
-   
-
-    	trait_geneid_dict={
-    	 "TT-1":"GH-1",
-    	 "TT-2":"GH-2",
-    	 "TT-3":"GH-3"
+    def test_do_literature_correlation_for_all_traits(self, mock_convert_to_mouse_geneid, mock_db):
+        mock_convert_to_mouse_geneid.side_effect = [
+            "MG-1", "MG-2;", "MG-3", "MG-4"]
 
-    	}
-    	mock_db.db.execute.return_value.fetchone.side_effect=[AttributeSetter({"value":"V1"}),AttributeSetter({"value":"V2"}),AttributeSetter({"value":"V3"})]
+        trait_geneid_dict = {
+            "TT-1": "GH-1",
+            "TT-2": "GH-2",
+            "TT-3": "GH-3"
 
+        }
+        mock_db.db.execute.return_value.fetchone.side_effect = [AttributeSetter(
+            {"value": "V1"}), AttributeSetter({"value": "V2"}), AttributeSetter({"value": "V3"})]
 
-    	this_trait=AttributeSetter({"geneid":"GH-1"})
+        this_trait = AttributeSetter({"geneid": "GH-1"})
 
-    	target_dataset=AttributeSetter({"group":AttributeSetter({"species":"rat"})})
-    	results=do_literature_correlation_for_all_traits(this_trait=this_trait,target_dataset=target_dataset,trait_geneid_dict=trait_geneid_dict,corr_params={})
+        target_dataset = AttributeSetter(
+            {"group": AttributeSetter({"species": "rat"})})
+        results = do_literature_correlation_for_all_traits(
+            this_trait=this_trait, target_dataset=target_dataset, trait_geneid_dict=trait_geneid_dict, corr_params={})
 
-    	expected_results={'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 'V1'], 'TT-3': ['GH-3', 'V2']}
-    	self.assertEqual(results,expected_results)
+        expected_results = {'TT-1': ['GH-1', 0],
+                            'TT-2': ['GH-2', 'V1'], 'TT-3': ['GH-3', 'V2']}
+        self.assertEqual(results, expected_results)
 
     @mock.patch("wqflask.api.correlation.corr_result_helpers.normalize_values")
-    def test_get_sample_r_and_p_values(self,mock_normalize):
-
-        group=AttributeSetter({"samplelist":["S1","S2","S3","S4","S5","S6","S7"]})
-        target_dataset=AttributeSetter({"group":group})
-
-        target_vals=[3.4, 6.2, 4.1,3.4,1.2,5.6]
-        trait_data={"S1":AttributeSetter({"value":2.3}),"S2":AttributeSetter({"value":1.1}),"S3":AttributeSetter({"value":6.3}),"S4":AttributeSetter({"value":3.6}),"S5":AttributeSetter({"value":4.1}),"S6":AttributeSetter({"value":5.0})}
-        this_trait=AttributeSetter({"data":trait_data})
-        mock_normalize.return_value=([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6)
-        mock_normalize.side_effect=[([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6),([2.3,1.1,6.3,3.6,4.1,5.0], [3.4,6.2,4.1,3.4,1.2,5.6], 6),([2.3,1.1,1.4], [3.4,6.2,4.1], 3)]
-
-        results_pearsonr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
-        results_spearmanr=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="spearman")
-        results_num_overlap=get_sample_r_and_p_values(this_trait=this_trait,this_dataset={},target_vals=target_vals,target_dataset=target_dataset,type="pearson")
-        expected_pearsonr=[-0.21618688834430866, 0.680771605997119, 6]
-        expected_spearmanr=[-0.11595420713048969, 0.826848213385815, 6]
-        for i,val in enumerate(expected_pearsonr):
-            self.assertAlmostEqual(val,results_pearsonr[i])
-        for i,val in enumerate(expected_spearmanr):
-            self.assertAlmostEqual(val,results_spearmanr[i])
-        self.assertEqual(results_num_overlap,None)
+    def test_get_sample_r_and_p_values(self, mock_normalize):
+
+        group = AttributeSetter(
+            {"samplelist": ["S1", "S2", "S3", "S4", "S5", "S6", "S7"]})
+        target_dataset = AttributeSetter({"group": group})
+
+        target_vals = [3.4, 6.2, 4.1, 3.4, 1.2, 5.6]
+        trait_data = {"S1": AttributeSetter({"value": 2.3}), "S2": AttributeSetter({"value": 1.1}), 
+        "S3": AttributeSetter(
+            {"value": 6.3}), "S4": AttributeSetter({"value": 3.6}), "S5": AttributeSetter({"value": 4.1}), 
+        "S6": AttributeSetter({"value": 5.0})}
+        this_trait = AttributeSetter({"data": trait_data})
+        mock_normalize.return_value = ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
+                                       [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6)
+        mock_normalize.side_effect = [([2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
+                                       [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6),
+                                      ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
+                                       [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6),
+                                      ([2.3, 1.1, 1.4], [3.4, 6.2, 4.1], 3)]
+
+        results_pearsonr = get_sample_r_and_p_values(this_trait=this_trait, this_dataset={
+        }, target_vals=target_vals, target_dataset=target_dataset, type="pearson")
+        results_spearmanr = get_sample_r_and_p_values(this_trait=this_trait, this_dataset={
+        }, target_vals=target_vals, target_dataset=target_dataset, type="spearman")
+        results_num_overlap = get_sample_r_and_p_values(this_trait=this_trait, this_dataset={
+        }, target_vals=target_vals, target_dataset=target_dataset, type="pearson")
+        expected_pearsonr = [-0.21618688834430866, 0.680771605997119, 6]
+        expected_spearmanr = [-0.11595420713048969, 0.826848213385815, 6]
+        for i, val in enumerate(expected_pearsonr):
+            self.assertAlmostEqual(val, results_pearsonr[i],4)
+        for i, val in enumerate(expected_spearmanr):
+            self.assertAlmostEqual(val, results_spearmanr[i],4)
+        self.assertEqual(results_num_overlap, None)
 
     @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
-    def test_calculate_results(self,literature_correlation):
- 
-        literature_correlation.return_value={'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1]}
-
-
-
-        this_dataset=MockDataset({"group":AttributeSetter({"species":"rat"})})
-        target_dataset=MockDataset({"group":AttributeSetter({"species":"rat"})})
-        this_trait=AttributeSetter({"geneid":"GH-1"})
-        corr_params={"type":"literature"}
-        sorted_results=calculate_results(this_trait=this_trait,this_dataset=this_dataset,target_dataset=target_dataset,corr_params=corr_params)
-        expected_results={'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1], 'TT-1': ['GH-1', 0]}
-
-        self.assertTrue(isinstance(sorted_results,OrderedDict))
-        self.assertEqual(dict(sorted_results),expected_results)
-
-
-
-            
-
-
+    def test_calculate_results(self, literature_correlation):
+
+        literature_correlation.return_value = {
+            'TT-1': ['GH-1', 0], 'TT-2': ['GH-2', 3], 'TT-3': ['GH-3', 1]}
+
+        this_dataset = MockDataset(
+            {"group": AttributeSetter({"species": "rat"})})
+        target_dataset = MockDataset(
+            {"group": AttributeSetter({"species": "rat"})})
+        this_trait = AttributeSetter({"geneid": "GH-1"})
+        corr_params = {"type": "literature"}
+        sorted_results = calculate_results(
+            this_trait=this_trait, this_dataset=this_dataset, target_dataset=target_dataset, corr_params=corr_params)
+        expected_results = {'TT-2': ['GH-2', 3],
+                            'TT-3': ['GH-3', 1], 'TT-1': ['GH-1', 0]}
+
+        self.assertTrue(isinstance(sorted_results, OrderedDict))
+        self.assertEqual(dict(sorted_results), expected_results)
-- 
cgit v1.2.3


From 4773ac8715896489562df9321b4a4d34ae61d6a7 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Mon, 14 Dec 2020 20:10:37 +0300
Subject: pep8 formatting in wqflask/api/test_mapping.py

---
 wqflask/tests/unit/wqflask/api/test_mapping.py | 154 ++++++++++++-------------
 1 file changed, 75 insertions(+), 79 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
index 5455b215..b094294a 100644
--- a/wqflask/tests/unit/wqflask/api/test_mapping.py
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -5,108 +5,104 @@ from wqflask.api.mapping import do_mapping_for_api
 
 
 class AttributeSetter:
-    def __init__(self,obj):
-        for key,value in obj.items():
-            setattr(self,key,value)
+    def __init__(self, obj):
+        for key, value in obj.items():
+            setattr(self, key, value)
+
 
 class MockGroup(AttributeSetter):
     def get_marker(self):
-        self.markers=[]
+        self.markers = []
+
+
 class TestMapping(unittest.TestCase):
-    
+
     def test_initialize_parameters(self):
-        expected_results={
-         "format":"json",
-         "limit_to":False,
-         "mapping_method":"gemma",
-         "maf":0.01,
-         "use_loco":True,
-         "num_perm":0,
-         "perm_check":False
+        expected_results = {
+            "format": "json",
+            "limit_to": False,
+            "mapping_method": "gemma",
+            "maf": 0.01,
+            "use_loco": True,
+            "num_perm": 0,
+            "perm_check": False
         }
 
-        results=initialize_parameters(start_vars={},dataset={},this_trait={})
-        self.assertEqual(results,expected_results)
+        results = initialize_parameters(
+            start_vars={}, dataset={}, this_trait={})
+        self.assertEqual(results, expected_results)
 
-        start_vars={
-        "format":"F1",
-        "limit_to":"1",
-        "mapping_method":"rqtl",
-        "control_marker":True,
-        "pair_scan":"true",
-        "interval_mapping":"true",
-        "use_loco":"true",
-        "num_perm":"14"
+        start_vars = {
+            "format": "F1",
+            "limit_to": "1",
+            "mapping_method": "rqtl",
+            "control_marker": True,
+            "pair_scan": "true",
+            "interval_mapping": "true",
+            "use_loco": "true",
+            "num_perm": "14"
 
         }
 
-        results_2=initialize_parameters(start_vars=start_vars,dataset={},this_trait={})
-        expected_results={
-        "format":"F1",
-        "limit_to":1,
-        "mapping_method":"gemma",
-        "maf":0.01,
-        "use_loco":True,
-        "num_perm":14,
-        "perm_check":"ON"
+        results_2 = initialize_parameters(
+            start_vars=start_vars, dataset={}, this_trait={})
+        expected_results = {
+            "format": "F1",
+            "limit_to": 1,
+            "mapping_method": "gemma",
+            "maf": 0.01,
+            "use_loco": True,
+            "num_perm": 14,
+            "perm_check": "ON"
         }
 
-        self.assertEqual(results_2,expected_results)
+        self.assertEqual(results_2, expected_results)
 
-    
     @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl_geno")
     @mock.patch("wqflask.api.mapping.gemma_mapping.run_gemma")
     @mock.patch("wqflask.api.mapping.initialize_parameters")
     @mock.patch("wqflask.api.mapping.retrieve_sample_data")
     @mock.patch("wqflask.api.mapping.create_trait")
     @mock.patch("wqflask.api.mapping.data_set.create_dataset")
-    def test_do_mapping_for_api(self,mock_create_dataset,mock_trait,mock_retrieve_sample,mock_param,run_gemma
-        ,run_rqtl_geno):
-        start_vars={
-        "db":"Temp",
-        "trait_id":"dewf3232rff2",
-        "format":"F1",
-        "mapping_method":"gemma",
-        "use_loco":True
+    def test_do_mapping_for_api(self, mock_create_dataset, mock_trait, mock_retrieve_sample, mock_param, run_gemma, run_rqtl_geno):
+        start_vars = {
+            "db": "Temp",
+            "trait_id": "dewf3232rff2",
+            "format": "F1",
+            "mapping_method": "gemma",
+            "use_loco": True
 
         }
-        sampleList=["S1","S2","S3","S4"]
-        samplelist=["S1","S2","S4"]
-        dataset=AttributeSetter({"group":samplelist})
-        this_trait=AttributeSetter({})
-        trait_data=AttributeSetter({
-            "data":{
-            "item1":AttributeSetter({"name":"S1","value":"S1_value"}),
-            "item2":AttributeSetter({"name":"S2","value":"S2_value"}),
-            "item3":AttributeSetter({"name":"S3","value":"S3_value"}),
+        sampleList = ["S1", "S2", "S3", "S4"]
+        samplelist = ["S1", "S2", "S4"]
+        dataset = AttributeSetter({"group": samplelist})
+        this_trait = AttributeSetter({})
+        trait_data = AttributeSetter({
+            "data": {
+                "item1": AttributeSetter({"name": "S1", "value": "S1_value"}),
+                "item2": AttributeSetter({"name": "S2", "value": "S2_value"}),
+                "item3": AttributeSetter({"name": "S3", "value": "S3_value"}),
 
             }
-            })
-        trait=AttributeSetter({
-            "data":trait_data
-            })
-
-        dataset.return_value=dataset
-        mock_trait.return_value=this_trait
-
-        mock_retrieve_sample.return_value=trait
-        mock_param.return_value={
-        "format":"F1",
-        "limit_to":False,
-        "mapping_method":"gemma",
-        "maf":0.01,
-        "use_loco":"True",
-        "num_perm":14,
-        "perm_check":"ON"
+        })
+        trait = AttributeSetter({
+            "data": trait_data
+        })
+
+        dataset.return_value = dataset
+        mock_trait.return_value = this_trait
+
+        mock_retrieve_sample.return_value = trait
+        mock_param.return_value = {
+            "format": "F1",
+            "limit_to": False,
+            "mapping_method": "gemma",
+            "maf": 0.01,
+            "use_loco": "True",
+            "num_perm": 14,
+            "perm_check": "ON"
         }
 
-        run_gemma.return_value=["results"]
-        results=do_mapping_for_api(start_vars=start_vars)
-        self.assertEqual(results,("results",None))
-
-        
-
-
-
-
-
+        run_gemma.return_value = ["results"]
+        results = do_mapping_for_api(start_vars=start_vars)
+        self.assertEqual(results, ("results", None))
-- 
cgit v1.2.3


From 6b6820ec9975ae4c7e9628e0d2b41754b0429b0e Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Wed, 16 Dec 2020 11:29:19 +0300
Subject: modify tests for show_corr_results

---
 wqflask/tests/unit/wqflask/correlation/__init__.py |   0
 .../correlation/test_correlation_functions.py      |   3 +-
 .../wqflask/correlation/test_show_corr_results.py  | 174 +++++++++++----------
 3 files changed, 90 insertions(+), 87 deletions(-)
 create mode 100644 wqflask/tests/unit/wqflask/correlation/__init__.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/correlation/__init__.py b/wqflask/tests/unit/wqflask/correlation/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
index db449eb1..44d2e0fc 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -5,8 +5,7 @@ from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_ti
 
 
 class TestCorrelationFunctions(unittest.TestCase):
-
-
+    
     @mock.patch("wqflask.correlation.correlation_functions.MrnaAssayTissueData")
     def test_get_trait_symbol_and_tissue_values(self, mock_class):
         """test for getting trait symbol and tissue_values"""
diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
index 969a84f5..ffb96dd6 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -2,92 +2,96 @@ import unittest
 from unittest import mock
 from wqflask.correlation.show_corr_results import get_header_fields
 from wqflask.correlation.show_corr_results import generate_corr_json
-from wqflask.correlation.show_corr_results import do_bicor
 
 
-class Trait:
-	def __init__(self,trait_obj):
-		for key,value in trait_obj.items():
-			setattr(self,key,value)
+class AttributeSetter:
+    def __init__(self, trait_obj):
+        for key, value in trait_obj.items():
+            setattr(self, key, value)
 
-class TestShowCorrResults(unittest.TestCase):
 
-	def test_get_header_fields(self):
-		expected=[
-		                    ['Index',
-                                'Record',
-                                'Symbol',
-                                'Description',
-                                'Location',
-                                'Mean',
-                                'Sample rho',
-                                'N',
-                                'Sample p(rho)',
-                                'Lit rho',
-                                'Tissue rho',
-                                'Tissue p(rho)',
-                                'Max LRS',
-                                'Max LRS Location',
-                                'Additive Effect'],
-
-                            ['Index',
-                                 'ID',
-                                 'Location',
-                                 'Sample r',
-                                 'N',
-                                 'Sample p(r)']
-
-		]
-		result1=get_header_fields("ProbeSet","spearman")
-		result2=get_header_fields("Other","Other")
-		self.assertEqual(result1,expected[0])
-		self.assertEqual(result2,expected[1])
-
-
-
-
-	def test_generate_corr_json(self):
-		this_trait=Trait({"name":"trait_test"})
-		dataset=Trait({"name":"the_name"})
-		target_dataset=Trait({"type":"Publish"})
-	
-		trait_with_publish={
-		"description_display":"Trait 2 description",
-		"authors":"trait_2 ",
-		"pubmed_id":"34n4nn31hn43",
-		"lrs_location":"N/A",
-		"additive":"",
-		"sample_r":100,
-		"num_overlap":3.2,
-		"view":True,
-		"name":"trait_1",
-		"pubmed_text":"2016",
-		"additive":"",
-		"sample_r":10.5,
-		"LRS_score_repr":"N/A",
-		"LRS_location_repr":"N/A",
-		"sample_p":5,
-		"num_overlap":"num_1"
-
-
-
-		}
-		expected_results="""[{"trait_id": "trait_1", "description": "Trait 2 description", "authors": "trait_2 ", "pubmed_id": "34n4nn31hn43", "year": "2016", "lrs_score": "N/A", "lrs_location": "N/A", "additive": "N/A", "sample_r": "10.500", "num_overlap": "num_1", "sample_p": "5.000e+00"}]"""
-
-		corr_results=[Trait(trait_with_publish)]
-		results=generate_corr_json(corr_results=corr_results,this_trait=this_trait,dataset=dataset,target_dataset=target_dataset,for_api=True)
-		self.assertEqual(results,expected_results)
-		
-		
-
-	def test_generate_corr_json_view_false(self):
-		trait=Trait({"view":False})
-		corr_results=[trait]
-		this_trait=Trait({"name":"trait_test"})
-		dataset=Trait({"name":"the_name"})
-		
-
-		results_where_view_is_false=generate_corr_json(corr_results=corr_results,this_trait=this_trait,dataset={},target_dataset={},for_api=False)
-
-		# self.assertEqual(results,[])
-		self.assertEqual(results_where_view_is_false,"[]")
\ No newline at end of file
+class TestShowCorrResults(unittest.TestCase):
+    def test_get_header_fields(self):
+        expected = [
+            ['Index',
+             'Record',
+             'Symbol',
+             'Description',
+             'Location',
+             'Mean',
+             'Sample rho',
+             'N',
+             'Sample p(rho)',
+             'Lit rho',
+             'Tissue rho',
+             'Tissue p(rho)',
+             'Max LRS',
+             'Max LRS Location',
+             'Additive Effect'],
+
+            ['Index',
+             'ID',
+             'Location',
+             'Sample r',
+             'N',
+             'Sample p(r)']
+
+        ]
+        result1 = get_header_fields("ProbeSet", "spearman")
+        result2 = get_header_fields("Other", "Other")
+        self.assertEqual(result1, expected[0])
+        self.assertEqual(result2, expected[1])
+
+    @mock.patch("wqflask.correlation.show_corr_results.hmac.data_hmac")
+    def test_generate_corr_json(self, mock_data_hmac):
+        mock_data_hmac.return_value = "hajsdiau"
+
+        dataset = AttributeSetter({"name": "the_name"})
+        this_trait = AttributeSetter(
+            {"name": "trait_test", "dataset": dataset})
+        target_dataset = AttributeSetter({"type": "Publish"})
+        corr_trait_1 = AttributeSetter({
+            "name": "trait_1",
+            "dataset": AttributeSetter({"name": "dataset_1"}),
+            "view": True,
+            "abbreviation": "T1",
+            "description_display": "Trait I description",
+            "authors": "JM J,JYEW",
+            "pubmed_id": "34n4nn31hn43",
+            "pubmed_text": "2016",
+            "pubmed_link": "https://www.load",
+            "lod_score": "",
+            "LRS_location_repr": "BXBS",
+            "additive": "",
+            "sample_r": 10.5,
+            "num_overlap": 2,
+            "sample_p": 5
+
+
+
+
+        })
+        corr_results = [corr_trait_1]
+
+        dataset_type_other = {
+            "location": "cx-3-4",
+            "sample_4": 12.32,
+            "num_overlap": 3,
+            "sample_p": 10.34
+        }
+
+        expected_results = '[{"index": 1, "trait_id": "trait_1", "dataset": "dataset_1", "hmac": "hajsdiau", "abbreviation_display": "T1", "description": "Trait I description", "authors_display": "JM J,JYEW", "additive": "N/A", "pubmed_id": "34n4nn31hn43", "year": "2016", "lod_score": "N/A", "lrs_location": "BXBS", "sample_r": "10.500", "num_overlap": 2, "sample_p": "5.000e+00"}]'
+
+        results1 = generate_corr_json(corr_results=corr_results, this_trait=this_trait,
+                                      dataset=dataset, target_dataset=target_dataset, for_api=True)
+        self.assertEqual(expected_results, results1)
+
+    def test_generate_corr_json_view_false(self):
+        trait = AttributeSetter({"view": False})
+        corr_results = [trait]
+        this_trait = AttributeSetter({"name": "trait_test"})
+        dataset = AttributeSetter({"name": "the_name"})
+
+        results_where_view_is_false = generate_corr_json(
+            corr_results=corr_results, this_trait=this_trait, dataset={}, target_dataset={}, for_api=False)
+        self.assertEqual(results_where_view_is_false, "[]")
-- 
cgit v1.2.3


From f2e4e893f5639f216f8cc6fc57984aaebffd82ef Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Mon, 14 Dec 2020 14:11:23 +0300
Subject: add tests for snp browser

---
 wqflask/tests/unit/wqflask/snp_browser/__init__.py |  0
 .../unit/wqflask/snp_browser/test_snp_browser.py   | 84 ++++++++++++++++++++++
 2 files changed, 84 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/snp_browser/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/snp_browser/__init__.py b/wqflask/tests/unit/wqflask/snp_browser/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
new file mode 100644
index 00000000..e8751778
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -0,0 +1,84 @@
+import unittest
+from unittest import mock
+from wqflask import app
+from wqflask.snp_browser.snp_browser import get_gene_id
+from wqflask.snp_browser.snp_browser import get_gene_id_name_dict
+from wqflask.snp_browser.snp_browser import check_if_in_gene
+from wqflask.snp_browser.snp_browser import get_browser_sample_lists
+from wqflask.snp_browser.snp_browser import get_header_list
+
+class TestSnpBrowser(unittest.TestCase):
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+
+    @mock.patch("wqflask.snp_browser.snp_browser.g")
+    def test_get_gene_id(self, mock_db):
+        mock_db.db.execute.return_value.fetchone.return_value = "517d729f-aa13-4413-a885-40a3f7ff768a"
+        called_value="\n                SELECT\n                        geneId\n                FROM\n                        GeneList\n                WHERE\n                        SpeciesId = c9c0f59e-1259-4cba-91e6-831ef1a99c83 AND geneSymbol = 'INSR'\n            "
+        results = get_gene_id(
+            species_id="c9c0f59e-1259-4cba-91e6-831ef1a99c83", gene_name="INSR")
+        mock_db.db.execute.assert_called_once_with(called_value)
+        self.assertEqual(results, "517d729f-aa13-4413-a885-40a3f7ff768a")
+
+    @mock.patch("wqflask.snp_browser.snp_browser.g")
+    def test_gene_id_name_dict(self,mock_db):
+    	no_gene_names=[]
+    	self.assertEqual("",get_gene_id_name_dict(species_id="fregb343bui43g4",gene_name_list=no_gene_names))
+    	gene_name_list=["GH1","GH2","GH3"]
+    	mock_db.db.execute.return_value.fetchall.side_effect=[[],[("fsdf43-fseferger-f22","GH1"),("1sdf43-fsewferger-f22","GH2"),
+    	("fwdj43-fstferger-f22","GH3")]]
+    	no_results=get_gene_id_name_dict(species_id="ret3-32rf32",gene_name_list=gene_name_list)
+    	results_found=get_gene_id_name_dict(species_id="ret3-32rf32",gene_name_list=gene_name_list)
+    	expected_found= {'GH1': 'fsdf43-fseferger-f22', 'GH2': '1sdf43-fsewferger-f22', 'GH3': 'fwdj43-fstferger-f22'}
+    	db_query_value="\n                SELECT\n                        geneId, geneSymbol\n                FROM\n                        GeneList\n                WHERE\n                        SpeciesId = ret3-32rf32 AND geneSymbol in ('GH1','GH2','GH3')\n            "
+    	mock_db.db.execute.assert_called_with(db_query_value)
+    	self.assertEqual(results_found,expected_found)
+    	self.assertEqual(no_results,{})
+
+    @mock.patch("wqflask.snp_browser.snp_browser.g")
+    def test_check_if_in_gene(self,mock_db):
+    	mock_db.db.execute.return_value.fetchone.side_effect=[("fsdf-232sdf-sdf","GHA"),""]
+    	results_found=check_if_in_gene(species_id="517d729f-aa13-4413-a885-40a3f7ff768a",chr="CH1",mb=12.09)
+    	db_query_value="SELECT geneId, geneSymbol\n                   FROM GeneList\n                   WHERE SpeciesId = 517d729f-aa13-4413-a885-40a3f7ff768a AND chromosome = 'CH1' AND\n                        (txStart < 12.09 AND txEnd > 12.09); "
+    	gene_not_found=check_if_in_gene(species_id="517d729f-aa13-4413-a885-40a3f7ff768a",chr="CH1",mb=12.09)
+    	mock_db.db.execute.assert_called_with(db_query_value)
+    	self.assertEqual(gene_not_found,"")
+
+    @mock.patch("wqflask.snp_browser.snp_browser.g")
+    def test_get_browser_sample_lists(self,mock_db):
+    	mock_db.db.execute.return_value.fetchall.return_value=[]
+
+    	results=get_browser_sample_lists(species_id="12")
+    	self.assertEqual(results, {'mouse': [], 'rat': []})
+
+    def test_get_header_list(self):
+    	empty_columns={"snp_source":"false","conservation_score":"true","gene_name":"false","transcript":"false","exon":"false","domain_2":"true","function":"false","function_details":"true"}
+    	strains={"mouse":["S1","S2","S3","S4","S5"],"rat":[]}
+    	expected_results=([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore', 'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
+
+    	results_with_snp=get_header_list(variant_type="SNP",strains=strains,species="Mouse",empty_columns=empty_columns)
+    	results_with_indel=get_header_list(variant_type="InDel",strains=strains,species="rat",empty_columns=[])
+    	expected_results_with_indel=(['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source'],0)
+
+    	self.assertEqual(expected_results,results_with_snp)
+    	self.assertEqual(results_with_indel,expected_results_with_indel)
+
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
-- 
cgit v1.2.3


From db3170eb2fe66d8fd337803a730c18367df1b150 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Mon, 14 Dec 2020 16:11:07 +0300
Subject: add tests for type checking

---
 wqflask/tests/unit/utility/test_type_checking.py | 57 ++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 wqflask/tests/unit/utility/test_type_checking.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_type_checking.py b/wqflask/tests/unit/utility/test_type_checking.py
new file mode 100644
index 00000000..1ea11695
--- /dev/null
+++ b/wqflask/tests/unit/utility/test_type_checking.py
@@ -0,0 +1,57 @@
+import unittest
+from utility.type_checking import is_float
+from utility.type_checking import is_int
+from utility.type_checking import is_str
+from utility.type_checking import get_float
+from utility.type_checking import get_int
+from utility.type_checking import get_string
+class TestTypeChecking(unittest.TestCase):
+	def test_is_float(self):
+		floats=[2,1.2,'3.1']
+		not_floats=["String",None,[],()]
+		for flt in floats:
+			results=is_float(flt)
+			self.assertTrue(results)
+		for nflt in not_floats:
+			results=is_float(nflt)
+			self.assertFalse(results)
+
+	def test_is_int(self):
+		int_values=[1,1.1]
+		not_int_values=["1sdf",None,[],"1.1"]
+		for int_val in int_values:
+			results=is_int(int_val)
+			self.assertTrue(results)
+		for not_int in not_int_values:
+			results=is_int(not_int)
+			self.assertFalse(results)
+
+	def test_is_str(self):
+		string_values=[1,False,[],{},"string_value"]
+		falsey_values=[None]
+		for string_val in string_values:
+			results=is_str(string_val)
+			self.assertTrue(results)
+		for non_string in falsey_values:
+			results=is_str(non_string)
+			self.assertFalse(results)
+
+
+	def test_get_float(self):
+		vars_object={"min_value":"12"}
+		results=get_float(vars_object,"min_value")
+		self.assertEqual(results,12.0)
+
+	def test_get_int(self):
+		vars_object={"lx_value":"1"}
+		results=get_int(vars_object,"lx_value")
+		self.assertEqual(results,1)
+
+	def test_get_string(self):
+		string_object={"mx_value":1}
+		results=get_string(string_object,"mx_value")
+		self.assertEqual(results,"1")
+
+
+
+
-- 
cgit v1.2.3


From 868b8cba1cda983d8d401e60e30794529b557c80 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Mon, 14 Dec 2020 22:36:36 +0300
Subject: modify get_header tests

---
 .../unit/wqflask/snp_browser/test_snp_browser.py   | 23 +++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index e8751778..9ec32c78 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -15,6 +15,18 @@ class TestSnpBrowser(unittest.TestCase):
     def tearDown(self):
         self.app_context.pop()
 
+    def test_get_header_list(self):
+        empty_columns={"snp_source":"false","conservation_score":"true","gene_name":"false","transcript":"false","exon":"false","domain_2":"true","function":"false","function_details":"true"}
+        strains={"mouse":["S1","S2","S3","S4","S5"],"rat":[]}
+        expected_results=([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore', 'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
+
+        results_with_snp=get_header_list(variant_type="SNP",strains=strains,species="Mouse",empty_columns=empty_columns)
+        results_with_indel=get_header_list(variant_type="InDel",strains=strains,species="rat",empty_columns=[])
+        expected_results_with_indel=(['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source'],0)
+
+        self.assertEqual(expected_results,results_with_snp)
+        self.assertEqual(results_with_indel,expected_results_with_indel)
+
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
     def test_get_gene_id(self, mock_db):
@@ -56,17 +68,6 @@ class TestSnpBrowser(unittest.TestCase):
     	results=get_browser_sample_lists(species_id="12")
     	self.assertEqual(results, {'mouse': [], 'rat': []})
 
-    def test_get_header_list(self):
-    	empty_columns={"snp_source":"false","conservation_score":"true","gene_name":"false","transcript":"false","exon":"false","domain_2":"true","function":"false","function_details":"true"}
-    	strains={"mouse":["S1","S2","S3","S4","S5"],"rat":[]}
-    	expected_results=([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore', 'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
-
-    	results_with_snp=get_header_list(variant_type="SNP",strains=strains,species="Mouse",empty_columns=empty_columns)
-    	results_with_indel=get_header_list(variant_type="InDel",strains=strains,species="rat",empty_columns=[])
-    	expected_results_with_indel=(['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source'],0)
-
-    	self.assertEqual(expected_results,results_with_snp)
-    	self.assertEqual(results_with_indel,expected_results_with_indel)
 
 
 
-- 
cgit v1.2.3


From 5a73d56fdbe197e99b476d49d4adce9403c8daeb Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Fri, 18 Dec 2020 15:18:19 +0300
Subject: refactor tests and pep8 formatting

---
 wqflask/tests/unit/utility/test_type_checking.py   |  93 ++++++++--------
 .../unit/wqflask/snp_browser/test_snp_browser.py   | 120 ++++++++++++---------
 2 files changed, 112 insertions(+), 101 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_type_checking.py b/wqflask/tests/unit/utility/test_type_checking.py
index 1ea11695..48d110c7 100644
--- a/wqflask/tests/unit/utility/test_type_checking.py
+++ b/wqflask/tests/unit/utility/test_type_checking.py
@@ -5,53 +5,50 @@ from utility.type_checking import is_str
 from utility.type_checking import get_float
 from utility.type_checking import get_int
 from utility.type_checking import get_string
-class TestTypeChecking(unittest.TestCase):
-	def test_is_float(self):
-		floats=[2,1.2,'3.1']
-		not_floats=["String",None,[],()]
-		for flt in floats:
-			results=is_float(flt)
-			self.assertTrue(results)
-		for nflt in not_floats:
-			results=is_float(nflt)
-			self.assertFalse(results)
-
-	def test_is_int(self):
-		int_values=[1,1.1]
-		not_int_values=["1sdf",None,[],"1.1"]
-		for int_val in int_values:
-			results=is_int(int_val)
-			self.assertTrue(results)
-		for not_int in not_int_values:
-			results=is_int(not_int)
-			self.assertFalse(results)
-
-	def test_is_str(self):
-		string_values=[1,False,[],{},"string_value"]
-		falsey_values=[None]
-		for string_val in string_values:
-			results=is_str(string_val)
-			self.assertTrue(results)
-		for non_string in falsey_values:
-			results=is_str(non_string)
-			self.assertFalse(results)
-
-
-	def test_get_float(self):
-		vars_object={"min_value":"12"}
-		results=get_float(vars_object,"min_value")
-		self.assertEqual(results,12.0)
-
-	def test_get_int(self):
-		vars_object={"lx_value":"1"}
-		results=get_int(vars_object,"lx_value")
-		self.assertEqual(results,1)
-
-	def test_get_string(self):
-		string_object={"mx_value":1}
-		results=get_string(string_object,"mx_value")
-		self.assertEqual(results,"1")
-
-
 
 
+class TestTypeChecking(unittest.TestCase):
+    def test_is_float(self):
+        floats = [2, 1.2, '3.1']
+        not_floats = ["String", None, [], ()]
+        for flt in floats:
+            results = is_float(flt)
+            self.assertTrue(results)
+        for nflt in not_floats:
+            results = is_float(nflt)
+            self.assertFalse(results)
+
+    def test_is_int(self):
+        int_values = [1, 1.1]
+        not_int_values = ["string", None, [], "1.1"]
+        for int_val in int_values:
+            results = is_int(int_val)
+            self.assertTrue(results)
+        for not_int in not_int_values:
+            results = is_int(not_int)
+            self.assertFalse(results)
+
+    def test_is_str(self):
+        string_values = [1, False, [], {}, "string_value"]
+        falsey_values = [None]
+        for string_val in string_values:
+            results = is_str(string_val)
+            self.assertTrue(results)
+        for non_string in falsey_values:
+            results = is_str(non_string)
+            self.assertFalse(results)
+
+    def test_get_float(self):
+        vars_object = {"min_value": "12"}
+        results = get_float(vars_object, "min_value")
+        self.assertEqual(results, 12.0)
+
+    def test_get_int(self):
+        vars_object = {"lx_value": "1"}
+        results = get_int(vars_object, "lx_value")
+        self.assertEqual(results, 1)
+
+    def test_get_string(self):
+        string_object = {"mx_value": 1}
+        results = get_string(string_object, "mx_value")
+        self.assertEqual(results, "1")
\ No newline at end of file
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index 9ec32c78..496d228f 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -7,6 +7,7 @@ from wqflask.snp_browser.snp_browser import check_if_in_gene
 from wqflask.snp_browser.snp_browser import get_browser_sample_lists
 from wqflask.snp_browser.snp_browser import get_header_list
 
+
 class TestSnpBrowser(unittest.TestCase):
     def setUp(self):
         self.app_context = app.app_context()
@@ -16,70 +17,83 @@ class TestSnpBrowser(unittest.TestCase):
         self.app_context.pop()
 
     def test_get_header_list(self):
-        empty_columns={"snp_source":"false","conservation_score":"true","gene_name":"false","transcript":"false","exon":"false","domain_2":"true","function":"false","function_details":"true"}
-        strains={"mouse":["S1","S2","S3","S4","S5"],"rat":[]}
-        expected_results=([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore', 'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
-
-        results_with_snp=get_header_list(variant_type="SNP",strains=strains,species="Mouse",empty_columns=empty_columns)
-        results_with_indel=get_header_list(variant_type="InDel",strains=strains,species="rat",empty_columns=[])
-        expected_results_with_indel=(['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source'],0)
-
-        self.assertEqual(expected_results,results_with_snp)
-        self.assertEqual(results_with_indel,expected_results_with_indel)
-
+        empty_columns = {"snp_source": "false", "conservation_score": "true", "gene_name": "false",
+                         "transcript": "false", "exon": "false", "domain_2": "true", "function": "false", "function_details": "true"}
+        strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []}
+        expected_results = ([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore',
+                              'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
+
+        results_with_snp = get_header_list(
+            variant_type="SNP", strains=strains, species="Mouse", empty_columns=empty_columns)
+        results_with_indel = get_header_list(
+            variant_type="InDel", strains=strains, species="rat", empty_columns=[])
+        expected_results_with_indel = (
+            ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 
+            'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0)
+
+        self.assertEqual(expected_results, results_with_snp)
+        self.assertEqual(results_with_indel, expected_results_with_indel)
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
     def test_get_gene_id(self, mock_db):
         mock_db.db.execute.return_value.fetchone.return_value = "517d729f-aa13-4413-a885-40a3f7ff768a"
-        called_value="\n                SELECT\n                        geneId\n                FROM\n                        GeneList\n                WHERE\n                        SpeciesId = c9c0f59e-1259-4cba-91e6-831ef1a99c83 AND geneSymbol = 'INSR'\n            "
+        db_query_value = """
+                SELECT
+                        geneId
+                FROM
+                        GeneList
+                WHERE
+                        SpeciesId = c9c0f59e-1259-4cba-91e6-831ef1a99c83 AND geneSymbol = 'INSR'
+            """
         results = get_gene_id(
             species_id="c9c0f59e-1259-4cba-91e6-831ef1a99c83", gene_name="INSR")
-        mock_db.db.execute.assert_called_once_with(called_value)
+        mock_db.db.execute.assert_called_once_with(db_query_value)
         self.assertEqual(results, "517d729f-aa13-4413-a885-40a3f7ff768a")
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
-    def test_gene_id_name_dict(self,mock_db):
-    	no_gene_names=[]
-    	self.assertEqual("",get_gene_id_name_dict(species_id="fregb343bui43g4",gene_name_list=no_gene_names))
-    	gene_name_list=["GH1","GH2","GH3"]
-    	mock_db.db.execute.return_value.fetchall.side_effect=[[],[("fsdf43-fseferger-f22","GH1"),("1sdf43-fsewferger-f22","GH2"),
-    	("fwdj43-fstferger-f22","GH3")]]
-    	no_results=get_gene_id_name_dict(species_id="ret3-32rf32",gene_name_list=gene_name_list)
-    	results_found=get_gene_id_name_dict(species_id="ret3-32rf32",gene_name_list=gene_name_list)
-    	expected_found= {'GH1': 'fsdf43-fseferger-f22', 'GH2': '1sdf43-fsewferger-f22', 'GH3': 'fwdj43-fstferger-f22'}
-    	db_query_value="\n                SELECT\n                        geneId, geneSymbol\n                FROM\n                        GeneList\n                WHERE\n                        SpeciesId = ret3-32rf32 AND geneSymbol in ('GH1','GH2','GH3')\n            "
-    	mock_db.db.execute.assert_called_with(db_query_value)
-    	self.assertEqual(results_found,expected_found)
-    	self.assertEqual(no_results,{})
+    def test_gene_id_name_dict(self, mock_db):
+        no_gene_names = []
+        self.assertEqual("", get_gene_id_name_dict(
+            species_id="fregb343bui43g4", gene_name_list=no_gene_names))
+        gene_name_list = ["GH1", "GH2", "GH3"]
+        mock_db.db.execute.return_value.fetchall.side_effect = [[], [("fsdf43-fseferger-f22", "GH1"), ("1sdf43-fsewferger-f22", "GH2"),
+                                                                     ("fwdj43-fstferger-f22", "GH3")]]
+        no_results = get_gene_id_name_dict(
+            species_id="ret3-32rf32", gene_name_list=gene_name_list)
+        results_found = get_gene_id_name_dict(
+            species_id="ret3-32rf32", gene_name_list=gene_name_list)
+        expected_found = {'GH1': 'fsdf43-fseferger-f22',
+                          'GH2': '1sdf43-fsewferger-f22', 'GH3': 'fwdj43-fstferger-f22'}
+        db_query_value = """
+                SELECT
+                        geneId, geneSymbol
+                FROM
+                        GeneList
+                WHERE
+                        SpeciesId = ret3-32rf32 AND geneSymbol in ('GH1','GH2','GH3')
+            """
+        mock_db.db.execute.assert_called_with(db_query_value)
+        self.assertEqual(results_found, expected_found)
+        self.assertEqual(no_results, {})
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
-    def test_check_if_in_gene(self,mock_db):
-    	mock_db.db.execute.return_value.fetchone.side_effect=[("fsdf-232sdf-sdf","GHA"),""]
-    	results_found=check_if_in_gene(species_id="517d729f-aa13-4413-a885-40a3f7ff768a",chr="CH1",mb=12.09)
-    	db_query_value="SELECT geneId, geneSymbol\n                   FROM GeneList\n                   WHERE SpeciesId = 517d729f-aa13-4413-a885-40a3f7ff768a AND chromosome = 'CH1' AND\n                        (txStart < 12.09 AND txEnd > 12.09); "
-    	gene_not_found=check_if_in_gene(species_id="517d729f-aa13-4413-a885-40a3f7ff768a",chr="CH1",mb=12.09)
-    	mock_db.db.execute.assert_called_with(db_query_value)
-    	self.assertEqual(gene_not_found,"")
+    def test_check_if_in_gene(self, mock_db):
+        mock_db.db.execute.return_value.fetchone.side_effect = [
+            ("fsdf-232sdf-sdf", "GHA"), ""]
+        results_found = check_if_in_gene(
+            species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr="CH1", mb=12.09)
+        db_query_value = """SELECT geneId, geneSymbol
+                   FROM GeneList
+                   WHERE SpeciesId = 517d729f-aa13-4413-a885-40a3f7ff768a AND chromosome = 'CH1' AND
+                        (txStart < 12.09 AND txEnd > 12.09); """
+        gene_not_found = check_if_in_gene(
+            species_id="517d729f-aa13-4413-a885-40a3f7ff768a", chr="CH1", mb=12.09)
+        mock_db.db.execute.assert_called_with(db_query_value)
+        self.assertEqual(gene_not_found, "")
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
-    def test_get_browser_sample_lists(self,mock_db):
-    	mock_db.db.execute.return_value.fetchall.return_value=[]
-
-    	results=get_browser_sample_lists(species_id="12")
-    	self.assertEqual(results, {'mouse': [], 'rat': []})
-
-
-
-
-
-
-
- 
-
-
-
-
-
-
-
+    def test_get_browser_sample_lists(self, mock_db):
+        mock_db.db.execute.return_value.fetchall.return_value = []
 
+        results = get_browser_sample_lists(species_id="12")
+        self.assertEqual(results, {'mouse': [], 'rat': []})
-- 
cgit v1.2.3


From b605f52440e84909631b6afdf510a9e513260901 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Wed, 6 Jan 2021 08:21:44 +0300
Subject: fix tests for show_corr_results

---
 wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
index ffb96dd6..33601990 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_show_corr_results.py
@@ -61,6 +61,7 @@ class TestShowCorrResults(unittest.TestCase):
             "pubmed_text": "2016",
             "pubmed_link": "https://www.load",
             "lod_score": "",
+            "mean": "",
             "LRS_location_repr": "BXBS",
             "additive": "",
             "sample_r": 10.5,
@@ -80,7 +81,7 @@ class TestShowCorrResults(unittest.TestCase):
             "sample_p": 10.34
         }
 
-        expected_results = '[{"index": 1, "trait_id": "trait_1", "dataset": "dataset_1", "hmac": "hajsdiau", "abbreviation_display": "T1", "description": "Trait I description", "authors_display": "JM J,JYEW", "additive": "N/A", "pubmed_id": "34n4nn31hn43", "year": "2016", "lod_score": "N/A", "lrs_location": "BXBS", "sample_r": "10.500", "num_overlap": 2, "sample_p": "5.000e+00"}]'
+        expected_results = '[{"index": 1, "trait_id": "trait_1", "dataset": "dataset_1", "hmac": "hajsdiau", "abbreviation_display": "T1", "description": "Trait I description", "mean": "N/A", "authors_display": "JM J,JYEW", "additive": "N/A", "pubmed_id": "34n4nn31hn43", "year": "2016", "lod_score": "N/A", "lrs_location": "BXBS", "sample_r": "10.500", "num_overlap": 2, "sample_p": "5.000e+00"}]'
 
         results1 = generate_corr_json(corr_results=corr_results, this_trait=this_trait,
                                       dataset=dataset, target_dataset=target_dataset, for_api=True)
-- 
cgit v1.2.3


From 4203e9609dcf59fa7369e9e0dde02d0da3c8e32f Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Wed, 6 Jan 2021 08:50:30 +0300
Subject: update tests for snp_browser

---
 .../tests/unit/wqflask/snp_browser/test_snp_browser.py    | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index 496d228f..7fa96dba 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -21,18 +21,25 @@ class TestSnpBrowser(unittest.TestCase):
                          "transcript": "false", "exon": "false", "domain_2": "true", "function": "false", "function_details": "true"}
         strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []}
         expected_results = ([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore',
-                              'Domain 1', 'Domain 2', 'Details'], ['S1', 'S2', 'S3', 'S4', 'S5']], 5)
+                              'Domain 1', 'Domain 2', 'Details'], 
+                              ['S1', 'S2', 'S3', 'S4', 'S5']], 5, 
+                              ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles', 
+                              'conservation_score', 'domain_1', 'domain_2',
+                              'function_details', 'S1', 'S2', 'S3', 'S4', 'S5'])
 
         results_with_snp = get_header_list(
             variant_type="SNP", strains=strains, species="Mouse", empty_columns=empty_columns)
         results_with_indel = get_header_list(
             variant_type="InDel", strains=strains, species="rat", empty_columns=[])
         expected_results_with_indel = (
-            ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 
-            'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0)
+            ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start',
+             'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0, 
+             ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
+            'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name'])
 
         self.assertEqual(expected_results, results_with_snp)
-        self.assertEqual(results_with_indel, expected_results_with_indel)
+        # self.assertEqual(results_with_indel, expected_results_with_indel)
+        self.assertEqual(expected_results_with_indel, results_with_indel)
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
     def test_get_gene_id(self, mock_db):
-- 
cgit v1.2.3


From e55aa51937abf03897a20a52dd7dbf3cfc4ac6c8 Mon Sep 17 00:00:00 2001
From: Alexanderkabui
Date: Wed, 6 Jan 2021 08:54:47 +0300
Subject: remove comments

---
 wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index 7fa96dba..ce3e7b83 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -38,7 +38,6 @@ class TestSnpBrowser(unittest.TestCase):
             'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name'])
 
         self.assertEqual(expected_results, results_with_snp)
-        # self.assertEqual(results_with_indel, expected_results_with_indel)
         self.assertEqual(expected_results_with_indel, results_with_indel)
 
     @mock.patch("wqflask.snp_browser.snp_browser.g")
-- 
cgit v1.2.3


From 5187e582721ddfbb1e864378823f2685748bf5f2 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 18 Jan 2021 11:15:33 +0300
Subject: Pass salt as bytes when testing pbkdf2_hex

* wqflask/tests/unit/wqflask/test_pbkdf2.py (test_pbkdf2_hex): Make
password salt bytes. Breaking change introduced in 0bac313ba.
---
 wqflask/tests/unit/wqflask/test_pbkdf2.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_pbkdf2.py b/wqflask/tests/unit/wqflask/test_pbkdf2.py
index a33fbd4f..7ad6c83e 100644
--- a/wqflask/tests/unit/wqflask/test_pbkdf2.py
+++ b/wqflask/tests/unit/wqflask/test_pbkdf2.py
@@ -11,43 +11,43 @@ class TestPbkdf2(unittest.TestCase):
         """
 
         for password, salt, iterations, keylen, expected_value in [
-                ('password', 'salt', 1, 20,
+                ('password', b'salt', 1, 20,
                  '0c60c80f961f0e71f3a9b524af6012062fe037a6'),
-                ('password', 'salt', 2, 20,
+                ('password', b'salt', 2, 20,
                  'ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957'),
-                ('password', 'salt', 4096, 20,
+                ('password', b'salt', 4096, 20,
                  '4b007901b765489abead49d926f721d065a429c1'),
                 ('passwordPASSWORDpassword',
-                 'saltSALTsaltSALTsaltSALTsaltSALTsalt',
+                 b'saltSALTsaltSALTsaltSALTsaltSALTsalt',
                  4096, 25,
                  '3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038'),
-                ('pass\x00word', 'sa\x00lt', 4096, 16,
+                ('pass\x00word', b'sa\x00lt', 4096, 16,
                  '56fa6aa75548099dcc37d7f03425e0c3'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1, 16,
+                ('password', b'ATHENA.MIT.EDUraeburn', 1, 16,
                  'cdedb5281bb2f801565a1122b2563515'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1, 32,
+                ('password', b'ATHENA.MIT.EDUraeburn', 1, 32,
                  ('cdedb5281bb2f80'
                   '1565a1122b256351'
                   '50ad1f7a04bb9f3a33'
                   '3ecc0e2e1f70837')),
-                ('password', 'ATHENA.MIT.EDUraeburn', 2, 16,
+                ('password', b'ATHENA.MIT.EDUraeburn', 2, 16,
                  '01dbee7f4a9e243e988b62c73cda935d'),
-                ('password', 'ATHENA.MIT.EDUraeburn', 2, 32,
+                ('password', b'ATHENA.MIT.EDUraeburn', 2, 32,
                  ('01dbee7f4a9e243e9'
                   '88b62c73cda935da05'
                   '378b93244ec8f48a99'
                   'e61ad799d86')),
-                ('password', 'ATHENA.MIT.EDUraeburn', 1200, 32,
+                ('password', b'ATHENA.MIT.EDUraeburn', 1200, 32,
                  ('5c08eb61fdf71e'
                   '4e4ec3cf6ba1f55'
                   '12ba7e52ddbc5e51'
                   '42f708a31e2e62b1e13')),
-                ('X' * 64, 'pass phrase equals block size', 1200, 32,
+                ('X' * 64, b'pass phrase equals block size', 1200, 32,
                  ('139c30c0966bc32ba'
                   '55fdbf212530ac9c5'
                   'ec59f1a452f5cc9ad'
                   '940fea0598ed1')),
-                ('X' * 65, 'pass phrase exceeds block size', 1200, 32,
+                ('X' * 65, b'pass phrase exceeds block size', 1200, 32,
                  ('9ccad6d468770cd'
                   '51b10e6a68721be6'
                   '11a8b4d282601db3'
-- 
cgit v1.2.3


From 7187f1b9d43ec2ef5db34819047dc4c1a6b3da3e Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sun, 31 Jan 2021 19:44:51 +0300
Subject: Update sql query in test

* wqflask/tests/unit/wqflask/api/test_gen_menu.py
(test_build_datasets_with_type_mrna): Update sql query to fix failing
test
---
 wqflask/tests/unit/wqflask/api/test_gen_menu.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index 84898bd1..cc666f0c 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -247,7 +247,7 @@ class TestGenMenu(unittest.TestCase):
             "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
             "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-            "ORDER BY ProbeSetFreeze.CreateTime DESC")
+            "ORDER BY ProbeSetFreeze.OrderList DESC")
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
     @mock.patch('wqflask.api.gen_menu.g')
-- 
cgit v1.2.3


From c1d775162c2a657f9e8001914cc216cd70460371 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 18 Feb 2021 21:36:28 +0000
Subject: Patched utility.authentication_tools.g as TestUserSession because
 otherwise the str.encode failed on the mock.Mock() object, and this also
 seems consistent with the way it's done in a later method

---
 wqflask/tests/unit/utility/test_authentication_tools.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
index 5c391be5..6d817f5e 100644
--- a/wqflask/tests/unit/utility/test_authentication_tools.py
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -5,7 +5,6 @@ from unittest import mock
 from utility.authentication_tools import check_resource_availability
 from utility.authentication_tools import add_new_resource
 
-
 class TestResponse:
     """Mock Test Response after a request"""
     @property
@@ -38,7 +37,7 @@ class TestCheckResourceAvailability(unittest.TestCase):
     """Test methods related to checking the resource availability"""
     @mock.patch('utility.authentication_tools.add_new_resource')
     @mock.patch('utility.authentication_tools.Redis')
-    @mock.patch('utility.authentication_tools.g', mock.Mock())
+    @mock.patch('utility.authentication_tools.g', TestUserSession())
     @mock.patch('utility.authentication_tools.get_resource_id')
     def test_check_resource_availability_default_mask(
             self,
@@ -46,6 +45,7 @@ class TestCheckResourceAvailability(unittest.TestCase):
             redis_mock,
             add_new_resource_mock):
         """Test the resource availability with default mask"""
+
         resource_id_mock.return_value = 1
         redis_mock.smembers.return_value = []
         test_dataset = mock.MagicMock()
@@ -64,7 +64,7 @@ class TestCheckResourceAvailability(unittest.TestCase):
             redis_mock,
             add_new_resource_mock,
             requests_mock):
-        """Test the resource availability with default mask"""
+        """Test the resource availability with non-default mask"""
         resource_id_mock.return_value = 1
         redis_mock.smembers.return_value = []
         add_new_resource_mock.return_value = {"default_mask": 2}
-- 
cgit v1.2.3


From e55861d6ced9a5c746a8e28c9a9c067e3927275a Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 18 Feb 2021 21:47:39 +0000
Subject: Fixed test_run_mapping.py to make export_mapping_results test work
 correctly

---
 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 4129cc0c..a29d8cfb 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -180,14 +180,19 @@ class TestRunMapping(unittest.TestCase):
 
             with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
                 export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
-                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)")
+                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)",
+                                       transform="qnorm", covariates="Dataset1:Trait1,Dataset2:Trait2", n_samples="100")
 
                 write_calls = [
                     mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
                     mock.call('Population: Human GP1_\n'), mock.call(
                         'Data Set: dataser_1\n'),
+                    mock.call('N Samples: 100\n'), mock.call('Transform - Quantile Normalized\n'),
                     mock.call('Gene Symbol: IGFI\n'), mock.call(
                         'Location: X1 @ 123313 Mb\n'),
+                    mock.call('Cofactors (dataset - trait):\n'),
+                    mock.call('Trait1 - Dataset1\n'),
+                    mock.call('Trait2 - Dataset2\n'),
                     mock.call('\n'), mock.call('Name,Chr,'),
                     mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
                     mock.call(',Additive'), mock.call(',Dominance'),
-- 
cgit v1.2.3


From cb039b3e7e8a3a260edc80b0de79fc27af795cf0 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 18 Feb 2021 21:58:58 +0000
Subject: Fixed TestCheckResourceAvailability to make it work after realizing
 that Redis.smembers apparently returns values as bytes

---
 wqflask/tests/unit/utility/test_authentication_tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
index 6d817f5e..fff5fd8f 100644
--- a/wqflask/tests/unit/utility/test_authentication_tools.py
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -89,7 +89,7 @@ class TestCheckResourceAvailability(unittest.TestCase):
             requests_mock):
         """Test the resource availability if the user is the super user"""
         resource_id_mock.return_value = 1
-        redis_mock.smembers.return_value = ["Jane"]
+        redis_mock.smembers.return_value = [b"Jane"]
         add_new_resource_mock.return_value = {"default_mask": 2}
         requests_mock.return_value = TestResponse()
         test_dataset = mock.MagicMock()
-- 
cgit v1.2.3


From 4817d78b22b899b9beb3fd3a99a10d6cbcee22d6 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 18 Feb 2021 22:05:43 +0000
Subject: Fixed test_gen_menu to reflect updated query

---
 wqflask/tests/unit/wqflask/api/test_gen_menu.py | 7 ++++---
 wqflask/wqflask/api/gen_menu.py                 | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index cc666f0c..57eb1650 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -244,10 +244,11 @@ class TestGenMenu(unittest.TestCase):
             "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
             "Species.Name = 'Mouse' AND Species.Id = " +
             "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and " +
+            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND " +
             "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
-            "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id " +
-            "ORDER BY ProbeSetFreeze.OrderList DESC")
+            "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND " +
+            "ProbeSetFreeze.public > 0 " +
+            "ORDER BY -ProbeSetFreeze.OrderList DESC, ProbeSetFreeze.CreateTime DESC")
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
     @mock.patch('wqflask.api.gen_menu.g')
diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index 4ce19fdb..18afc5ad 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -207,7 +207,7 @@ def build_datasets(species, group, type_name):
              "InbredSet.SpeciesId AND InbredSet.Name = '{1}' "
              "AND ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
              "AND Tissue.Name = '{2}' AND ProbeFreeze.TissueId = "
-             "Tissue.Id and ProbeFreeze.InbredSetId = InbredSet.Id "
+             "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id "
              "AND ProbeSetFreeze.public > 0 "
              "ORDER BY -ProbeSetFreeze.OrderList DESC, ProbeSetFreeze.CreateTime DESC").format(species, group, type_name)).fetchall()
 
-- 
cgit v1.2.3


From 8ca8eb18ed8aa35177008bb92d805b9d603aec66 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Tue, 16 Mar 2021 19:12:48 +0000
Subject: Fixed test_check_resource_availability_of_super_user to account for
 user_id being returned as bytes instead of a str

---
 wqflask/tests/unit/utility/test_authentication_tools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
index fff5fd8f..42dcae88 100644
--- a/wqflask/tests/unit/utility/test_authentication_tools.py
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -18,7 +18,7 @@ class TestUser:
     @property
     def user_id(self):
         """Mockes user id. Used in Flask.g.user_session.user_id"""
-        return "Jane"
+        return b"Jane"
 
 
 class TestUserSession:
-- 
cgit v1.2.3


From be9c4a39500d7978b4cae7536a5f96c3818d211e Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Wed, 24 Mar 2021 09:41:47 +0300
Subject: initial commit for gn3-correlation api integration

---
 .../wqflask/correlation/test_correlation_gn3.py    | 14 ++++
 wqflask/wqflask/correlation/correlation_gn3_api.py | 77 ++++++++++++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py
 create mode 100644 wqflask/wqflask/correlation/correlation_gn3_api.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py
new file mode 100644
index 00000000..e1bd6d86
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_gn3.py
@@ -0,0 +1,14 @@
+"""this module contains tests for code used in integrating to gn3 api"""
+from unittest import TestCase
+from base.data_set import create_dataset
+
+class TestCorrelation(TestCase):
+
+    def test_create_dataset(self):
+        """test for creating datasets"""
+
+        pass
+    def test_fetch_dataset_info(self):
+        """test for fetching dataset info data"""
+
+        pass
diff --git a/wqflask/wqflask/correlation/correlation_gn3_api.py b/wqflask/wqflask/correlation/correlation_gn3_api.py
new file mode 100644
index 00000000..4cf6533c
--- /dev/null
+++ b/wqflask/wqflask/correlation/correlation_gn3_api.py
@@ -0,0 +1,77 @@
+"""module that calls the gn3 api's to do the correlation """
+from base import data_set
+from base.trait import create_trait
+from base.trait import retrieve_sample_data
+
+
+
+
+
+
+
+def compute_sample_r(start_vars,target_dataset, trait_data, target_samplelist, method="pearson"):
+    import requests
+    from wqflask.correlation.correlation_gn3_api import compute_correlation
+
+    cor_results = compute_correlation(start_vars)
+
+    data = {
+        "target_dataset": target_dataset,
+        "target_samplelist": target_samplelist,
+        "trait_data": {
+            "trait_sample_data": trait_data,
+            "trait_id": "HC_Q"
+        }
+    }
+    requests_url = f"http://127.0.0.1:8080/api/correlation/sample_x/{method}"
+
+    results = requests.post(requests_url, json=data)
+
+    data = results.json()
+
+    print(data)
+
+    return data
+
+
+def process_samples(start_vars,sample_names,excluded_samples=None):
+    sample_data = {}
+    if not excluded_samples:
+        excluded_samples = ()
+
+        sample_vals_dict  = json.loads(start_vars["sample_vals"])
+
+        for sample in sample_names:
+            if sample not in excluded_samples:
+                val = sample_val_dict[sample]
+                if not val.strip().lower() == "x":
+                    sample_data[str(sample)]=float(value)
+
+    return sample_data
+
+
+def create_fetch_dataset_data(dataset_name):
+    this_dataset  = data_set.create_dataset(dataset_name=dataset_name)
+
+    this_dataset.get_trait_data()
+
+
+def create_target_this_trait(start_vars):
+    """this function prefetch required data for correlation"""
+
+    this_dataset = data_set.create_dataset(dataset_name=start_vars['dataset'])
+    target_dataset = data_set.create_dataset(
+        dataset_name=start_vars['corr_dataset'])
+
+    this_trait = create_trait(dataset=this_dataset,
+                              name=start_vars['trait_id'])
+
+    this_trait = retrieve_sample_data(this_trait, this_dataset)
+
+    target_dataset.get_trait_data()
+
+    return (this_dataset,this_trait,target_dataset)
+def compute_correlation(start_vars):
+
+    this_dataset, this_trait, target_dataset = create_target_this_trait(
+        start_vars=start_vars)
-- 
cgit v1.2.3


From f6c8f30528969bf916bff4290c55f0866f69e8ea Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 29 Apr 2021 17:38:08 +0300
Subject: tests: unit: test_data_set: Remove unused mock

---
 wqflask/tests/unit/base/test_data_set.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
index 96563a16..ab0dc51c 100644
--- a/wqflask/tests/unit/base/test_data_set.py
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -31,14 +31,12 @@ class TestDataSetTypes(unittest.TestCase):
     def tearDown(self):
         self.app_context.pop()
 
-    @mock.patch('base.data_set.g')
-    def test_data_set_type(self, db_mock):
+    def test_data_set_type(self):
         """Test that DatasetType returns correctly if the Redis Instance is not empty
         and the name variable exists in the dictionary
 
         """
         with app.app_context():
-            db_mock.get = mock.Mock()
             redis_mock = mock.Mock()
             redis_mock.get.return_value = self.test_dataset
             self.assertEqual(DatasetType(redis_mock)
-- 
cgit v1.2.3


From e2b02fc85201320b1ae1d96ec4f598be1f6602c9 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 29 Apr 2021 20:29:38 +0300
Subject: tests: test_data_set: Update test

---
 wqflask/tests/unit/base/test_data_set.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
index ab0dc51c..ee5d6f06 100644
--- a/wqflask/tests/unit/base/test_data_set.py
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -87,8 +87,7 @@ class TestDataSetTypes(unittest.TestCase):
                  '"B139_K_1206_M": "ProbeSet", '
                  '"B139_K_1206_R": "ProbeSet", '
                  '"Test": "ProbeSet"}'))
-
-            db_mock.db.execute.assert_called_with(
+            db_mock.db.execute.assert_called_once_with(
                 ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
                  "WHERE ProbeSetFreeze.Name = \"Test\" ")
             )
-- 
cgit v1.2.3


From c7e661b8ff9f70955418fbc4527378904beb0cf4 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 12:16:51 +0300
Subject: autopep8: Fix E20-E27

Run:
python -m autopep8 --in-place --recrusive ./ --select\
E20,E211,E22,E224,E224,E225,E226,E227,E228,E231,E241,\
E242,E251,E252,E26,E265,E266,E27 -p 3
---
 wqflask/base/data_set.py                           |   18 +-
 wqflask/base/mrna_assay_tissue_data.py             |   16 +-
 wqflask/base/species.py                            |    2 +-
 wqflask/base/webqtlConfig.py                       |   40 +-
 wqflask/db/call.py                                 |    6 +-
 wqflask/db/gn_server.py                            |    2 +-
 wqflask/db/webqtlDatabaseFunction.py               |   10 +-
 wqflask/maintenance/convert_dryad_to_bimbam.py     |    6 +-
 wqflask/maintenance/convert_geno_to_bimbam.py      |   10 +-
 wqflask/maintenance/gen_select_dataset.py          |   16 +-
 .../maintenance/generate_kinship_from_bimbam.py    |    4 +-
 wqflask/maintenance/geno_to_json.py                |   26 +-
 wqflask/maintenance/quantile_normalize.py          |   30 +-
 wqflask/maintenance/set_resource_defaults.py       |   26 +-
 wqflask/tests/unit/wqflask/api/test_correlation.py |    4 +-
 .../marker_regression/test_gemma_mapping.py        |   14 +-
 .../marker_regression/test_qtlreaper_mapping.py    |   24 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |   28 +-
 wqflask/tests/wqflask/show_trait/testSampleList.py |    6 +-
 wqflask/utility/Plot.py                            |  180 ++--
 wqflask/utility/TDCell.py                          |    6 +-
 wqflask/utility/THCell.py                          |    8 +-
 wqflask/utility/__init__.py                        |    2 +-
 wqflask/utility/benchmark.py                       |    4 +-
 wqflask/utility/chunks.py                          |    2 +-
 wqflask/utility/corestats.py                       |    6 +-
 wqflask/utility/elasticsearch_tools.py             |    8 +-
 wqflask/utility/external.py                        |    2 +-
 wqflask/utility/gen_geno_ob.py                     |   18 +-
 wqflask/utility/helper_functions.py                |    2 +-
 wqflask/utility/logger.py                          |   34 +-
 wqflask/utility/pillow_utils.py                    |    2 +-
 wqflask/utility/startup_config.py                  |   10 +-
 wqflask/utility/svg.py                             |  624 +++++------
 wqflask/utility/temp_data.py                       |    2 +-
 wqflask/utility/tools.py                           |  112 +-
 wqflask/utility/type_checking.py                   |    6 +-
 wqflask/utility/webqtlUtil.py                      |   60 +-
 wqflask/wqflask/__init__.py                        |    8 +-
 wqflask/wqflask/api/correlation.py                 |   44 +-
 wqflask/wqflask/api/gen_menu.py                    |    4 +-
 wqflask/wqflask/api/mapping.py                     |   12 +-
 wqflask/wqflask/api/router.py                      |  196 ++--
 wqflask/wqflask/collect.py                         |   20 +-
 .../comparison_bar_chart/comparison_bar_chart.py   |   12 +-
 wqflask/wqflask/correlation/corr_scatter_plot.py   |   76 +-
 .../wqflask/correlation/correlation_functions.py   |   34 +-
 wqflask/wqflask/correlation/show_corr_results.py   |   38 +-
 .../wqflask/correlation_matrix/show_corr_matrix.py |   52 +-
 wqflask/wqflask/ctl/ctl_analysis.py                |   88 +-
 wqflask/wqflask/database.py                        |    2 +-
 wqflask/wqflask/do_search.py                       |   80 +-
 wqflask/wqflask/export_traits.py                   |    2 +-
 wqflask/wqflask/external_tools/send_to_bnw.py      |    6 +-
 .../wqflask/external_tools/send_to_geneweaver.py   |    6 +-
 .../wqflask/external_tools/send_to_webgestalt.py   |   26 +-
 wqflask/wqflask/group_manager.py                   |   22 +-
 wqflask/wqflask/gsearch.py                         |    2 +-
 wqflask/wqflask/heatmap/heatmap.py                 |    6 +-
 wqflask/wqflask/interval_analyst/GeneUtil.py       |   24 +-
 .../marker_regression/display_mapping_results.py   | 1114 ++++++++++----------
 wqflask/wqflask/marker_regression/gemma_mapping.py |    2 +-
 wqflask/wqflask/marker_regression/plink_mapping.py |   34 +-
 .../wqflask/marker_regression/qtlreaper_mapping.py |   70 +-
 wqflask/wqflask/marker_regression/rqtl_mapping.py  |   82 +-
 wqflask/wqflask/marker_regression/run_mapping.py   |  134 +--
 wqflask/wqflask/model.py                           |    8 +-
 wqflask/wqflask/parser.py                          |    4 +-
 wqflask/wqflask/resource_manager.py                |   10 +-
 wqflask/wqflask/search_results.py                  |   16 +-
 wqflask/wqflask/show_trait/SampleList.py           |   14 +-
 wqflask/wqflask/show_trait/show_trait.py           |   18 +-
 wqflask/wqflask/snp_browser/snp_browser.py         |   42 +-
 wqflask/wqflask/submit_bnw.py                      |    2 +-
 wqflask/wqflask/update_search_results.py           |    6 +-
 wqflask/wqflask/user_login.py                      |   88 +-
 wqflask/wqflask/user_manager.py                    |  143 ++-
 wqflask/wqflask/user_session.py                    |   38 +-
 wqflask/wqflask/views.py                           |    6 +-
 wqflask/wsgi.py                                    |    2 +-
 80 files changed, 1975 insertions(+), 1994 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 3183363b..55ab45f5 100644
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -150,7 +150,7 @@ class DatasetType:
                             "FROM PublishFreeze, InbredSet "
                             "WHERE InbredSet.Name = '%s' AND "
                             "PublishFreeze.InbredSetId = InbredSet.Id"),
-            'geno':  ("SELECT GenoFreeze.Id FROM GenoFreeze WHERE "
+            'geno': ("SELECT GenoFreeze.Id FROM GenoFreeze WHERE "
                       "GenoFreeze.Name = \"%s\" ")
         }
 
@@ -215,7 +215,7 @@ def create_datasets_list():
 
         if USE_REDIS:
             r.set(key, pickle.dumps(datasets, pickle.HIGHEST_PROTOCOL))
-            r.expire(key, 60*60)
+            r.expire(key, 60 * 60)
 
     return datasets
 
@@ -239,7 +239,7 @@ class Markers:
             for line in bimbam_fh:
                 marker = {}
                 marker['name'] = line.split(delimiter)[0].rstrip()
-                marker['Mb'] = float(line.split(delimiter)[1].rstrip())/1000000
+                marker['Mb'] = float(line.split(delimiter)[1].rstrip()) / 1000000
                 marker['chr'] = line.split(delimiter)[2].rstrip()
                 markers.append(marker)
 
@@ -369,8 +369,8 @@ class DatasetGroup:
     def get_markers(self):
         def check_plink_gemma():
             if flat_file_exists("mapping"):
-                MAPPING_PATH = flat_files("mapping")+"/"
-                if os.path.isfile(MAPPING_PATH+self.name+".bed"):
+                MAPPING_PATH = flat_files("mapping") + "/"
+                if os.path.isfile(MAPPING_PATH + self.name + ".bed"):
                     return True
             return False
 
@@ -416,7 +416,7 @@ class DatasetGroup:
         else:
             logger.debug("Cache not hit")
 
-            genotype_fn = locate_ignore_error(self.name+".geno", 'genotype')
+            genotype_fn = locate_ignore_error(self.name + ".geno", 'genotype')
             if genotype_fn:
                 self.samplelist = get_group_samplelists.get_samplelist(
                     "geno", genotype_fn)
@@ -425,7 +425,7 @@ class DatasetGroup:
 
             if USE_REDIS:
                 r.set(key, json.dumps(self.samplelist))
-                r.expire(key, 60*5)
+                r.expire(key, 60 * 5)
 
     def all_samples_ordered(self):
         result = []
@@ -531,7 +531,7 @@ def datasets(group_name, this_group=None):
 
     if USE_REDIS:
         r.set(key, pickle.dumps(dataset_menu, pickle.HIGHEST_PROTOCOL))
-        r.expire(key, 60*5)
+        r.expire(key, 60 * 5)
 
     if this_group != None:
         this_group._datasets = dataset_menu
@@ -622,7 +622,7 @@ class DataSet:
     WHERE ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id
     AND ProbeFreeze.TissueId = Tissue.Id
     AND (ProbeSetFreeze.Name = '%s' OR ProbeSetFreeze.FullName = '%s' OR ProbeSetFreeze.ShortName = '%s')
-                """ % (query_args), "/dataset/"+self.name+".json",
+                """ % (query_args), "/dataset/" + self.name + ".json",
                     lambda r: (r["id"], r["name"], r["full_name"],
                                r["short_name"], r["data_scale"], r["tissue"])
                 )
diff --git a/wqflask/base/mrna_assay_tissue_data.py b/wqflask/base/mrna_assay_tissue_data.py
index 1f8224af..f3264b3d 100644
--- a/wqflask/base/mrna_assay_tissue_data.py
+++ b/wqflask/base/mrna_assay_tissue_data.py
@@ -9,7 +9,7 @@ from utility.db_tools import escape
 
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 class MrnaAssayTissueData:
 
@@ -20,7 +20,7 @@ class MrnaAssayTissueData:
 
         self.data = collections.defaultdict(Bunch)
 
-        query =  '''select t.Symbol, t.GeneId, t.DataId, t.Chr, t.Mb, t.description, t.Probe_Target_Description
+        query = '''select t.Symbol, t.GeneId, t.DataId, t.Chr, t.Mb, t.description, t.Probe_Target_Description
                         from (
                         select Symbol, max(Mean) as maxmean
                         from TissueProbeSetXRef
@@ -31,14 +31,14 @@ class MrnaAssayTissueData:
         # Due to the limit size of TissueProbeSetFreezeId table in DB,
         # performance of inner join is acceptable.MrnaAssayTissueData(gene_symbols=symbol_list)
         if len(gene_symbols) == 0:
-            query +=  '''Symbol!='' and Symbol Is Not Null group by Symbol)
+            query += '''Symbol!='' and Symbol Is Not Null group by Symbol)
                 as x inner join TissueProbeSetXRef as t on t.Symbol = x.Symbol
                 and t.Mean = x.maxmean;
                     '''
         else:
             in_clause = db_tools.create_in_clause(gene_symbols)
 
-            #ZS: This was in the query, not sure why: http://docs.python.org/2/library/string.html?highlight=lower#string.lower
+            # ZS: This was in the query, not sure why: http://docs.python.org/2/library/string.html?highlight=lower#string.lower
             query += ''' Symbol in {} group by Symbol)
                 as x inner join TissueProbeSetXRef as t on t.Symbol = x.Symbol
                 and t.Mean = x.maxmean;
@@ -64,11 +64,11 @@ class MrnaAssayTissueData:
                 self.data[symbol].probe_target_description = result.Probe_Target_Description
 
     ###########################################################################
-    #Input: cursor, symbolList (list), dataIdDict(Dict)
-    #output: symbolValuepairDict (dictionary):one dictionary of Symbol and Value Pair,
+    # Input: cursor, symbolList (list), dataIdDict(Dict)
+    # output: symbolValuepairDict (dictionary):one dictionary of Symbol and Value Pair,
     #        key is symbol, value is one list of expression values of one probeSet;
-    #function: get one dictionary whose key is gene symbol and value is tissue expression data (list type).
-    #Attention! All keys are lower case!
+    # function: get one dictionary whose key is gene symbol and value is tissue expression data (list type).
+    # Attention! All keys are lower case!
     ###########################################################################
 
     def get_symbol_values_pairs(self):
diff --git a/wqflask/base/species.py b/wqflask/base/species.py
index eae3325a..cf764d72 100644
--- a/wqflask/base/species.py
+++ b/wqflask/base/species.py
@@ -4,7 +4,7 @@ from flask import Flask, g
 
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 class TheSpecies:
     def __init__(self, dataset=None, species_name=None):
diff --git a/wqflask/base/webqtlConfig.py b/wqflask/base/webqtlConfig.py
index bb8704a5..872b52eb 100644
--- a/wqflask/base/webqtlConfig.py
+++ b/wqflask/base/webqtlConfig.py
@@ -1,4 +1,4 @@
-#########################################'
+# '
 #      Environment Variables - public
 #
 # Note: much of this needs to handled by the settings/environment
@@ -10,35 +10,35 @@
 
 from utility.tools import valid_path, mk_dir, assert_dir, assert_writable_dir, flat_files, TEMPDIR
 
-#Debug Level
-#1 for debug, mod python will reload import each time
+# Debug Level
+# 1 for debug, mod python will reload import each time
 DEBUG = 1
 
-#USER privilege
-USERDICT = {'guest':1,'user':2, 'admin':3, 'root':4}
+# USER privilege
+USERDICT = {'guest': 1, 'user': 2, 'admin': 3, 'root':4}
 
-#Set privileges
+# Set privileges
 SUPER_PRIVILEGES = {'data': 'edit', 'metadata': 'edit', 'admin': 'edit-admins'}
 DEFAULT_PRIVILEGES = {'data': 'view', 'metadata': 'view', 'admin': 'not-admin'}
 
-#minimum number of informative strains
+# minimum number of informative strains
 KMININFORMATIVE = 5
 
-#Daily download limit from one IP
+# Daily download limit from one IP
 DAILYMAXIMUM = 1000
 
-#maximum LRS value
+# maximum LRS value
 MAXLRS = 460.0
 
-#MINIMUM Database public value
+# MINIMUM Database public value
 PUBLICTHRESH = 0
 
-#EXTERNAL LINK ADDRESSES
+# EXTERNAL LINK ADDRESSES
 PUBMEDLINK_URL = "http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?cmd=Retrieve&db=PubMed&list_uids=%s&dopt=Abstract"
 UCSC_BLAT = 'http://genome.ucsc.edu/cgi-bin/hgBlat?org=%s&db=%s&type=0&sort=0&output=0&userSeq=%s'
 UTHSC_BLAT = 'http://ucscbrowser.genenetwork.org/cgi-bin/hgBlat?org=%s&db=%s&type=0&sort=0&output=0&userSeq=%s'
 UTHSC_BLAT2 = 'http://ucscbrowserbeta.genenetwork.org/cgi-bin/hgBlat?org=%s&db=%s&type=0&sort=0&output=0&userSeq=%s'
-GENOMEBROWSER_URL="https://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=%s"
+GENOMEBROWSER_URL = "https://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=%s"
 NCBI_LOCUSID = "http://www.ncbi.nlm.nih.gov/gene?cmd=Retrieve&dopt=Graphics&list_uids=%s"
 GENBANK_ID = "http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=Nucleotide&cmd=search&doptcmdl=DocSum&term=%s"
 OMIM_ID = "http://www.ncbi.nlm.nih.gov/omim/%s"
@@ -56,7 +56,7 @@ GEMMA_URL = "http://www.chibi.ubc.ca/Gemma/gene/showGene.html?ncbiid=%s"
 ABA_URL = "http://mouse.brain-map.org/search/show?search_type=gene&search_term=%s"
 EBIGWAS_URL = "https://www.ebi.ac.uk/gwas/search?query=%s"
 WIKI_PI_URL = "http://severus.dbmi.pitt.edu/wiki-pi/index.php/search?q=%s"
-ENSEMBLETRANSCRIPT_URL="http://useast.ensembl.org/Mus_musculus/Transcript/Idhistory?t=%s"
+ENSEMBLETRANSCRIPT_URL = "http://useast.ensembl.org/Mus_musculus/Transcript/Idhistory?t=%s"
 DBSNP = 'http://ensembl.org/Mus_musculus/Variation/Population?v=%s'
 PROTEIN_ATLAS_URL = "http://www.proteinatlas.org/search/%s"
 OPEN_TARGETS_URL = "https://genetics.opentargets.org/gene/%s"
@@ -71,13 +71,13 @@ RRID_RAT_URL = "https://rgd.mcw.edu/rgdweb/report/strain/main.html?id=%s"
 # want to reach this base dir
 assert_writable_dir(TEMPDIR)
 
-TMPDIR               = mk_dir(TEMPDIR+'/gn2/')
+TMPDIR = mk_dir(TEMPDIR + '/gn2/')
 assert_writable_dir(TMPDIR)
 
-CACHEDIR             = mk_dir(TMPDIR+'/cache/')
+CACHEDIR = mk_dir(TMPDIR + '/cache/')
 # We can no longer write into the git tree:
-GENERATED_IMAGE_DIR  = mk_dir(TMPDIR+'generated/')
-GENERATED_TEXT_DIR   = mk_dir(TMPDIR+'generated_text/')
+GENERATED_IMAGE_DIR = mk_dir(TMPDIR + 'generated/')
+GENERATED_TEXT_DIR = mk_dir(TMPDIR + 'generated_text/')
 
 # Make sure we have permissions to access these
 assert_writable_dir(CACHEDIR)
@@ -85,12 +85,12 @@ assert_writable_dir(GENERATED_IMAGE_DIR)
 assert_writable_dir(GENERATED_TEXT_DIR)
 
 # Flat file directories
-GENODIR              = flat_files('genotype')+'/'
+GENODIR = flat_files('genotype') + '/'
 assert_dir(GENODIR)
 # assert_dir(GENODIR+'bimbam') # for gemma
 
 # JSON genotypes are OBSOLETE
-JSON_GENODIR         = flat_files('genotype/json')+'/'
+JSON_GENODIR = flat_files('genotype/json') + '/'
 if not valid_path(JSON_GENODIR):
     # fall back on old location (move the dir, FIXME)
     JSON_GENODIR = flat_files('json')
@@ -98,4 +98,4 @@ if not valid_path(JSON_GENODIR):
 # Are we using the following...?
 PORTADDR = "http://50.16.251.170"
 INFOPAGEHREF = '/dbdoc/%s.html'
-CGIDIR = '/webqtl/' #XZ: The variable name 'CGIDIR' should be changed to 'PYTHONDIR'
+CGIDIR = '/webqtl/'  # XZ: The variable name 'CGIDIR' should be changed to 'PYTHONDIR'
diff --git a/wqflask/db/call.py b/wqflask/db/call.py
index 0971d2a2..555878ad 100644
--- a/wqflask/db/call.py
+++ b/wqflask/db/call.py
@@ -12,7 +12,7 @@ from utility.tools import USE_GN_SERVER, LOG_SQL, GN_SERVER_URL
 from utility.benchmark import Bench
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 # from inspect import stack
 
@@ -64,9 +64,9 @@ def gn_server(path):
     with Bench("GN_SERVER", LOG_SQL):
         res = ()
         try:
-            res = urllib.request.urlopen(GN_SERVER_URL+path)
+            res = urllib.request.urlopen(GN_SERVER_URL + path)
         except:
-            res = urllib2.urlopen(GN_SERVER_URL+path)
+            res = urllib2.urlopen(GN_SERVER_URL + path)
         rest = res.read()
         res2 = json.loads(rest)
         logger.debug(res2)
diff --git a/wqflask/db/gn_server.py b/wqflask/db/gn_server.py
index da224112..6c7383d0 100644
--- a/wqflask/db/gn_server.py
+++ b/wqflask/db/gn_server.py
@@ -3,7 +3,7 @@
 from db.call import gn_server
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 def menu_main():
     return gn_server("/int/menu/main.json")
diff --git a/wqflask/db/webqtlDatabaseFunction.py b/wqflask/db/webqtlDatabaseFunction.py
index 2805febd..18ade405 100644
--- a/wqflask/db/webqtlDatabaseFunction.py
+++ b/wqflask/db/webqtlDatabaseFunction.py
@@ -24,24 +24,24 @@ from db.call import fetch1
 from utility.tools import USE_GN_SERVER
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 ###########################################################################
-#output: cursor instance
-#function: connect to database and return cursor instance
+# output: cursor instance
+# function: connect to database and return cursor instance
 ###########################################################################
 
 def retrieve_species(group):
     """Get the species of a group (e.g. returns string "mouse" on "BXD"
 
     """
-    result = fetch1("select Species.Name from Species, InbredSet where InbredSet.Name = '%s' and InbredSet.SpeciesId = Species.Id" % (group), "/cross/"+group+".json", lambda r: (r["species"],))[0]
+    result = fetch1("select Species.Name from Species, InbredSet where InbredSet.Name = '%s' and InbredSet.SpeciesId = Species.Id" % (group), "/cross/" + group + ".json", lambda r: (r["species"],))[0]
     logger.debug("retrieve_species result:", result)
     return result
 
 
 def retrieve_species_id(group):
 
-    result = fetch1("select SpeciesId from InbredSet where Name = '%s'" % (group), "/cross/"+group+".json", lambda r: (r["species_id"],))[0]
+    result = fetch1("select SpeciesId from InbredSet where Name = '%s'" % (group), "/cross/" + group + ".json", lambda r: (r["species_id"],))[0]
     logger.debug("retrieve_species_id result:", result)
     return result
diff --git a/wqflask/maintenance/convert_dryad_to_bimbam.py b/wqflask/maintenance/convert_dryad_to_bimbam.py
index 12ce35e9..8eab66e8 100644
--- a/wqflask/maintenance/convert_dryad_to_bimbam.py
+++ b/wqflask/maintenance/convert_dryad_to_bimbam.py
@@ -41,7 +41,7 @@ def read_dryad_file(filename):
 
     return geno_rows
 
-    #for i, marker in enumerate(marker_list):
+    # for i, marker in enumerate(marker_list):
     #    this_row = []
     #    this_row.append(marker)
     #    this_row.append("X")
@@ -53,7 +53,7 @@ def read_dryad_file(filename):
     #        print("row: " + str(i))
     #        geno_rows.append(this_row)
     #            
-    #return geno_rows
+    # return geno_rows
 
 def write_bimbam_files(geno_rows):
     with open('/home/zas1024/cfw_data/CFW_geno.txt', 'w') as geno_fh:
@@ -64,6 +64,6 @@ def convert_dryad_to_bimbam(filename):
     geno_file_rows = read_dryad_file(filename)
     write_bimbam_files(geno_file_rows)
 
-if __name__=="__main__":
+if __name__ == "__main__":
     input_filename = "/home/zas1024/cfw_data/" + sys.argv[1] + ".txt"
     convert_dryad_to_bimbam(input_filename)
diff --git a/wqflask/maintenance/convert_geno_to_bimbam.py b/wqflask/maintenance/convert_geno_to_bimbam.py
index 0853b3ac..dc01cbb3 100644
--- a/wqflask/maintenance/convert_geno_to_bimbam.py
+++ b/wqflask/maintenance/convert_geno_to_bimbam.py
@@ -103,9 +103,9 @@ class ConvertGenoFile:
         with open(self.output_files[2], "w") as snp_fh:
             for marker in self.markers:
                 if self.mb_exists:
-                    snp_fh.write(marker['name'] +", " + str(int(float(marker['Mb'])*1000000)) + ", " + marker['chr'] + "\n")
+                    snp_fh.write(marker['name'] + ", " + str(int(float(marker['Mb']) * 1000000)) + ", " + marker['chr'] + "\n")
                 else:
-                    snp_fh.write(marker['name'] +", " + str(int(float(marker['cM'])*1000000)) + ", " + marker['chr'] + "\n")
+                    snp_fh.write(marker['name'] + ", " + str(int(float(marker['cM']) * 1000000)) + ", " + marker['chr'] + "\n")
 
     def get_sample_list(self, row_contents):
         self.sample_list = []
@@ -178,12 +178,12 @@ class ConvertGenoFile:
                 print("    Row is:", convertob.latest_row_value)
                 break
 
-if __name__=="__main__":
+if __name__ == "__main__":
     Old_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype"""
     New_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype/bimbam"""
     #Input_File = """/home/zas1024/gene/genotype_files/genotypes/BXD.geno"""
     #Output_File = """/home/zas1024/gene/wqflask/wqflask/pylmm/data/bxd.snps"""
     #convertob = ConvertGenoFile("/home/zas1024/gene/genotype_files/genotypes/SRxSHRSPF2.geno", "/home/zas1024/gene/genotype_files/new_genotypes/SRxSHRSPF2.json")
-    #convertob.convert()
+    # convertob.convert()
     ConvertGenoFile.process_all(Old_Geno_Directory, New_Geno_Directory)
-    #ConvertGenoFiles(Geno_Directory)
+    # ConvertGenoFiles(Geno_Directory)
diff --git a/wqflask/maintenance/gen_select_dataset.py b/wqflask/maintenance/gen_select_dataset.py
index 544e2fd1..f480d63f 100644
--- a/wqflask/maintenance/gen_select_dataset.py
+++ b/wqflask/maintenance/gen_select_dataset.py
@@ -61,10 +61,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db = parsed_uri.path[1:],
-                        host = parsed_uri.hostname,
-                        user = parsed_uri.username,
-                        passwd = parsed_uri.password)
+                        db=parsed_uri.path[1:],
+                        host=parsed_uri.hostname,
+                        user=parsed_uri.username,
+                        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
@@ -120,7 +120,7 @@ def get_types(groups):
                     if not phenotypes_exist(group_name) and not genotypes_exist(group_name):
                         types[species].pop(group_name, None)
                         groups[species] = tuple(group for group in groups[species] if group[0] != group_name)
-            else: #ZS: This whole else statement might be unnecessary, need to check
+            else:  # ZS: This whole else statement might be unnecessary, need to check
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
                     types[species][group_name] = types_list
@@ -133,7 +133,7 @@ def get_types(groups):
 def phenotypes_exist(group_name):
     #print("group_name:", group_name)
     Cursor.execute("""select Name from PublishFreeze
-                      where PublishFreeze.Name = '%s'""" % (group_name+"Publish"))
+                      where PublishFreeze.Name = '%s'""" % (group_name + "Publish"))
 
     results = Cursor.fetchone()
     #print("RESULTS:", results)
@@ -146,7 +146,7 @@ def phenotypes_exist(group_name):
 def genotypes_exist(group_name):
     #print("group_name:", group_name)
     Cursor.execute("""select Name from GenoFreeze
-                      where GenoFreeze.Name = '%s'""" % (group_name+"Geno"))
+                      where GenoFreeze.Name = '%s'""" % (group_name + "Geno"))
 
     results = Cursor.fetchone()
     #print("RESULTS:", results)
@@ -246,7 +246,7 @@ def build_datasets(species, group, type_name):
         dataset_text = "%s Genotypes" % group
         datasets.append((dataset_id, dataset_value, dataset_text))
 
-    else: # for mRNA expression/ProbeSet
+    else:  # for mRNA expression/ProbeSet
         Cursor.execute("""select ProbeSetFreeze.Id, ProbeSetFreeze.Name, ProbeSetFreeze.FullName from
                     ProbeSetFreeze, ProbeFreeze, InbredSet, Tissue, Species where
                     Species.Name = '%s' and Species.Id = InbredSet.SpeciesId and
diff --git a/wqflask/maintenance/generate_kinship_from_bimbam.py b/wqflask/maintenance/generate_kinship_from_bimbam.py
index 3e4d1741..664e9e48 100644
--- a/wqflask/maintenance/generate_kinship_from_bimbam.py
+++ b/wqflask/maintenance/generate_kinship_from_bimbam.py
@@ -52,9 +52,9 @@ class GenerateKinshipMatrices:
                 break
     
     
-if __name__=="__main__":
+if __name__ == "__main__":
     Geno_Directory = """/export/local/home/zas1024/genotype_files/genotype/"""
     Bimbam_Directory = """/export/local/home/zas1024/genotype_files/genotype/bimbam/"""
     GenerateKinshipMatrices.process_all(Geno_Directory, Bimbam_Directory)
     
-    #./gemma -g /home/zas1024/genotype_files/genotype/bimbam/BXD_geno.txt -p /home/zas1024/genotype_files/genotype/bimbam/BXD_pheno.txt -gk 1 -o BXD
+    # ./gemma -g /home/zas1024/genotype_files/genotype/bimbam/BXD_geno.txt -p /home/zas1024/genotype_files/genotype/bimbam/BXD_pheno.txt -gk 1 -o BXD
diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index f5f7e0e7..fa0dcebd 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -66,16 +66,16 @@ class ConvertGenoFile:
         self.configurations = {}
         #self.skipped_cols = 3
         
-        #if self.input_file.endswith(".geno.gz"):
+        # if self.input_file.endswith(".geno.gz"):
         #    print("self.input_file: ", self.input_file)
         #    self.input_fh = gzip.open(self.input_file)
-        #else:
+        # else:
         self.input_fh = open(self.input_file)
         
         with open(self.output_file, "w") as self.output_fh:
-            #if self.file_type == "geno":
+            # if self.file_type == "geno":
             self.process_csv()
-            #elif self.file_type == "snps":
+            # elif self.file_type == "snps":
             #    self.process_snps_file()
 
 
@@ -105,7 +105,7 @@ class ConvertGenoFile:
                     this_marker.genotypes.append("NA")
                 
             #print("this_marker is:", pf(this_marker.__dict__))   
-            #if this_marker.chr == "14":
+            # if this_marker.chr == "14":
             self.markers.append(this_marker.__dict__)
 
         with open(self.output_file, 'w') as fh:
@@ -115,16 +115,16 @@ class ConvertGenoFile:
                 #self.latest_col_pos = item_count + self.skipped_cols
                 #self.latest_col_value = item
                 
-                #if item_count != 0:
+                # if item_count != 0:
                 #    self.output_fh.write(" ")
-                #self.output_fh.write(self.configurations[item.upper()])
+                # self.output_fh.write(self.configurations[item.upper()])
                     
-            #self.output_fh.write("\n")
+            # self.output_fh.write("\n")
 
 
     def process_rows(self):
         for self.latest_row_pos, row in enumerate(self.input_fh):
-            #if self.input_file.endswith(".geno.gz"):
+            # if self.input_file.endswith(".geno.gz"):
             #    print("row: ", row)
             self.latest_row_value = row
             # Take care of headers
@@ -176,21 +176,21 @@ class ConvertGenoFile:
                 print("    Row is:", convertob.latest_row_value)
                 break
             
-    #def process_snps_file(cls, snps_file, new_directory):
+    # def process_snps_file(cls, snps_file, new_directory):
     #    output_file = os.path.join(new_directory, "mouse_families.json")
     #    print("%s -> %s" % (snps_file, output_file))
     #    convertob = ConvertGenoFile(input_file, output_file)
         
 
 
-if __name__=="__main__":
+if __name__ == "__main__":
     Old_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype"""
     New_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype/json"""
     #Input_File = """/home/zas1024/gene/genotype_files/genotypes/BXD.geno"""
     #Output_File = """/home/zas1024/gene/wqflask/wqflask/pylmm/data/bxd.snps"""
     #convertob = ConvertGenoFile("/home/zas1024/gene/genotype_files/genotypes/SRxSHRSPF2.geno", "/home/zas1024/gene/genotype_files/new_genotypes/SRxSHRSPF2.json")
-    #convertob.convert()
+    # convertob.convert()
     ConvertGenoFile.process_all(Old_Geno_Directory, New_Geno_Directory)
-    #ConvertGenoFiles(Geno_Directory)
+    # ConvertGenoFiles(Geno_Directory)
     
     #process_csv(Input_File, Output_File)
diff --git a/wqflask/maintenance/quantile_normalize.py b/wqflask/maintenance/quantile_normalize.py
index 701b2b50..6751a8e5 100644
--- a/wqflask/maintenance/quantile_normalize.py
+++ b/wqflask/maintenance/quantile_normalize.py
@@ -20,10 +20,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db = parsed_uri.path[1:],
-                        host = parsed_uri.hostname,
-                        user = parsed_uri.username,
-                        passwd = parsed_uri.password)
+                        db=parsed_uri.path[1:],
+                        host=parsed_uri.hostname,
+                        user=parsed_uri.username,
+                        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
@@ -35,16 +35,16 @@ def create_dataframe(input_file):
     input_array = np.loadtxt(open(input_file, "rb"), delimiter="\t", skiprows=1, usecols=list(range(1, ncols)))
     return pd.DataFrame(input_array)
 
-#This function taken from https://github.com/ShawnLYU/Quantile_Normalize
+# This function taken from https://github.com/ShawnLYU/Quantile_Normalize
 def quantileNormalize(df_input):
     df = df_input.copy()
-    #compute rank
+    # compute rank
     dic = {}
     for col in df:
-        dic.update({col : sorted(df[col])})
+        dic.update({col: sorted(df[col])})
     sorted_df = pd.DataFrame(dic)
-    rank = sorted_df.mean(axis = 1).tolist()
-    #sort
+    rank = sorted_df.mean(axis=1).tolist()
+    # sort
     for col in df:
         t = np.searchsorted(np.sort(df[col]), df[col])
         df[col] = [rank[i] for i in t]
@@ -65,8 +65,8 @@ def set_data(dataset_name):
                 for i, sample in enumerate(sample_names):
                     this_sample = {
                                     "name": sample,
-                                    "value": line1.split('\t')[i+1],
-                                    "qnorm": line2.split('\t')[i+1]
+                                    "value": line1.split('\t')[i + 1],
+                                    "qnorm": line2.split('\t')[i + 1]
                                   }
                     sample_list.append(this_sample)
                 query = """SELECT Species.SpeciesName, InbredSet.InbredSetName, ProbeSetFreeze.FullName
@@ -99,9 +99,9 @@ if __name__ == '__main__':
     Conn = MySQLdb.Connect(**parse_db_uri())
     Cursor = Conn.cursor()
 
-    #es = Elasticsearch([{
+    # es = Elasticsearch([{
     #    "host": ELASTICSEARCH_HOST, "port": ELASTICSEARCH_PORT
-    #}], timeout=60) if (ELASTICSEARCH_HOST and ELASTICSEARCH_PORT) else None
+    # }], timeout=60) if (ELASTICSEARCH_HOST and ELASTICSEARCH_PORT) else None
 
     es = get_elasticsearch_connection(for_user=False)
 
@@ -116,8 +116,8 @@ if __name__ == '__main__':
     success, _ = bulk(es, set_data(sys.argv[1]))
 
     response = es.search(
-        index = "traits", doc_type = "trait", body = {
-            "query": { "match": { "name": "ENSMUSG00000028982" } }
+        index="traits", doc_type="trait", body = {
+            "query": {"match": {"name": "ENSMUSG00000028982"}}
         }
     )
 
diff --git a/wqflask/maintenance/set_resource_defaults.py b/wqflask/maintenance/set_resource_defaults.py
index 4177c124..286094dd 100644
--- a/wqflask/maintenance/set_resource_defaults.py
+++ b/wqflask/maintenance/set_resource_defaults.py
@@ -43,10 +43,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db = parsed_uri.path[1:],
-                        host = parsed_uri.hostname,
-                        user = parsed_uri.username,
-                        passwd = parsed_uri.password)
+                        db=parsed_uri.path[1:],
+                        host=parsed_uri.hostname,
+                        user=parsed_uri.username,
+                        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
@@ -63,14 +63,14 @@ def insert_probeset_resources(default_owner_id):
         resource_ob = {}
         resource_ob['name'] = resource[1]
         resource_ob['owner_id'] = default_owner_id
-        resource_ob['data'] = { "dataset" : str(resource[0])}
+        resource_ob['data'] = {"dataset": str(resource[0])}
         resource_ob['type'] = "dataset-probeset"
         if resource[2] < 1 and resource[3] > 0:
-            resource_ob['default_mask'] = { "data": "view",
+            resource_ob['default_mask'] = {"data": "view",
                                             "metadata": "view",
                                             "admin": "not-admin"}
         else:
-            resource_ob['default_mask'] = { "data": "no-access",
+            resource_ob['default_mask'] = {"data": "no-access",
                                             "metadata": "no-access",
                                             "admin": "not-admin"}
         resource_ob['group_masks'] = {}
@@ -97,10 +97,10 @@ def insert_publish_resources(default_owner_id):
             else:
                 resource_ob['name'] = str(resource[0])
             resource_ob['owner_id'] = default_owner_id
-            resource_ob['data'] = { "dataset" : str(resource[1]) ,
-                                    "trait"   : str(resource[0])}
+            resource_ob['data'] = {"dataset": str(resource[1]),
+                                    "trait": str(resource[0])}
             resource_ob['type'] = "dataset-publish"
-            resource_ob['default_mask'] = { "data": "view",
+            resource_ob['default_mask'] = {"data": "view",
                                             "metadata": "view",
                                             "admin": "not-admin"}
 
@@ -125,14 +125,14 @@ def insert_geno_resources(default_owner_id):
             resource_ob['owner_id'] = "c5ce8c56-78a6-474f-bcaf-7129d97f56ae"
         else:
             resource_ob['owner_id'] = default_owner_id
-        resource_ob['data'] = { "dataset" : str(resource[0]) }
+        resource_ob['data'] = {"dataset": str(resource[0])}
         resource_ob['type'] = "dataset-geno"
         if resource[2] < 1:
-            resource_ob['default_mask'] = { "data": "view",
+            resource_ob['default_mask'] = {"data": "view",
                                             "metadata": "view",
                                             "admin": "not-admin"}
         else:
-            resource_ob['default_mask'] = { "data": "no-access",
+            resource_ob['default_mask'] = {"data": "no-access",
                                             "metadata": "no-access",
                                             "admin": "not-admin"}
         resource_ob['group_masks'] = {}
diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index d0264b87..bd99838d 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -127,9 +127,9 @@ class TestCorrelations(unittest.TestCase):
         expected_pearsonr = [-0.21618688834430866, 0.680771605997119, 6]
         expected_spearmanr = [-0.11595420713048969, 0.826848213385815, 6]
         for i, val in enumerate(expected_pearsonr):
-            self.assertAlmostEqual(val, results_pearsonr[i],4)
+            self.assertAlmostEqual(val, results_pearsonr[i], 4)
         for i, val in enumerate(expected_spearmanr):
-            self.assertAlmostEqual(val, results_spearmanr[i],4)
+            self.assertAlmostEqual(val, results_spearmanr[i], 4)
         self.assertEqual(results_num_overlap, None)
 
     @mock.patch("wqflask.api.correlation.do_literature_correlation_for_all_traits")
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index fe2569b8..f194c6c9 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -47,11 +47,11 @@ class TestGemmaMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.run_mapping.random.choice")
     @mock.patch("wqflask.marker_regression.gemma_mapping.os")
     @mock.patch("wqflask.marker_regression.gemma_mapping.gen_pheno_txt_file")
-    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files,mock_parse_loco):
+    def test_run_gemma_firstrun_set_true(self, mock_gen_pheno_txt, mock_os, mock_choice, mock_gen_covar, mock_flat_files, mock_parse_loco):
         """add tests for run_gemma where first run is set to true"""
-        this_chromosomes={}
+        this_chromosomes = {}
         for i in range(1, 5):
-            this_chromosomes[f'CH{i}']=(AttributeSetter({"name": f"CH{i}"}))
+            this_chromosomes[f'CH{i}'] = (AttributeSetter({"name": f"CH{i}"}))
         chromosomes = AttributeSetter({"chromosomes": this_chromosomes})
 
         dataset_group = MockGroup(
@@ -68,9 +68,9 @@ class TestGemmaMapping(unittest.TestCase):
         mock_parse_loco.return_value = []
         results = run_gemma(this_trait=trait, this_dataset=dataset, samples=[
         ], vals=[], covariates="", use_loco=True)
-        self.assertEqual(mock_os.system.call_count,2)
+        self.assertEqual(mock_os.system.call_count, 2)
         mock_gen_pheno_txt.assert_called_once()
-        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR",True)
+        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR", True)
         mock_os.path.isfile.assert_called_once_with(
             ('/home/user/imgfile_output.assoc.txt'))
         self.assertEqual(mock_flat_files.call_count, 4)
@@ -144,7 +144,7 @@ class TestGemmaMapping(unittest.TestCase):
             "files": [["file_name", "user", "~/file1"],
                       ["file_name", "user", "~/file2"]]
         }
-        return_file="""X/Y\tM1\t28.457155\tQ\tE\tA\tMMB\t23.3\tW\t0.9\t0.85\t
+        return_file = """X/Y\tM1\t28.457155\tQ\tE\tA\tMMB\t23.3\tW\t0.9\t0.85\t
 chr4\tM2\t12\tQ\tE\tMMB\tR\t24\tW\t0.87\t0.5
 Y\tM4\t12\tQ\tE\tMMB\tR\t11.6\tW\t0.21\t0.7
 X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
@@ -159,7 +159,7 @@ X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
             mock_open.side_effect = handles
             results = parse_loco_output(
                 this_dataset={}, gwa_output_filename=".xw/")
-            expected_results= [
+            expected_results = [
             {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85, 'additive': 23.3, 'lod_score': 0.07058107428570727},
             {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5, 'additive': 24.0, 'lod_score': 0.3010299956639812},
             {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7, 'additive': 11.6, 'lod_score': 0.1549019599857432},
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index b47f877a..bbb79f98 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -1,20 +1,20 @@
 import unittest
-from unittest import  mock
-from wqflask.marker_regression.qtlreaper_mapping import  gen_pheno_txt_file
+from unittest import mock
+from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file
 
-#issues some methods in genofile object are not defined
-#modify samples should equal to vals
+# issues some methods in genofile object are not defined
+# modify samples should equal to vals
 class TestQtlReaperMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
-	def  test_gen_pheno_txt_file(self):                   
-		vals=["V1","x","V4","V3","x"]
-		samples=["S1","S2","S3","S4","S5"]
-		trait_filename="trait_file"
+	def test_gen_pheno_txt_file(self):                   
+		vals = ["V1", "x", "V4", "V3","x"]
+		samples = ["S1", "S2", "S3", "S4","S5"]
+		trait_filename = "trait_file"
 		with mock.patch("builtins.open", mock.mock_open())as mock_open:
-			gen_pheno_txt_file(samples=samples,vals=vals,trait_filename=trait_filename)
-			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt","w")
-			filehandler=mock_open()
-			write_calls= [mock.call('Trait\t'),mock.call('S1\tS3\tS4\n'),mock.call('T1\t'),mock.call('V1\tV4\tV3')]
+			gen_pheno_txt_file(samples=samples, vals=vals, trait_filename=trait_filename)
+			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
+			filehandler = mock_open()
+			write_calls = [mock.call('Trait\t'), mock.call('S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
 
 			filehandler.write.assert_has_calls(write_calls)
 
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index c585f1df..0e617e93 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -8,7 +8,7 @@ from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
 class TestRqtlMapping(unittest.TestCase):
 
 	def setUp(self):
-		self.app_context=app.app_context()
+		self.app_context = app.app_context()
 		self.app_context.push()
 
 	def tearDown(self):
@@ -17,28 +17,28 @@ class TestRqtlMapping(unittest.TestCase):
 
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-	def test_get_trait_data(self,mock_logger,mock_db):
+	def test_get_trait_data(self, mock_logger, mock_db):
 		"""test for getting trait data_type return True"""
-		query_value="""SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-		mock_db.db.execute.return_value.fetchone.return_value=["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
-		results=get_trait_data_type("traid_id")
+		query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+		mock_db.db.execute.return_value.fetchone.return_value = ["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+		results = get_trait_data_type("traid_id")
 		mock_db.db.execute.assert_called_with(query_value)
-		self.assertEqual(results,"fer434f")
+		self.assertEqual(results, "fer434f")
 
 	def test_sanitize_rqtl_phenotype(self):
 		"""test for sanitizing rqtl phenotype"""
-		vals=['f',"x","r","x","x"]
-		results=sanitize_rqtl_phenotype(vals)
-		expected_phenotype_string='c(f,NA,r,NA,NA)'
+		vals = ['f', "x", "r", "x","x"]
+		results = sanitize_rqtl_phenotype(vals)
+		expected_phenotype_string = 'c(f,NA,r,NA,NA)'
 
-		self.assertEqual(results,expected_phenotype_string)
+		self.assertEqual(results, expected_phenotype_string)
 
 	def test_sanitize_rqtl_names(self):
 		"""test for sanitzing rqtl names"""
-		vals=['f',"x","r","x","x"]
-		expected_sanitized_name="c('f',NA,'r',NA,NA)"
-		results=sanitize_rqtl_names(vals)
-		self.assertEqual(expected_sanitized_name,results)
+		vals = ['f', "x", "r", "x","x"]
+		expected_sanitized_name = "c('f',NA,'r',NA,NA)"
+		results = sanitize_rqtl_names(vals)
+		self.assertEqual(expected_sanitized_name, results)
 
 
 		
diff --git a/wqflask/tests/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
index 34c51e3e..441a88a7 100644
--- a/wqflask/tests/wqflask/show_trait/testSampleList.py
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -10,7 +10,7 @@ class TestSampleList(unittest.TestCase):
 
         characters_list = ["z", "f", "q", "s", "t", "a", "g"]
         names_list = ["temp1", "publish", "Sample", "Dataset"]
-        sorted_list_a=natural_sort(characters_list)
-        sorted_list_b=natural_sort(names_list)
+        sorted_list_a = natural_sort(characters_list)
+        sorted_list_b = natural_sort(names_list)
         self.assertEqual(sorted_list_a, ["a", "f", "g", "q", "s", "t", "z"])
-        self.assertEqual(sorted_list_b,["Dataset", "Sample", "publish", "temp1"])
+        self.assertEqual(sorted_list_b, ["Dataset", "Sample", "publish", "temp1"])
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index 61f408d2..68c2cb72 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -34,7 +34,7 @@ import utility.corestats as corestats
 from base import webqtlConfig
 from utility.pillow_utils import draw_rotated_text
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 # ---- Define common colours ---- #
 BLUE = ImageColor.getrgb("blue")
@@ -74,7 +74,7 @@ def frange(start, end=None, inc=1.0):
         end = start + 0.0
         start = 0.0
     else:
-        start += 0.0 # force it to be a float
+        start += 0.0  # force it to be a float
     count = int((end - start) / inc)
     if start + count * inc != end:
     # Need to adjust the count. AFAICT, it always comes up one short.
@@ -119,13 +119,13 @@ def find_outliers(vals):
 
 # parameter: data is either object returned by reaper permutation function (called by MarkerRegressionPage.py)
 # or the first object returned by direct (pair-scan) permu function (called by DirectPlotPage.py)
-def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLabel=None, YLabel=None, title=None, offset= (60, 20, 40, 40), zoom = 1):
+def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLabel=None, YLabel=None, title=None, offset=(60, 20, 40, 40), zoom=1):
     im_drawer = ImageDraw.Draw(canvas)
     xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
 
     plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
     plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
-    if plotHeight<=0 or plotWidth<=0:
+    if plotHeight <= 0 or plotWidth <= 0:
        return
 
     if len(data) < 2:
@@ -133,15 +133,15 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
 
     max_D = max(data)
     min_D = min(data)
-    #add by NL 06-20-2011: fix the error: when max_D is infinite, log function in detScale will go wrong
-    if max_D == float('inf') or max_D>webqtlConfig.MAXLRS:
-       max_D=webqtlConfig.MAXLRS #maximum LRS value
+    # add by NL 06-20-2011: fix the error: when max_D is infinite, log function in detScale will go wrong
+    if max_D == float('inf') or max_D > webqtlConfig.MAXLRS:
+       max_D = webqtlConfig.MAXLRS  # maximum LRS value
 
     xLow, xTop, stepX = detScale(min_D, max_D)
 
-    #reduce data
-    #ZS: Used to determine number of bins for permutation output
-    step = ceil((xTop-xLow)/50.0)
+    # reduce data
+    # ZS: Used to determine number of bins for permutation output
+    step = ceil((xTop - xLow) / 50.0)
     j = xLow
     dataXY = []
     Count = []
@@ -151,122 +151,122 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
        j += step
 
     for i, item in enumerate(data):
-       if item == float('inf') or item>webqtlConfig.MAXLRS:
-           item = webqtlConfig.MAXLRS #maximum LRS value
-       j = int((item-xLow)/step)
+       if item == float('inf') or item > webqtlConfig.MAXLRS:
+           item = webqtlConfig.MAXLRS  # maximum LRS value
+       j = int((item - xLow) / step)
        Count[j] += 1
 
-    yLow, yTop, stepY=detScale(0, max(Count))
+    yLow, yTop, stepY = detScale(0, max(Count))
 
-    #draw data
-    xScale = plotWidth/(xTop-xLow)
-    yScale = plotHeight/(yTop-yLow)
-    barWidth = xScale*step
+    # draw data
+    xScale = plotWidth / (xTop - xLow)
+    yScale = plotHeight / (yTop - yLow)
+    barWidth = xScale * step
 
     for i, count in enumerate(Count):
        if count:
-           xc = (dataXY[i]-xLow)*xScale+xLeftOffset
-           yc =-(count-yLow)*yScale+yTopOffset+plotHeight
+           xc = (dataXY[i] - xLow) * xScale + xLeftOffset
+           yc = -(count - yLow) * yScale + yTopOffset + plotHeight
            im_drawer.rectangle(
-               xy=((xc+2, yc), (xc+barWidth-2, yTopOffset+plotHeight)),
+               xy=((xc + 2, yc), (xc + barWidth - 2, yTopOffset + plotHeight)),
                outline=barColor, fill=barColor)
 
-    #draw drawing region
+    # draw drawing region
     im_drawer.rectangle(
-        xy=((xLeftOffset, yTopOffset), (xLeftOffset+plotWidth, yTopOffset+plotHeight))
+        xy=((xLeftOffset, yTopOffset), (xLeftOffset + plotWidth, yTopOffset + plotHeight))
     )
 
-    #draw scale
-    scaleFont=ImageFont.truetype(font=COUR_FILE, size=11)
-    x=xLow
-    for i in range(int(stepX)+1):
-       xc=xLeftOffset+(x-xLow)*xScale
+    # draw scale
+    scaleFont = ImageFont.truetype(font=COUR_FILE, size=11)
+    x = xLow
+    for i in range(int(stepX) + 1):
+       xc = xLeftOffset + (x - xLow) * xScale
        im_drawer.line(
-           xy=((xc, yTopOffset+plotHeight), (xc, yTopOffset+plotHeight+5)),
+           xy=((xc, yTopOffset + plotHeight), (xc, yTopOffset + plotHeight + 5)),
            fill=axesColor)
        strX = cformat(d=x, rank=0)
        im_drawer.text(
            text=strX,
-           xy=(xc-im_drawer.textsize(strX, font=scaleFont)[0]/2,
-               yTopOffset+plotHeight+14), font=scaleFont)
-       x+= (xTop - xLow)/stepX
-
-    y=yLow
-    for i in range(int(stepY)+1):
-       yc=yTopOffset+plotHeight-(y-yLow)*yScale
-       im_drawer.line(xy=((xLeftOffset, yc), (xLeftOffset-5, yc)), fill=axesColor)
-       strY = "%d" %y
+           xy=(xc - im_drawer.textsize(strX, font=scaleFont)[0] / 2,
+               yTopOffset + plotHeight + 14), font=scaleFont)
+       x += (xTop - xLow) / stepX
+
+    y = yLow
+    for i in range(int(stepY) + 1):
+       yc = yTopOffset + plotHeight - (y - yLow) * yScale
+       im_drawer.line(xy=((xLeftOffset, yc), (xLeftOffset - 5, yc)), fill=axesColor)
+       strY = "%d" % y
        im_drawer.text(
            text=strY,
-           xy=(xLeftOffset-im_drawer.textsize(strY, font=scaleFont)[0]-6, yc+5),
+           xy=(xLeftOffset - im_drawer.textsize(strY, font=scaleFont)[0] - 6, yc + 5),
            font=scaleFont)
-       y+= (yTop - yLow)/stepY
+       y += (yTop - yLow) / stepY
 
-    #draw label
-    labelFont=ImageFont.truetype(font=TAHOMA_FILE, size=17)
+    # draw label
+    labelFont = ImageFont.truetype(font=TAHOMA_FILE, size=17)
     if XLabel:
        im_drawer.text(
            text=XLabel,
-           xy=(xLeftOffset+(
-               plotWidth-im_drawer.textsize(XLabel, font=labelFont)[0])/2.0,
-               yTopOffset+plotHeight+yBottomOffset-10),
+           xy=(xLeftOffset + (
+               plotWidth - im_drawer.textsize(XLabel, font=labelFont)[0]) / 2.0,
+               yTopOffset + plotHeight + yBottomOffset-10),
            font=labelFont, fill=labelColor)
 
     if YLabel:
         draw_rotated_text(canvas, text=YLabel,
                           xy=(19,
-                              yTopOffset+plotHeight-(
-                                  plotHeight-im_drawer.textsize(
-                                      YLabel, font=labelFont)[0])/2.0),
+                              yTopOffset + plotHeight - (
+                                  plotHeight - im_drawer.textsize(
+                                      YLabel, font=labelFont)[0]) / 2.0),
                           font=labelFont, fill=labelColor, angle=90)
 
-    labelFont=ImageFont.truetype(font=VERDANA_FILE, size=16)
+    labelFont = ImageFont.truetype(font=VERDANA_FILE, size=16)
     if title:
        im_drawer.text(
            text=title,
-           xy=(xLeftOffset+(plotWidth-im_drawer.textsize(
-               title, font=labelFont)[0])/2.0,
+           xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
+               title, font=labelFont)[0]) / 2.0,
                20),
            font=labelFont, fill=labelColor)
 
 # This function determines the scale of the plot
 def detScaleOld(min, max):
-    if min>=max:
+    if min >= max:
         return None
     elif min == -1.0 and max == 1.0:
         return [-1.2, 1.2, 12]
     else:
-        a=max-min
-        b=floor(log10(a))
-        c=pow(10.0, b)
-        if a < c*5.0:
-            c/=2.0
-        #print a,b,c
-        low=c*floor(min/c)
-        high=c*ceil(max/c)
-        return [low, high, round((high-low)/c)]
-
-def detScale(min=0,max=0):
-
-    if min>=max:
+        a = max - min
+        b = floor(log10(a))
+        c = pow(10.0, b)
+        if a < c * 5.0:
+            c /= 2.0
+        # print a,b,c
+        low = c * floor(min / c)
+        high = c * ceil(max / c)
+        return [low, high, round((high - low) / c)]
+
+def detScale(min=0, max=0):
+
+    if min >= max:
         return None
     elif min == -1.0 and max == 1.0:
         return [-1.2, 1.2, 12]
     else:
-        a=max-min
+        a = max - min
         if max != 0:
-            max += 0.1*a
+            max += 0.1 * a
         if min != 0:
-            if min > 0 and min < 0.1*a:
+            if min > 0 and min < 0.1 * a:
                 min = 0.0
             else:
-                min -= 0.1*a
-        a=max-min
-        b=floor(log10(a))
-        c=pow(10.0, b)
-        low=c*floor(min/c)
-        high=c*ceil(max/c)
-        n = round((high-low)/c)
+                min -= 0.1 * a
+        a = max - min
+        b = floor(log10(a))
+        c = pow(10.0, b)
+        low = c * floor(min / c)
+        high = c * ceil(max / c)
+        n = round((high - low) / c)
         div = 2.0
         while n < 5 or n > 15:
             if n < 5:
@@ -274,23 +274,23 @@ def detScale(min=0,max=0):
             else:
                 c *= div
             if div == 2.0:
-                div =5.0
+                div = 5.0
             else:
-                div =2.0
-            low=c*floor(min/c)
-            high=c*ceil(max/c)
-            n = round((high-low)/c)
+                div = 2.0
+            low = c * floor(min / c)
+            high = c * ceil(max / c)
+            n = round((high - low) / c)
 
         return [low, high, n]
 
 def bluefunc(x):
-    return 1.0 / (1.0 + exp(-10*(x-0.6)))
+    return 1.0 / (1.0 + exp(-10 * (x - 0.6)))
 
 def redfunc(x):
-    return 1.0 / (1.0 + exp(10*(x-0.5)))
+    return 1.0 / (1.0 + exp(10 * (x - 0.5)))
 
 def greenfunc(x):
-    return 1 - pow(redfunc(x+0.2), 2) - bluefunc(x-0.3)
+    return 1 - pow(redfunc(x + 0.2), 2) - bluefunc(x - 0.3)
 
 def colorSpectrum(n=100):
     multiple = 10
@@ -303,17 +303,17 @@ def colorSpectrum(n=100):
         return [ImageColor.getrgb("rgb(100%,0%,0%)"),
                 ImageColor.getrgb("rgb(0%,100%,0%)"),
                 ImageColor.getrgb("rgb(0%,0%,100%)")]
-    N = n*multiple
-    out = [None]*N;
+    N = n * multiple
+    out = [None] * N;
     for i in range(N):
-        x = float(i)/N
+        x = float(i) / N
         out[i] = ImageColor.getrgb("rgb({}%,{}%,{}%".format(
-            *[int(i*100) for i in (
+            *[int(i * 100) for i in (
                 redfunc(x), greenfunc(x), bluefunc(x))]))
     out2 = [out[0]]
-    step = N/float(n-1)
+    step = N / float(n - 1)
     j = 0
-    for i in range(n-2):
+    for i in range(n - 2):
         j += step
         out2.append(out[int(j)])
     out2.append(out[-1])
@@ -324,5 +324,5 @@ def _test():
     doctest.testmod()
 
 
-if __name__=="__main__":
+if __name__ == "__main__":
     _test()
diff --git a/wqflask/utility/TDCell.py b/wqflask/utility/TDCell.py
index 8de8e050..4b0f4b1d 100644
--- a/wqflask/utility/TDCell.py
+++ b/wqflask/utility/TDCell.py
@@ -33,9 +33,9 @@
 
 class TDCell:
     def __init__(self, html="", text="", val=0.0):
-        self.html = html        #html, for web page
-        self.text = text        #text value, for output to a text file
-        self.val = val          #sort by value
+        self.html = html  # html, for web page
+        self.text = text  # text value, for output to a text file
+        self.val = val  # sort by value
 
     def __str__(self):
         return self.text
diff --git a/wqflask/utility/THCell.py b/wqflask/utility/THCell.py
index dde221b5..f533dcb8 100644
--- a/wqflask/utility/THCell.py
+++ b/wqflask/utility/THCell.py
@@ -33,10 +33,10 @@
 
 class THCell:
     def __init__(self, html="", text="", sort=1, idx=-1):
-        self.html = html        #html, for web page
-        self.text = text        #Column text value
-        self.sort = sort        #0: not sortable, 1: yes
-        self.idx = idx          #sort by value
+        self.html = html  # html, for web page
+        self.text = text  # Column text value
+        self.sort = sort  # 0: not sortable, 1: yes
+        self.idx = idx  # sort by value
 
     def __str__(self):
         return self.text
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index df926884..ec7e72d0 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -4,7 +4,7 @@ from pprint import pformat as pf
 
 class Bunch:
     """Like a dictionary but using object notation"""
-    def __init__(self,  **kw):
+    def __init__(self, **kw):
             self.__dict__ = kw
 
     def __repr__(self):
diff --git a/wqflask/utility/benchmark.py b/wqflask/utility/benchmark.py
index 91ea91e8..3d40a3b8 100644
--- a/wqflask/utility/benchmark.py
+++ b/wqflask/utility/benchmark.py
@@ -4,7 +4,7 @@ import time
 from utility.tools import LOG_BENCH
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 class Bench:
     entries = collections.OrderedDict()
@@ -39,7 +39,7 @@ class Bench:
         total_time = sum((time_taken for time_taken in list(cls.entries.values())))
         print("\nTiming report\n")
         for name, time_taken in list(cls.entries.items()):
-            percent = int(round((time_taken/total_time) * 100))
+            percent = int(round((time_taken / total_time) * 100))
             print("[{}%] {}: {}".format(percent, name, time_taken))
         print()
 
diff --git a/wqflask/utility/chunks.py b/wqflask/utility/chunks.py
index 9a7db102..484b5de6 100644
--- a/wqflask/utility/chunks.py
+++ b/wqflask/utility/chunks.py
@@ -26,6 +26,6 @@ def divide_into_chunks(the_list, number_chunks):
 
     chunks = []
     for counter in range(0, length, chunksize):
-        chunks.append(the_list[counter:counter+chunksize])
+        chunks.append(the_list[counter:counter + chunksize])
 
     return chunks
diff --git a/wqflask/utility/corestats.py b/wqflask/utility/corestats.py
index 67ca3ad3..15d1cb8d 100644
--- a/wqflask/utility/corestats.py
+++ b/wqflask/utility/corestats.py
@@ -15,7 +15,7 @@
 
 import sys
 
-#ZS: Should switch to using some third party library for this; maybe scipy has an equivalent
+# ZS: Should switch to using some third party library for this; maybe scipy has an equivalent
 class Stats:
 
     def __init__(self, sequence):
@@ -63,7 +63,7 @@ class Stats:
         if len(self.sequence) < 1:
             value = None
         elif (percentile >= 100):
-            sys.stderr.write('ERROR: percentile must be < 100.  you supplied: %s\n'% percentile)
+            sys.stderr.write('ERROR: percentile must be < 100.  you supplied: %s\n' % percentile)
             value = None
         else:
             element_idx = int(len(self.sequence) * (percentile / 100.0))
@@ -80,4 +80,4 @@ class Stats:
 #    stats = corestats.Stats(sequence)
 #    print stats.avg()
 #    print stats.percentile(90)
-# -------------------------------------------
\ No newline at end of file
+# -------------------------------------------
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index a5580811..ae1181e4 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -48,7 +48,7 @@ logger = getLogger(__name__)
 from utility.tools import ELASTICSEARCH_HOST, ELASTICSEARCH_PORT
 
 def test_elasticsearch_connection():
-    es = Elasticsearch(['http://'+ELASTICSEARCH_HOST+":"+str(ELASTICSEARCH_PORT)+'/'], verify_certs=True)
+    es = Elasticsearch(['http://' + ELASTICSEARCH_HOST + ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
     if not es.ping():
         logger.warning("Elasticsearch is DOWN")
 
@@ -97,8 +97,8 @@ def get_item_by_unique_column(es, column_name, column_value, index, doc_type):
     item_details = None
     try:
         response = es.search(
-            index = index, doc_type = doc_type, body = {
-                "query": { "match": { column_name: column_value } }
+            index=index, doc_type=doc_type, body = {
+                "query": {"match": {column_name: column_value}}
             })
         if len(response["hits"]["hits"]) > 0:
             item_details = response["hits"]["hits"][0]["_source"]
@@ -109,4 +109,4 @@ def get_item_by_unique_column(es, column_name, column_value, index, doc_type):
 def es_save_data(es, index, doc_type, data_item, data_id,):
     from time import sleep
     es.create(index, doc_type, body=data_item, id=data_id)
-    sleep(1) # Delay 1 second to allow indexing
+    sleep(1)  # Delay 1 second to allow indexing
diff --git a/wqflask/utility/external.py b/wqflask/utility/external.py
index 50afea08..c1bf4043 100644
--- a/wqflask/utility/external.py
+++ b/wqflask/utility/external.py
@@ -6,4 +6,4 @@ import subprocess
 
 def shell(command):
     if subprocess.call(command, shell=True) != 0:
-        raise Exception("ERROR: failed on "+command)
+        raise Exception("ERROR: failed on " + command)
diff --git a/wqflask/utility/gen_geno_ob.py b/wqflask/utility/gen_geno_ob.py
index 0a381c9b..9cfa39f9 100644
--- a/wqflask/utility/gen_geno_ob.py
+++ b/wqflask/utility/gen_geno_ob.py
@@ -1,5 +1,5 @@
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class genotype:
     """
@@ -18,7 +18,7 @@ class genotype:
         self.filler = False
         self.mb_exists = False
 
-        #ZS: This is because I'm not sure if some files switch the column that contains Mb/cM positions; might be unnecessary
+        # ZS: This is because I'm not sure if some files switch the column that contains Mb/cM positions; might be unnecessary
         self.cm_column = 2
         self.mb_column = 3
 
@@ -36,14 +36,14 @@ class genotype:
         return len(self.chromosomes)
 
     def read_rdata_output(self, qtl_results):
-        #ZS: This is necessary because R/qtl requires centimorgan marker positions, which it normally gets from the .geno file, but that doesn't exist for HET3-ITP (which only has RData), so it needs to read in the marker cM positions from the results
-        self.chromosomes = [] #ZS: Overwriting since the .geno file's contents are just placeholders
+        # ZS: This is necessary because R/qtl requires centimorgan marker positions, which it normally gets from the .geno file, but that doesn't exist for HET3-ITP (which only has RData), so it needs to read in the marker cM positions from the results
+        self.chromosomes = []  # ZS: Overwriting since the .geno file's contents are just placeholders
 
-        this_chr = "" #ZS: This is so it can track when the chromosome changes as it iterates through markers
+        this_chr = ""  # ZS: This is so it can track when the chromosome changes as it iterates through markers
         chr_ob = None
         for marker in qtl_results:
             locus = Locus(self)
-            if (str(marker['chr']) != this_chr) and this_chr != "X": #ZS: This is really awkward but works as a temporary fix
+            if (str(marker['chr']) != this_chr) and this_chr != "X":  # ZS: This is really awkward but works as a temporary fix
                 if this_chr != "":
                     self.chromosomes.append(chr_ob)
                 this_chr = str(marker['chr'])
@@ -68,7 +68,7 @@ class genotype:
         with open(filename, 'r') as geno_file:
             lines = geno_file.readlines()
 
-            this_chr = "" #ZS: This is so it can track when the chromosome changes as it iterates through markers
+            this_chr = ""  # ZS: This is so it can track when the chromosome changes as it iterates through markers
             chr_ob = None
             for line in lines:
                 if line[0] == "#":
@@ -141,7 +141,7 @@ class Chr:
         self.loci.append(Locus(self.geno_ob, marker_row))
 
 class Locus:
-    def __init__(self, geno_ob, marker_row = None):
+    def __init__(self, geno_ob, marker_row=None):
         self.chr = None
         self.name = None
         self.cM = None
@@ -175,5 +175,5 @@ class Locus:
             for allele in marker_row[start_pos:]:
                 if allele in list(geno_table.keys()):
                     self.genotype.append(geno_table[allele])
-                else: #ZS: Some genotype appears that isn't specified in the metadata, make it unknown
+                else:  # ZS: Some genotype appears that isn't specified in the metadata, make it unknown
                     self.genotype.append("U")
diff --git a/wqflask/utility/helper_functions.py b/wqflask/utility/helper_functions.py
index 12fd6be5..ecc075ae 100644
--- a/wqflask/utility/helper_functions.py
+++ b/wqflask/utility/helper_functions.py
@@ -39,7 +39,7 @@ def get_trait_db_obs(self, trait_db_list):
     for trait in trait_db_list:
         data, _separator, hmac_string = trait.rpartition(':')
         data = data.strip()
-        assert hmac_string==hmac.hmac_creation(data), "Data tampering?"
+        assert hmac_string == hmac.hmac_creation(data), "Data tampering?"
         trait_name, dataset_name = data.split(":")[:2]
         if dataset_name == "Temp":
             dataset_ob = data_set.create_dataset(
diff --git a/wqflask/utility/logger.py b/wqflask/utility/logger.py
index e904eb94..16912e58 100644
--- a/wqflask/utility/logger.py
+++ b/wqflask/utility/logger.py
@@ -49,14 +49,14 @@ class GNLogger:
         """Set the undelying log level"""
         self.logger.setLevel(value)
 
-    def debug(self,*args):
+    def debug(self, *args):
         """Call logging.debug for multiple args. Use (lazy) debugf and
 level=num to filter on LOG_LEVEL_DEBUG.
 
         """
         self.collect(self.logger.debug, *args)
 
-    def debug20(self,*args):
+    def debug20(self, *args):
         """Call logging.debug for multiple args. Use level=num to filter on
 LOG_LEVEL_DEBUG (NYI).
 
@@ -65,29 +65,29 @@ LOG_LEVEL_DEBUG (NYI).
             if self.logger.getEffectiveLevel() < 20:
                 self.collect(self.logger.debug, *args)
 
-    def info(self,*args):
+    def info(self, *args):
         """Call logging.info for multiple args"""
         self.collect(self.logger.info, *args)
 
-    def warning(self,*args):
+    def warning(self, *args):
         """Call logging.warning for multiple args"""
         self.collect(self.logger.warning, *args)
         # self.logger.warning(self.collect(*args))
 
-    def error(self,*args):
+    def error(self, *args):
         """Call logging.error for multiple args"""
         now = datetime.datetime.utcnow()
         time_str = now.strftime('%H:%M:%S UTC %Y%m%d')
-        l = [time_str]+list(args)
+        l = [time_str] + list(args)
         self.collect(self.logger.error, *l)
 
-    def infof(self,*args):
+    def infof(self, *args):
         """Call logging.info for multiple args lazily"""
         # only evaluate function when logging
         if self.logger.getEffectiveLevel() < 30:
             self.collectf(self.logger.debug, *args)
 
-    def debugf(self,level=0,*args):
+    def debugf(self, level=0, *args):
         """Call logging.debug for multiple args lazily and handle
         LOG_LEVEL_DEBUG correctly
 
@@ -97,7 +97,7 @@ LOG_LEVEL_DEBUG (NYI).
             if self.logger.getEffectiveLevel() < 20:
                 self.collectf(self.logger.debug, *args)
 
-    def sql(self, sqlcommand, fun = None):
+    def sql(self, sqlcommand, fun=None):
         """Log SQL command, optionally invoking a timed fun"""
         if LOG_SQL:
             caller = stack()[1][3]
@@ -110,11 +110,11 @@ LOG_LEVEL_DEBUG (NYI).
                 self.info(result)
             return result
 
-    def collect(self,fun,*args):
+    def collect(self, fun, *args):
         """Collect arguments and use fun to output"""
-        out = "."+stack()[2][3]
+        out = "." + stack()[2][3]
         for a in args:
-            if len(out)>1:
+            if len(out) > 1:
                 out += ": "
             if isinstance(a, str):
                 out = out + a
@@ -122,11 +122,11 @@ LOG_LEVEL_DEBUG (NYI).
                 out = out + pf(a, width=160)
         fun(out)
 
-    def collectf(self,fun,*args):
+    def collectf(self, fun, *args):
         """Collect arguments and use fun to output one by one"""
-        out = "."+stack()[2][3]
+        out = "." + stack()[2][3]
         for a in args:
-            if len(out)>1:
+            if len(out) > 1:
                 out += ": "
                 if isfunction(a):
                     out += a()
@@ -139,7 +139,7 @@ LOG_LEVEL_DEBUG (NYI).
 
 # Get the module logger. You can override log levels at the
 # module level
-def getLogger(name, level = None):
+def getLogger(name, level=None):
     gnlogger = GNLogger(name)
     logger = gnlogger.logger
 
@@ -148,5 +148,5 @@ def getLogger(name, level = None):
     else:
         logger.setLevel(LOG_LEVEL)
 
-    logger.info("Log level of "+name+" set to "+logging.getLevelName(logger.getEffectiveLevel()))
+    logger.info("Log level of " + name + " set to " + logging.getLevelName(logger.getEffectiveLevel()))
     return gnlogger
diff --git a/wqflask/utility/pillow_utils.py b/wqflask/utility/pillow_utils.py
index c486abba..6e95beb0 100644
--- a/wqflask/utility/pillow_utils.py
+++ b/wqflask/utility/pillow_utils.py
@@ -3,7 +3,7 @@ from PIL import Image, ImageColor, ImageDraw, ImageFont
 from utility.tools import TEMPDIR
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 BLACK = ImageColor.getrgb("black")
 WHITE = ImageColor.getrgb("white")
diff --git a/wqflask/utility/startup_config.py b/wqflask/utility/startup_config.py
index f1aaebb6..f22f4b14 100644
--- a/wqflask/utility/startup_config.py
+++ b/wqflask/utility/startup_config.py
@@ -3,12 +3,12 @@ from wqflask import app
 from utility.tools import WEBSERVER_MODE, show_settings, get_setting_int, get_setting, get_setting_bool
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
-BLUE  = '\033[94m'
+BLUE = '\033[94m'
 GREEN = '\033[92m'
-BOLD  = '\033[1m'
-ENDC  = '\033[0m'
+BOLD = '\033[1m'
+ENDC = '\033[0m'
 
 def app_config():
     app.config['SESSION_TYPE'] = 'filesystem'
@@ -27,7 +27,7 @@ def app_config():
     port = get_setting_int("SERVER_PORT")
 
     if get_setting_bool("USE_GN_SERVER"):
-        print(("GN2 API server URL is ["+BLUE+get_setting("GN_SERVER_URL")+ENDC+"]"))
+        print(("GN2 API server URL is [" + BLUE + get_setting("GN_SERVER_URL") + ENDC + "]"))
         import requests
         page = requests.get(get_setting("GN_SERVER_URL"))
         if page.status_code != 200:
diff --git a/wqflask/utility/svg.py b/wqflask/utility/svg.py
index b92cc2d1..4c478c36 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -172,7 +172,7 @@ def _viewboxlist(a):
     """formats a tuple"""
     s = ''
     for e in a:
-        s += str(e)+' '
+        s += str(e) + ' '
     return s
 
 
@@ -189,7 +189,7 @@ class pathdata:
     def __init__(self, x=None, y=None):
         self.path = []
         if x is not None and y is not None:
-            self.path.append('M '+str(x)+' '+str(y))
+            self.path.append('M ' + str(x) + ' ' + str(y))
 
     def closepath(self):
         """ends the path"""
@@ -197,79 +197,79 @@ class pathdata:
 
     def move(self, x, y):
         """move to absolute"""
-        self.path.append('M '+str(x)+' '+str(y))
+        self.path.append('M ' + str(x) + ' ' + str(y))
 
     def relmove(self, x, y):
         """move to relative"""
-        self.path.append('m '+str(x)+' '+str(y))
+        self.path.append('m ' + str(x) + ' ' + str(y))
 
     def line(self, x, y):
         """line to absolute"""
-        self.path.append('L '+str(x)+' '+str(y))
+        self.path.append('L ' + str(x) + ' ' + str(y))
 
     def relline(self, x, y):
         """line to relative"""
-        self.path.append('l '+str(x)+' '+str(y))
+        self.path.append('l ' + str(x) + ' ' + str(y))
 
     def hline(self, x):
         """horizontal line to absolute"""
-        self.path.append('H'+str(x))
+        self.path.append('H' + str(x))
 
     def relhline(self, x):
         """horizontal line to relative"""
-        self.path.append('h'+str(x))
+        self.path.append('h' + str(x))
 
     def vline(self, y):
         """verical line to absolute"""
-        self.path.append('V'+str(y))
+        self.path.append('V' + str(y))
 
     def relvline(self, y):
         """vertical line to relative"""
-        self.path.append('v'+str(y))
+        self.path.append('v' + str(y))
 
     def bezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy absolut"""
-        self.path.append('C'+str(x1)+','+str(y1)+' '+str(x2) +
-                         ','+str(y2)+' '+str(x)+','+str(y))
+        self.path.append('C' + str(x1) + ','+str(y1)+' '+str(x2) +
+                         ',' + str(y2) + ' '+str(x)+','+str(y))
 
     def relbezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy relative"""
-        self.path.append('c'+str(x1)+','+str(y1)+' '+str(x2) +
-                         ','+str(y2)+' '+str(x)+','+str(y))
+        self.path.append('c' + str(x1) + ','+str(y1)+' '+str(x2) +
+                         ',' + str(y2) + ' '+str(x)+','+str(y))
 
     def smbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy absolut"""
-        self.path.append('S'+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
+        self.path.append('S' + str(x2) + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
 
     def relsmbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy relative"""
-        self.path.append('s'+str(x2)+','+str(y2)+' '+str(x)+','+str(y))
+        self.path.append('s' + str(x2) + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
 
     def qbezier(self, x1, y1, x, y):
         """quadratic bezier with xy1 to xy absolut"""
-        self.path.append('Q'+str(x1)+','+str(y1)+' '+str(x)+','+str(y))
+        self.path.append('Q' + str(x1) + ',' + str(y1) + ' ' + str(x) + ',' + str(y))
 
     def relqbezier(self, x1, y1, x, y):
         """quadratic bezier with xy1 to xy relative"""
-        self.path.append('q'+str(x1)+','+str(y1)+' '+str(x)+','+str(y))
+        self.path.append('q' + str(x1) + ',' + str(y1) + ' ' + str(x) + ',' + str(y))
 
     def smqbezier(self, x, y):
         """smooth quadratic bezier to xy absolut"""
-        self.path.append('T'+str(x)+','+str(y))
+        self.path.append('T' + str(x) + ',' + str(y))
 
     def relsmqbezier(self, x, y):
         """smooth quadratic bezier to xy relative"""
-        self.path.append('t'+str(x)+','+str(y))
+        self.path.append('t' + str(x) + ',' + str(y))
 
     def ellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy absolut"""
-        self.path.append('A'+str(rx)+','+str(ry)+' '+str(xrot) +
-                         ' '+str(laf)+' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('A' + str(rx) + ','+str(ry)+' '+str(xrot) +
+                         ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
 
     def relellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy relative"""
-        self.path.append('a'+str(rx)+','+str(ry)+' '+str(xrot) +
-                         ' '+str(laf)+' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('a' + str(rx) + ','+str(ry)+' '+str(xrot) +
+                         ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
 
     def __repr__(self):
         return ' '.join(self.path)
@@ -312,10 +312,10 @@ class SVGelement:
         self.elements.append(SVGelement)
 
     def toXml(self, level, f):
-        f.write('\t'*level)
-        f.write('<'+self.type)
+        f.write('\t' * level)
+        f.write('<' + self.type)
         for attkey in list(self.attributes.keys()):
-            f.write(' '+_escape(str(attkey))+'=' +
+            f.write(' ' + _escape(str(attkey)) + '=' +
                     _quoteattr(str(self.attributes[attkey])))
         if self.namespace:
             f.write(' xmlns="' + _escape(str(self.namespace)) +
@@ -325,23 +325,23 @@ class SVGelement:
         if self.elements:
             f.write('\n')
         for element in self.elements:
-            element.toXml(level+1, f)
+            element.toXml(level + 1, f)
         if self.cdata:
-            f.write('\n'+'\t'*(level+1)+'<![CDATA[')
+            f.write('\n' + '\t' * (level + 1) + '<![CDATA[')
             for line in self.cdata.splitlines():
-                f.write('\n'+'\t'*(level+2)+line)
-            f.write('\n'+'\t'*(level+1)+']]>\n')
+                f.write('\n' + '\t' * (level + 2) + line)
+            f.write('\n' + '\t' * (level + 1) + ']]>\n')
         if self.text:
             if isinstance(self.text, type('')):  # If the text is only text
                 f.write(_escape(str(self.text)))
             else:  # If the text is a spannedtext class
                 f.write(str(self.text))
         if self.elements:
-            f.write('\t'*level+'</'+self.type+'>\n')
+            f.write('\t' * level + '</' + self.type + '>\n')
         elif self.text:
-            f.write('</'+self.type+'>\n')
+            f.write('</' + self.type + '>\n')
         elif self.cdata:
-            f.write('\t'*level+'</'+self.type+'>\n')
+            f.write('\t' * level + '</' + self.type + '>\n')
         else:
             f.write('/>\n')
 
@@ -447,38 +447,38 @@ class rect(SVGelement):
         if width == None or height == None:
             raise ValueError('both height and width are required')
 
-        SVGelement.__init__(self, 'rect', {'width':width,'height':height}, **args)
-        if x!=None:
-            self.attributes['x']=x
-        if y!=None:
-            self.attributes['y']=y
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke!=None:
-            self.attributes['stroke']=stroke
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
+        SVGelement.__init__(self, 'rect', {'width': width, 'height': height}, **args)
+        if x != None:
+            self.attributes['x'] = x
+        if y != None:
+            self.attributes['y'] = y
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke != None:
+            self.attributes['stroke'] = stroke
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
 
 class ellipse(SVGelement):
     """e=ellipse(rx,ry,x,y,fill,stroke,stroke_width,**args)
 
     an ellipse is defined as a center and a x and y radius.
     """
-    def __init__(self,cx=None,cy=None,rx=None,ry=None,fill=None,stroke=None,stroke_width=None,**args):
-        if rx==None or ry== None:
+    def __init__(self, cx=None, cy=None, rx=None, ry=None,fill=None,stroke=None,stroke_width=None,**args):
+        if rx == None or ry == None:
             raise ValueError('both rx and ry are required')
 
-        SVGelement.__init__(self, 'ellipse', {'rx':rx,'ry':ry}, **args)
-        if cx!=None:
-            self.attributes['cx']=cx
-        if cy!=None:
-            self.attributes['cy']=cy
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke!=None:
-            self.attributes['stroke']=stroke
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
+        SVGelement.__init__(self, 'ellipse', {'rx': rx, 'ry': ry}, **args)
+        if cx != None:
+            self.attributes['cx'] = cx
+        if cy != None:
+            self.attributes['cy'] = cy
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke != None:
+            self.attributes['stroke'] = stroke
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
 
 
 class circle(SVGelement):
@@ -486,20 +486,20 @@ class circle(SVGelement):
 
     The circle creates an element using a x, y and radius values eg
     """
-    def __init__(self,cx=None,cy=None,r=None,fill=None,stroke=None,stroke_width=None,**args):
-        if r==None:
+    def __init__(self, cx=None, cy=None, r=None, fill=None,stroke=None,stroke_width=None,**args):
+        if r == None:
             raise ValueError('r is required')
-        SVGelement.__init__(self, 'circle', {'r':r}, **args)
-        if cx!=None:
-            self.attributes['cx']=cx
-        if cy!=None:
-            self.attributes['cy']=cy
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke!=None:
-            self.attributes['stroke']=stroke
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
+        SVGelement.__init__(self, 'circle', {'r': r}, **args)
+        if cx != None:
+            self.attributes['cx'] = cx
+        if cy != None:
+            self.attributes['cy'] = cy
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke != None:
+            self.attributes['stroke'] = stroke
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
 
 class point(circle):
     """p=point(x,y,color)
@@ -507,7 +507,7 @@ class point(circle):
     A point is defined as a circle with a size 1 radius. It may be more efficient to use a
     very small rectangle if you use many points because a circle is difficult to render.
     """
-    def __init__(self,x,y,fill='black',**args):
+    def __init__(self, x, y, fill='black', **args):
         circle.__init__(self, x, y, 1, fill, **args)
 
 class line(SVGelement):
@@ -515,64 +515,64 @@ class line(SVGelement):
 
     A line is defined by a begin x,y pair and an end x,y pair
     """
-    def __init__(self,x1=None,y1=None,x2=None,y2=None,stroke=None,stroke_width=None,**args):
+    def __init__(self, x1=None, y1=None, x2=None, y2=None,stroke=None,stroke_width=None,**args):
         SVGelement.__init__(self, 'line', **args)
-        if x1!=None:
-            self.attributes['x1']=x1
-        if y1!=None:
-            self.attributes['y1']=y1
-        if x2!=None:
-            self.attributes['x2']=x2
-        if y2!=None:
-            self.attributes['y2']=y2
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
-        if stroke!=None:
-            self.attributes['stroke']=stroke
+        if x1 != None:
+            self.attributes['x1'] = x1
+        if y1 != None:
+            self.attributes['y1'] = y1
+        if x2 != None:
+            self.attributes['x2'] = x2
+        if y2 != None:
+            self.attributes['y2'] = y2
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
+        if stroke != None:
+            self.attributes['stroke'] = stroke
 
 class polyline(SVGelement):
     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 
     a polyline is defined by a list of xy pairs
     """
-    def __init__(self,points,fill=None,stroke=None,stroke_width=None,**args):
-        SVGelement.__init__(self, 'polyline', {'points':_xypointlist(points)}, **args)
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
-        if stroke!=None:
-            self.attributes['stroke']=stroke
+    def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
+        SVGelement.__init__(self, 'polyline', {'points': _xypointlist(points)}, **args)
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
+        if stroke != None:
+            self.attributes['stroke'] = stroke
 
 class polygon(SVGelement):
     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 
     a polygon is defined by a list of xy pairs
     """
-    def __init__(self,points,fill=None,stroke=None,stroke_width=None,**args):
-        SVGelement.__init__(self, 'polygon', {'points':_xypointlist(points)}, **args)
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
-        if stroke!=None:
-            self.attributes['stroke']=stroke
+    def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
+        SVGelement.__init__(self, 'polygon', {'points': _xypointlist(points)}, **args)
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
+        if stroke != None:
+            self.attributes['stroke'] = stroke
 
 class path(SVGelement):
     """p=path(path,fill,stroke,stroke_width,**args)
 
     a path is defined by a path object and optional width, stroke and fillcolor
     """
-    def __init__(self,pathdata,fill=None,stroke=None,stroke_width=None,id=None,**args):
-        SVGelement.__init__(self, 'path', {'d':str(pathdata)}, **args)
-        if stroke!=None:
-            self.attributes['stroke']=stroke
-        if fill!=None:
-            self.attributes['fill']=fill
-        if stroke_width!=None:
-            self.attributes['stroke-width']=stroke_width
-        if id!=None:
-            self.attributes['id']=id
+    def __init__(self, pathdata, fill=None, stroke=None, stroke_width=None,id=None,**args):
+        SVGelement.__init__(self, 'path', {'d': str(pathdata)}, **args)
+        if stroke != None:
+            self.attributes['stroke'] = stroke
+        if fill != None:
+            self.attributes['fill'] = fill
+        if stroke_width != None:
+            self.attributes['stroke-width'] = stroke_width
+        if id != None:
+            self.attributes['id'] = id
 
 
 class text(SVGelement):
@@ -580,20 +580,20 @@ class text(SVGelement):
 
     a text element can bge used for displaying text on the screen
     """
-    def __init__(self,x=None,y=None,text=None,font_size=None,font_family=None,text_anchor=None,**args):
+    def __init__(self, x=None, y=None, text=None, font_size=None,font_family=None,text_anchor=None,**args):
         SVGelement.__init__(self, 'text', **args)
-        if x!=None:
-            self.attributes['x']=x
-        if y!=None:
-            self.attributes['y']=y
-        if font_size!=None:
-            self.attributes['font-size']=font_size
-        if font_family!=None:
-            self.attributes['font-family']=font_family
-        if text!=None:
-            self.text=text
-        if text_anchor!=None:
-            self.attributes['text-anchor']=text_anchor
+        if x != None:
+            self.attributes['x'] = x
+        if y != None:
+            self.attributes['y'] = y
+        if font_size != None:
+            self.attributes['font-size'] = font_size
+        if font_family != None:
+            self.attributes['font-family'] = font_family
+        if text != None:
+            self.text = text
+        if text_anchor != None:
+            self.attributes['text-anchor'] = text_anchor
 
 
 class textpath(SVGelement):
@@ -601,10 +601,10 @@ class textpath(SVGelement):
 
     a textpath places a text on a path which is referenced by a link.
     """
-    def __init__(self,link,text=None,**args):
-        SVGelement.__init__(self, 'textPath', {'xlink:href':link}, **args)
-        if text!=None:
-            self.text=text
+    def __init__(self, link, text=None, **args):
+        SVGelement.__init__(self, 'textPath', {'xlink:href': link}, **args)
+        if text != None:
+            self.text = text
 
 class pattern(SVGelement):
     """p=pattern(x,y,width,height,patternUnits,**args)
@@ -613,18 +613,18 @@ class pattern(SVGelement):
     graphic object which can be replicated ("tiled") at fixed intervals
     in x and y to cover the areas to be painted.
     """
-    def __init__(self,x=None,y=None,width=None,height=None,patternUnits=None,**args):
+    def __init__(self, x=None, y=None, width=None, height=None,patternUnits=None,**args):
         SVGelement.__init__(self, 'pattern', **args)
-        if x!=None:
-            self.attributes['x']=x
-        if y!=None:
-            self.attributes['y']=y
-        if width!=None:
-            self.attributes['width']=width
-        if height!=None:
-            self.attributes['height']=height
-        if patternUnits!=None:
-            self.attributes['patternUnits']=patternUnits
+        if x != None:
+            self.attributes['x'] = x
+        if y != None:
+            self.attributes['y'] = y
+        if width != None:
+            self.attributes['width'] = width
+        if height != None:
+            self.attributes['height'] = height
+        if patternUnits != None:
+            self.attributes['patternUnits'] = patternUnits
 
 class title(SVGelement):
     """t=title(text,**args)
@@ -632,10 +632,10 @@ class title(SVGelement):
     a title is a text element. The text is displayed in the title bar
     add at least one to the root svg element
     """
-    def __init__(self,text=None,**args):
+    def __init__(self, text=None, **args):
         SVGelement.__init__(self, 'title', **args)
-        if text!=None:
-            self.text=text
+        if text != None:
+            self.text = text
 
 class description(SVGelement):
     """d=description(text,**args)
@@ -643,10 +643,10 @@ class description(SVGelement):
     a description can be added to any element and is used for a tooltip
     Add this element before adding other elements.
     """
-    def __init__(self,text=None,**args):
+    def __init__(self, text=None, **args):
         SVGelement.__init__(self, 'desc', **args)
-        if text!=None:
-            self.text=text
+        if text != None:
+            self.text = text
 
 class lineargradient(SVGelement):
     """lg=lineargradient(x1,y1,x2,y2,id,**args)
@@ -654,18 +654,18 @@ class lineargradient(SVGelement):
     defines a lineargradient using two xy pairs.
     stop elements van be added to define the gradient colors.
     """
-    def __init__(self,x1=None,y1=None,x2=None,y2=None,id=None,**args):
+    def __init__(self, x1=None, y1=None, x2=None, y2=None,id=None,**args):
         SVGelement.__init__(self, 'linearGradient', **args)
-        if x1!=None:
-            self.attributes['x1']=x1
-        if y1!=None:
-            self.attributes['y1']=y1
-        if x2!=None:
-            self.attributes['x2']=x2
-        if y2!=None:
-            self.attributes['y2']=y2
-        if id!=None:
-            self.attributes['id']=id
+        if x1 != None:
+            self.attributes['x1'] = x1
+        if y1 != None:
+            self.attributes['y1'] = y1
+        if x2 != None:
+            self.attributes['x2'] = x2
+        if y2 != None:
+            self.attributes['y2'] = y2
+        if id != None:
+            self.attributes['id'] = id
 
 class radialgradient(SVGelement):
     """rg=radialgradient(cx,cy,r,fx,fy,id,**args)
@@ -673,38 +673,38 @@ class radialgradient(SVGelement):
     defines a radial gradient using a outer circle which are defined by a cx,cy and r and by using a focalpoint.
     stop elements van be added to define the gradient colors.
     """
-    def __init__(self,cx=None,cy=None,r=None,fx=None,fy=None,id=None,**args):
+    def __init__(self, cx=None, cy=None, r=None, fx=None,fy=None,id=None,**args):
         SVGelement.__init__(self, 'radialGradient', **args)
-        if cx!=None:
-            self.attributes['cx']=cx
-        if cy!=None:
-            self.attributes['cy']=cy
-        if r!=None:
-            self.attributes['r']=r
-        if fx!=None:
-            self.attributes['fx']=fx
-        if fy!=None:
-            self.attributes['fy']=fy
-        if id!=None:
-            self.attributes['id']=id
+        if cx != None:
+            self.attributes['cx'] = cx
+        if cy != None:
+            self.attributes['cy'] = cy
+        if r != None:
+            self.attributes['r'] = r
+        if fx != None:
+            self.attributes['fx'] = fx
+        if fy != None:
+            self.attributes['fy'] = fy
+        if id != None:
+            self.attributes['id'] = id
 
 class stop(SVGelement):
     """st=stop(offset,stop_color,**args)
 
     Puts a stop color at the specified radius
     """
-    def __init__(self,offset,stop_color=None,**args):
-        SVGelement.__init__(self, 'stop', {'offset':offset}, **args)
-        if stop_color!=None:
-            self.attributes['stop-color']=stop_color
+    def __init__(self, offset, stop_color=None, **args):
+        SVGelement.__init__(self, 'stop', {'offset': offset}, **args)
+        if stop_color != None:
+            self.attributes['stop-color'] = stop_color
 
 class style(SVGelement):
     """st=style(type,cdata=None,**args)
 
     Add a CDATA element to this element for defing in line stylesheets etc..
     """
-    def __init__(self,type,cdata=None,**args):
-        SVGelement.__init__(self, 'style', {'type':type}, cdata=cdata, **args)
+    def __init__(self, type, cdata=None, **args):
+        SVGelement.__init__(self, 'style', {'type': type}, cdata=cdata, **args)
 
 
 class image(SVGelement):
@@ -712,22 +712,22 @@ class image(SVGelement):
 
     adds an image to the drawing. Supported formats are .png, .jpg and .svg.
     """
-    def __init__(self,url,x=None,y=None,width=None,height=None,**args):
-        if width==None or height==None:
+    def __init__(self, url, x=None, y=None, width=None,height=None,**args):
+        if width == None or height == None:
             raise ValueError('both height and width are required')
-        SVGelement.__init__(self, 'image', {'xlink:href':url,'width':width,'height':height}, **args)
-        if x!=None:
-            self.attributes['x']=x
-        if y!=None:
-            self.attributes['y']=y
+        SVGelement.__init__(self, 'image', {'xlink:href': url, 'width': width, 'height':height}, **args)
+        if x != None:
+            self.attributes['x'] = x
+        if y != None:
+            self.attributes['y'] = y
 
 class cursor(SVGelement):
     """c=cursor(url,**args)
 
     defines a custom cursor for a element or a drawing
     """
-    def __init__(self,url,**args):
-        SVGelement.__init__(self, 'cursor', {'xlink:href':url}, **args)
+    def __init__(self, url, **args):
+        SVGelement.__init__(self, 'cursor', {'xlink:href': url}, **args)
 
 
 class marker(SVGelement):
@@ -736,20 +736,20 @@ class marker(SVGelement):
     defines a marker which can be used as an endpoint for a line or other pathtypes
     add an element to it which should be used as a marker.
     """
-    def __init__(self,id=None,viewBox=None,refx=None,refy=None,markerWidth=None,markerHeight=None,**args):
+    def __init__(self, id=None, viewBox=None, refx=None, refy=None,markerWidth=None,markerHeight=None,**args):
         SVGelement.__init__(self, 'marker', **args)
-        if id!=None:
-            self.attributes['id']=id
-        if viewBox!=None:
-            self.attributes['viewBox']=_viewboxlist(viewBox)
-        if refx!=None:
-            self.attributes['refX']=refx
-        if refy!=None:
-            self.attributes['refY']=refy
-        if markerWidth!=None:
-            self.attributes['markerWidth']=markerWidth
-        if markerHeight!=None:
-            self.attributes['markerHeight']=markerHeight
+        if id != None:
+            self.attributes['id'] = id
+        if viewBox != None:
+            self.attributes['viewBox'] = _viewboxlist(viewBox)
+        if refx != None:
+            self.attributes['refX'] = refx
+        if refy != None:
+            self.attributes['refY'] = refy
+        if markerWidth != None:
+            self.attributes['markerWidth'] = markerWidth
+        if markerHeight != None:
+            self.attributes['markerHeight'] = markerHeight
 
 class group(SVGelement):
     """g=group(id,**args)
@@ -757,10 +757,10 @@ class group(SVGelement):
     a group is defined by an id and is used to contain elements
     g.addElement(SVGelement)
     """
-    def __init__(self,id=None,**args):
+    def __init__(self, id=None, **args):
         SVGelement.__init__(self, 'g', **args)
-        if id!=None:
-            self.attributes['id']=id
+        if id != None:
+            self.attributes['id'] = id
 
 class symbol(SVGelement):
     """sy=symbol(id,viewbox,**args)
@@ -771,19 +771,19 @@ class symbol(SVGelement):
     sy.addElement(SVGelement)
     """
 
-    def __init__(self,id=None,viewBox=None,**args):
+    def __init__(self, id=None, viewBox=None, **args):
         SVGelement.__init__(self, 'symbol', **args)
-        if id!=None:
-            self.attributes['id']=id
-        if viewBox!=None:
-            self.attributes['viewBox']=_viewboxlist(viewBox)
+        if id != None:
+            self.attributes['id'] = id
+        if viewBox != None:
+            self.attributes['viewBox'] = _viewboxlist(viewBox)
 
 class defs(SVGelement):
     """d=defs(**args)
 
     container for defining elements
     """
-    def __init__(self,**args):
+    def __init__(self, **args):
         SVGelement.__init__(self, 'defs', **args)
 
 class switch(SVGelement):
@@ -793,7 +793,7 @@ class switch(SVGelement):
     requiredFeatures, requiredExtensions and systemLanguage.
     Refer to the SVG specification for details.
     """
-    def __init__(self,**args):
+    def __init__(self, **args):
         SVGelement.__init__(self, 'switch', **args)
 
 
@@ -802,17 +802,17 @@ class use(SVGelement):
 
     references a symbol by linking to its id and its position, height and width
     """
-    def __init__(self,link,x=None,y=None,width=None,height=None,**args):
-        SVGelement.__init__(self, 'use', {'xlink:href':link}, **args)
-        if x!=None:
-            self.attributes['x']=x
-        if y!=None:
-            self.attributes['y']=y
+    def __init__(self, link, x=None, y=None, width=None,height=None,**args):
+        SVGelement.__init__(self, 'use', {'xlink:href': link}, **args)
+        if x != None:
+            self.attributes['x'] = x
+        if y != None:
+            self.attributes['y'] = y
 
-        if width!=None:
-            self.attributes['width']=width
-        if height!=None:
-            self.attributes['height']=height
+        if width != None:
+            self.attributes['width'] = width
+        if height != None:
+            self.attributes['height'] = height
 
 
 class link(SVGelement):
@@ -821,17 +821,17 @@ class link(SVGelement):
     a link  is defined by a hyperlink. add elements which have to be linked
     a.addElement(SVGelement)
     """
-    def __init__(self,link='',**args):
-        SVGelement.__init__(self, 'a', {'xlink:href':link}, **args)
+    def __init__(self, link='', **args):
+        SVGelement.__init__(self, 'a', {'xlink:href': link}, **args)
 
 class view(SVGelement):
     """v=view(id,**args)
 
     a view can be used to create a view with different attributes"""
-    def __init__(self,id=None,**args):
+    def __init__(self, id=None, **args):
         SVGelement.__init__(self, 'view', **args)
-        if id!=None:
-            self.attributes['id']=id
+        if id != None:
+            self.attributes['id'] = id
 
 class script(SVGelement):
     """sc=script(type,type,cdata,**args)
@@ -839,77 +839,77 @@ class script(SVGelement):
     adds a script element which contains CDATA to the SVG drawing
 
     """
-    def __init__(self,type,cdata=None,**args):
-        SVGelement.__init__(self, 'script', {'type':type}, cdata=cdata, **args)
+    def __init__(self, type, cdata=None, **args):
+        SVGelement.__init__(self, 'script', {'type': type}, cdata=cdata, **args)
 
 class animate(SVGelement):
     """an=animate(attribute,from,to,during,**args)
 
     animates an attribute.
     """
-    def __init__(self,attribute,fr=None,to=None,dur=None,**args):
-        SVGelement.__init__(self, 'animate', {'attributeName':attribute}, **args)
-        if fr!=None:
-            self.attributes['from']=fr
-        if to!=None:
-            self.attributes['to']=to
-        if dur!=None:
-            self.attributes['dur']=dur
+    def __init__(self, attribute, fr=None, to=None, dur=None,**args):
+        SVGelement.__init__(self, 'animate', {'attributeName': attribute}, **args)
+        if fr != None:
+            self.attributes['from'] = fr
+        if to != None:
+            self.attributes['to'] = to
+        if dur != None:
+            self.attributes['dur'] = dur
 
 class animateMotion(SVGelement):
     """an=animateMotion(pathdata,dur,**args)
 
     animates a SVGelement over the given path in dur seconds
     """
-    def __init__(self,pathdata,dur,**args):
+    def __init__(self, pathdata, dur, **args):
         SVGelement.__init__(self, 'animateMotion', **args)
-        if pathdata!=None:
-            self.attributes['path']=str(pathdata)
-        if dur!=None:
-            self.attributes['dur']=dur
+        if pathdata != None:
+            self.attributes['path'] = str(pathdata)
+        if dur != None:
+            self.attributes['dur'] = dur
 
 class animateTransform(SVGelement):
     """antr=animateTransform(type,from,to,dur,**args)
 
     transform an element from and to a value.
     """
-    def __init__(self,type=None,fr=None,to=None,dur=None,**args):
-        SVGelement.__init__(self, 'animateTransform', {'attributeName':'transform'}, **args)
+    def __init__(self, type=None, fr=None, to=None, dur=None,**args):
+        SVGelement.__init__(self, 'animateTransform', {'attributeName': 'transform'}, **args)
         # As far as I know the attributeName is always transform
-        if type!=None:
-            self.attributes['type']=type
-        if fr!=None:
-            self.attributes['from']=fr
-        if to!=None:
-            self.attributes['to']=to
-        if dur!=None:
-            self.attributes['dur']=dur
+        if type != None:
+            self.attributes['type'] = type
+        if fr != None:
+            self.attributes['from'] = fr
+        if to != None:
+            self.attributes['to'] = to
+        if dur != None:
+            self.attributes['dur'] = dur
 class animateColor(SVGelement):
     """ac=animateColor(attribute,type,from,to,dur,**args)
 
     Animates the color of a element
     """
-    def __init__(self,attribute,type=None,fr=None,to=None,dur=None,**args):
-        SVGelement.__init__(self, 'animateColor', {'attributeName':attribute}, **args)
-        if type!=None:
-            self.attributes['type']=type
-        if fr!=None:
-            self.attributes['from']=fr
-        if to!=None:
-            self.attributes['to']=to
-        if dur!=None:
-            self.attributes['dur']=dur
+    def __init__(self, attribute, type=None, fr=None, to=None,dur=None,**args):
+        SVGelement.__init__(self, 'animateColor', {'attributeName': attribute}, **args)
+        if type != None:
+            self.attributes['type'] = type
+        if fr != None:
+            self.attributes['from'] = fr
+        if to != None:
+            self.attributes['to'] = to
+        if dur != None:
+            self.attributes['dur'] = dur
 class set(SVGelement):
     """st=set(attribute,to,during,**args)
 
     sets an attribute to a value for a
     """
-    def __init__(self,attribute,to=None,dur=None,**args):
-        SVGelement.__init__(self, 'set', {'attributeName':attribute}, **args)
-        if to!=None:
-            self.attributes['to']=to
-        if dur!=None:
-            self.attributes['dur']=dur
+    def __init__(self, attribute, to=None, dur=None, **args):
+        SVGelement.__init__(self, 'set', {'attributeName': attribute}, **args)
+        if to != None:
+            self.attributes['to'] = to
+        if dur != None:
+            self.attributes['dur'] = dur
 
 
 
@@ -928,15 +928,15 @@ class svg(SVGelement):
     d.setSVG(s)
     d.toXml()
     """
-    def __init__(self,viewBox=None, width=None, height=None,**args):
+    def __init__(self, viewBox=None, width=None, height=None, **args):
         SVGelement.__init__(self, 'svg', **args)
-        if viewBox!=None:
-            self.attributes['viewBox']=_viewboxlist(viewBox)
-        if width!=None:
-            self.attributes['width']=width
-        if height!=None:
-            self.attributes['height']=height
-        self.namespace="http://www.w3.org/2000/svg"
+        if viewBox != None:
+            self.attributes['viewBox'] = _viewboxlist(viewBox)
+        if width != None:
+            self.attributes['width'] = width
+        if height != None:
+            self.attributes['height'] = height
+        self.namespace = "http://www.w3.org/2000/svg"
 
 class drawing:
     """d=drawing()
@@ -950,15 +950,15 @@ class drawing:
     """
 
     def __init__(self, entity={}):
-        self.svg=None
+        self.svg = None
         self.entity = entity
     def setSVG(self, svg):
-        self.svg=svg
+        self.svg = svg
         # Voeg een element toe aan de grafiek toe.
-    if use_dom_implementation==0:
-        def toXml(self, filename='',compress=False):
+    if use_dom_implementation == 0:
+        def toXml(self, filename='', compress=False):
             import io
-            xml=io.StringIO()
+            xml = io.StringIO()
             xml.write("<?xml version='1.0' encoding='UTF-8'?>\n")
             xml.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\"")
             if self.entity:
@@ -971,8 +971,8 @@ class drawing:
             if not filename:
                 if compress:
                     import gzip
-                    f=io.StringIO()
-                    zf=gzip.GzipFile(fileobj=f, mode='wb')
+                    f = io.StringIO()
+                    zf = gzip.GzipFile(fileobj=f, mode='wb')
                     zf.write(xml.getvalue())
                     zf.close()
                     f.seek(0)
@@ -980,18 +980,18 @@ class drawing:
                 else:
                     return xml.getvalue()
             else:
-                if filename[-4:]=='svgz':
+                if filename[-4:] == 'svgz':
                     import gzip
-                    f=gzip.GzipFile(filename=filename, mode="wb", compresslevel=9)
+                    f = gzip.GzipFile(filename=filename, mode="wb", compresslevel=9)
                     f.write(xml.getvalue())
                     f.close()
                 else:
-                    f=file(filename, 'w')
+                    f = file(filename, 'w')
                     f.write(xml.getvalue())
                     f.close()
 
     else:
-        def toXml(self,filename='',compress=False):
+        def toXml(self, filename='', compress=False):
             """drawing.toXml()        ---->to the screen
             drawing.toXml(filename)---->to the file
             writes a svg drawing to the screen or to a file
@@ -1002,35 +1002,35 @@ class drawing:
             global root
             # root is defined global so it can be used by the appender. Its also possible to use it as an arugument but
             # that is a bit messy.
-            root=implementation.createDocument(None, None, doctype)
+            root = implementation.createDocument(None, None, doctype)
             # Create the xml document.
             global appender
             def appender(element, elementroot):
                 """This recursive function appends elements to an element and sets the attributes
                 and type. It stops when alle elements have been appended"""
                 if element.namespace:
-                    e=root.createElementNS(element.namespace, element.type)
+                    e = root.createElementNS(element.namespace, element.type)
                 else:
-                    e=root.createElement(element.type)
+                    e = root.createElement(element.type)
                 if element.text:
-                    textnode=root.createTextNode(element.text)
+                    textnode = root.createTextNode(element.text)
                     e.appendChild(textnode)
-                for attribute in list(element.attributes.keys()):   #in element.attributes is supported from python 2.2
+                for attribute in list(element.attributes.keys()):  # in element.attributes is supported from python 2.2
                     e.setAttribute(attribute, str(element.attributes[attribute]))
                 if element.elements:
                     for el in element.elements:
-                        e=appender(el, e)
+                        e = appender(el, e)
                 elementroot.appendChild(e)
                 return elementroot
-            root=appender(self.svg, root)
+            root = appender(self.svg, root)
             if not filename:
                 import io
-                xml=io.StringIO()
+                xml = io.StringIO()
                 PrettyPrint(root, xml)
                 if compress:
                     import gzip
-                    f=io.StringIO()
-                    zf=gzip.GzipFile(fileobj=f, mode='wb')
+                    f = io.StringIO()
+                    zf = gzip.GzipFile(fileobj=f, mode='wb')
                     zf.write(xml.getvalue())
                     zf.close()
                     f.seek(0)
@@ -1039,16 +1039,16 @@ class drawing:
                     return xml.getvalue()
             else:
                 try:
-                    if filename[-4:]=='svgz':
+                    if filename[-4:] == 'svgz':
                         import gzip
                         import io
-                        xml=io.StringIO()
+                        xml = io.StringIO()
                         PrettyPrint(root, xml)
-                        f=gzip.GzipFile(filename=filename, mode='wb', compresslevel=9)
+                        f = gzip.GzipFile(filename=filename, mode='wb', compresslevel=9)
                         f.write(xml.getvalue())
                         f.close()
                     else:
-                        f=open(filename, 'w')
+                        f = open(filename, 'w')
                         PrettyPrint(root, f)
                         f.close()
                 except:
@@ -1058,44 +1058,44 @@ class drawing:
             import xml.parsers.xmlproc.xmlval
         except:
             raise exceptions.ImportError('PyXml is required for validating SVG')
-        svg=self.toXml()
-        xv=xml.parsers.xmlproc.xmlval.XMLValidator()
+        svg = self.toXml()
+        xv = xml.parsers.xmlproc.xmlval.XMLValidator()
         try:
             xv.feed(svg)
         except:
             raise Exception("SVG is not well formed, see messages above")
         else:
             print("SVG well formed")
-if __name__=='__main__':
+if __name__ == '__main__':
 
 
-    d=drawing()
-    s=svg((0, 0, 100, 100))
-    r=rect(-100, -100, 300, 300, 'cyan')
+    d = drawing()
+    s = svg((0, 0, 100, 100))
+    r = rect(-100, -100, 300, 300, 'cyan')
     s.addElement(r)
 
-    t=title('SVGdraw Demo')
+    t = title('SVGdraw Demo')
     s.addElement(t)
-    g=group('animations')
-    e=ellipse(0, 0, 5, 2)
+    g = group('animations')
+    e = ellipse(0, 0, 5, 2)
     g.addElement(e)
-    c=circle(0, 0, 1, 'red')
+    c = circle(0, 0, 1, 'red')
     g.addElement(c)
-    pd=pathdata(0, -10)
+    pd = pathdata(0, -10)
     for i in range(6):
         pd.relsmbezier(10, 5, 0, 10)
         pd.relsmbezier(-10, 5, 0, 10)
-    an=animateMotion(pd, 10)
-    an.attributes['rotate']='auto-reverse'
-    an.attributes['repeatCount']="indefinite"
+    an = animateMotion(pd, 10)
+    an.attributes['rotate'] = 'auto-reverse'
+    an.attributes['repeatCount'] = "indefinite"
     g.addElement(an)
     s.addElement(g)
     for i in range(20, 120, 20):
-        u=use('#animations', i, 0)
+        u = use('#animations', i, 0)
         s.addElement(u)
     for i in range(0, 120, 20):
         for j in range(5, 105, 10):
-            c=circle(i, j, 1, 'red', 'black', .5)
+            c = circle(i, j, 1, 'red', 'black', .5)
             s.addElement(c)
     d.setSVG(s)
 
diff --git a/wqflask/utility/temp_data.py b/wqflask/utility/temp_data.py
index b2cbd458..2088ba9a 100644
--- a/wqflask/utility/temp_data.py
+++ b/wqflask/utility/temp_data.py
@@ -11,7 +11,7 @@ class TempData:
 
     def store(self, field, value):
         self.redis.hset(self.key, field, value)
-        self.redis.expire(self.key, 60*15)  # Expire in 15 minutes
+        self.redis.expire(self.key, 60 * 15)  # Expire in 15 minutes
 
     def get_all(self):
         return self.redis.hgetall(self.key)
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index 65df59c3..9b751344 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -9,7 +9,7 @@ from wqflask import app
 
 # Use the standard logger here to avoid a circular dependency
 import logging
-logger = logging.getLogger(__name__ )
+logger = logging.getLogger(__name__)
 
 OVERRIDES = {}
 
@@ -18,7 +18,7 @@ def app_set(command_id, value):
     app.config.setdefault(command_id, value)
     return value
 
-def get_setting(command_id,guess=None):
+def get_setting(command_id, guess=None):
     """Resolve a setting from the environment or the global settings in
     app.config, with valid_path is a function checking whether the
     path points to an expected directory and returns the full path to
@@ -54,7 +54,7 @@ def get_setting(command_id,guess=None):
     # print("Looking for "+command_id+"\n")
     command = value(os.environ.get(command_id))
     if command is None or command == "":
-        command = OVERRIDES.get(command_id) # currently not in use
+        command = OVERRIDES.get(command_id)  # currently not in use
         if command is None:
             # ---- Check whether setting exists in app
             command = value(app.config.get(command_id))
@@ -62,7 +62,7 @@ def get_setting(command_id,guess=None):
                 command = value(guess)
                 if command is None or command == "":
                     # print command
-                    raise Exception(command_id+' setting unknown or faulty (update default_settings.py?).')
+                    raise Exception(command_id + ' setting unknown or faulty (update default_settings.py?).')
     # print("Set "+command_id+"="+str(command))
     return command
 
@@ -99,13 +99,13 @@ def js_path(module=None):
     """
     Find the JS module in the two paths
     """
-    try_gn   = get_setting("JS_GN_PATH")+"/"+module
+    try_gn = get_setting("JS_GN_PATH") + "/" + module
     if valid_path(try_gn):
         return try_gn
-    try_guix = get_setting("JS_GUIX_PATH")+"/"+module
+    try_guix = get_setting("JS_GUIX_PATH") + "/" + module
     if valid_path(try_guix):
         return try_guix
-    raise "No JS path found for "+module+" (if not in Guix check JS_GN_PATH)"
+    raise "No JS path found for " + module + " (if not in Guix check JS_GN_PATH)"
 
 def reaper_command(guess=None):
     return get_setting("REAPER_COMMAND", guess)
@@ -121,28 +121,28 @@ def plink_command(guess=None):
 
 def flat_file_exists(subdir):
     base = get_setting("GENENETWORK_FILES")
-    return valid_path(base+"/"+subdir)
+    return valid_path(base + "/" + subdir)
 
 def flat_files(subdir=None):
     base = get_setting("GENENETWORK_FILES")
     if subdir:
-        return assert_dir(base+"/"+subdir)
+        return assert_dir(base + "/" + subdir)
     return assert_dir(base)
 
 def assert_bin(fn):
     if not valid_bin(fn):
-        raise Exception("ERROR: can not find binary "+fn)
+        raise Exception("ERROR: can not find binary " + fn)
     return fn
 
 def assert_dir(dir):
     if not valid_path(dir):
-        raise Exception("ERROR: can not find directory "+dir)
+        raise Exception("ERROR: can not find directory " + dir)
     return dir
 
 def assert_writable_dir(dir):
     try:
         fn = dir + "/test.txt"
-        fh = open( fn, 'w' )
+        fh = open(fn, 'w')
         fh.write("I am writing this text to the file\n")
         fh.close()
         os.remove(fn)
@@ -152,7 +152,7 @@ def assert_writable_dir(dir):
 
 def assert_file(fn):
     if not valid_file(fn):
-        raise Exception('Unable to find file '+fn)
+        raise Exception('Unable to find file ' + fn)
     return fn
 
 def mk_dir(dir):
@@ -168,19 +168,19 @@ def locate(name, subdir=None):
     """
     base = get_setting("GENENETWORK_FILES")
     if subdir:
-        base = base+"/"+subdir
+        base = base + "/" + subdir
     if valid_path(base):
         lookfor = base + "/" + name
         if valid_file(lookfor):
-            logger.info("Found: file "+lookfor+"\n")
+            logger.info("Found: file " + lookfor + "\n")
             return lookfor
         else:
-            raise Exception("Can not locate "+lookfor)
+            raise Exception("Can not locate " + lookfor)
     if subdir: sys.stderr.write(subdir)
-    raise Exception("Can not locate "+name+" in "+base)
+    raise Exception("Can not locate " + name + " in " + base)
 
 def locate_phewas(name, subdir=None):
-    return locate(name, '/phewas/'+subdir)
+    return locate(name, '/phewas/' + subdir)
 
 def locate_ignore_error(name, subdir=None):
     """
@@ -191,13 +191,13 @@ def locate_ignore_error(name, subdir=None):
     """
     base = get_setting("GENENETWORK_FILES")
     if subdir:
-        base = base+"/"+subdir
+        base = base + "/" + subdir
     if valid_path(base):
         lookfor = base + "/" + name
         if valid_file(lookfor):
-            logger.debug("Found: file "+name+"\n")
+            logger.debug("Found: file " + name + "\n")
             return lookfor
-    logger.info("WARNING: file "+name+" not found\n")
+    logger.info("WARNING: file " + name + " not found\n")
     return None
 
 def tempdir():
@@ -206,20 +206,20 @@ def tempdir():
     """
     return valid_path(get_setting("TMPDIR", "/tmp"))
 
-BLUE  = '\033[94m'
+BLUE = '\033[94m'
 GREEN = '\033[92m'
-BOLD  = '\033[1m'
-ENDC  = '\033[0m'
+BOLD = '\033[1m'
+ENDC = '\033[0m'
 
 def show_settings():
     from utility.tools import LOG_LEVEL
 
-    print(("Set global log level to "+BLUE+LOG_LEVEL+ENDC))
+    print(("Set global log level to " + BLUE + LOG_LEVEL + ENDC))
     log_level = getattr(logging, LOG_LEVEL.upper())
     logging.basicConfig(level=log_level)
 
     logger.info(OVERRIDES)
-    logger.info(BLUE+"Mr. Mojo Risin 2"+ENDC)
+    logger.info(BLUE + "Mr. Mojo Risin 2" + ENDC)
     keylist = list(app.config.keys())
     print("runserver.py: ****** Webserver configuration - k,v pairs from app.config ******")
     keylist.sort()
@@ -231,35 +231,35 @@ def show_settings():
 
 
 # Cached values
-GN_VERSION         = get_setting('GN_VERSION')
-HOME               = get_setting('HOME')
-SERVER_PORT        = get_setting('SERVER_PORT')
-WEBSERVER_MODE     = get_setting('WEBSERVER_MODE')
-GN2_BASE_URL       = get_setting('GN2_BASE_URL')
-GN2_BRANCH_URL     = get_setting('GN2_BRANCH_URL')
-GN_SERVER_URL      = get_setting('GN_SERVER_URL')
-SERVER_PORT        = get_setting_int('SERVER_PORT')
-SQL_URI            = get_setting('SQL_URI')
-LOG_LEVEL          = get_setting('LOG_LEVEL')
-LOG_LEVEL_DEBUG    = get_setting_int('LOG_LEVEL_DEBUG')
-LOG_SQL            = get_setting_bool('LOG_SQL')
-LOG_SQL_ALCHEMY    = get_setting_bool('LOG_SQL_ALCHEMY')
-LOG_BENCH          = get_setting_bool('LOG_BENCH')
-LOG_FORMAT         = "%(message)s"    # not yet in use
-USE_REDIS          = get_setting_bool('USE_REDIS')
-USE_GN_SERVER      = get_setting_bool('USE_GN_SERVER')
-
-GENENETWORK_FILES  = get_setting('GENENETWORK_FILES')
-JS_GUIX_PATH       = get_setting('JS_GUIX_PATH')
+GN_VERSION = get_setting('GN_VERSION')
+HOME = get_setting('HOME')
+SERVER_PORT = get_setting('SERVER_PORT')
+WEBSERVER_MODE = get_setting('WEBSERVER_MODE')
+GN2_BASE_URL = get_setting('GN2_BASE_URL')
+GN2_BRANCH_URL = get_setting('GN2_BRANCH_URL')
+GN_SERVER_URL = get_setting('GN_SERVER_URL')
+SERVER_PORT = get_setting_int('SERVER_PORT')
+SQL_URI = get_setting('SQL_URI')
+LOG_LEVEL = get_setting('LOG_LEVEL')
+LOG_LEVEL_DEBUG = get_setting_int('LOG_LEVEL_DEBUG')
+LOG_SQL = get_setting_bool('LOG_SQL')
+LOG_SQL_ALCHEMY = get_setting_bool('LOG_SQL_ALCHEMY')
+LOG_BENCH = get_setting_bool('LOG_BENCH')
+LOG_FORMAT = "%(message)s"    # not yet in use
+USE_REDIS = get_setting_bool('USE_REDIS')
+USE_GN_SERVER = get_setting_bool('USE_GN_SERVER')
+
+GENENETWORK_FILES = get_setting('GENENETWORK_FILES')
+JS_GUIX_PATH = get_setting('JS_GUIX_PATH')
 assert_dir(JS_GUIX_PATH)
-JS_GN_PATH         = get_setting('JS_GN_PATH')
+JS_GN_PATH = get_setting('JS_GN_PATH')
 # assert_dir(JS_GN_PATH)
 
 GITHUB_CLIENT_ID = get_setting('GITHUB_CLIENT_ID')
 GITHUB_CLIENT_SECRET = get_setting('GITHUB_CLIENT_SECRET')
 if GITHUB_CLIENT_ID != 'UNKNOWN' and GITHUB_CLIENT_SECRET:
     GITHUB_AUTH_URL = "https://github.com/login/oauth/authorize?client_id=" + \
-                      GITHUB_CLIENT_ID+"&client_secret="+GITHUB_CLIENT_SECRET
+                      GITHUB_CLIENT_ID + "&client_secret=" + GITHUB_CLIENT_SECRET
     GITHUB_API_URL = get_setting('GITHUB_API_URL')
 
 ORCID_CLIENT_ID = get_setting('ORCID_CLIENT_ID')
@@ -267,7 +267,7 @@ ORCID_CLIENT_SECRET = get_setting('ORCID_CLIENT_SECRET')
 ORCID_AUTH_URL = None
 if ORCID_CLIENT_ID != 'UNKNOWN' and ORCID_CLIENT_SECRET:
     ORCID_AUTH_URL = "https://orcid.org/oauth/authorize?response_type=code&scope=/authenticate&show_login=true&client_id=" + \
-                      ORCID_CLIENT_ID+"&client_secret="+ORCID_CLIENT_SECRET + "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
+                      ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
     ORCID_TOKEN_URL = get_setting('ORCID_TOKEN_URL')
 
 ELASTICSEARCH_HOST = get_setting('ELASTICSEARCH_HOST')
@@ -279,28 +279,28 @@ SMTP_CONNECT = get_setting('SMTP_CONNECT')
 SMTP_USERNAME = get_setting('SMTP_USERNAME')
 SMTP_PASSWORD = get_setting('SMTP_PASSWORD')
 
-REAPER_COMMAND     = app_set("REAPER_COMMAND", reaper_command())
-GEMMA_COMMAND      = app_set("GEMMA_COMMAND", gemma_command())
+REAPER_COMMAND = app_set("REAPER_COMMAND", reaper_command())
+GEMMA_COMMAND = app_set("GEMMA_COMMAND", gemma_command())
 assert(GEMMA_COMMAND is not None)
-PLINK_COMMAND      = app_set("PLINK_COMMAND", plink_command())
+PLINK_COMMAND = app_set("PLINK_COMMAND", plink_command())
 GEMMA_WRAPPER_COMMAND = gemma_wrapper_command()
-TEMPDIR            = tempdir() # defaults to UNIX TMPDIR
+TEMPDIR = tempdir()  # defaults to UNIX TMPDIR
 assert_dir(TEMPDIR)
 
 # ---- Handle specific JS modules
 JS_GUIX_PATH = get_setting("JS_GUIX_PATH")
 assert_dir(JS_GUIX_PATH)
-assert_dir(JS_GUIX_PATH+'/cytoscape-panzoom')
+assert_dir(JS_GUIX_PATH + '/cytoscape-panzoom')
 
 CSS_PATH = JS_GUIX_PATH  # The CSS is bundled together with the JS
 # assert_dir(JS_PATH)
 
 JS_TWITTER_POST_FETCHER_PATH = get_setting("JS_TWITTER_POST_FETCHER_PATH", js_path("javascript-twitter-post-fetcher"))
 assert_dir(JS_TWITTER_POST_FETCHER_PATH)
-assert_file(JS_TWITTER_POST_FETCHER_PATH+"/js/twitterFetcher_min.js")
+assert_file(JS_TWITTER_POST_FETCHER_PATH + "/js/twitterFetcher_min.js")
 
 JS_CYTOSCAPE_PATH = get_setting("JS_CYTOSCAPE_PATH", js_path("cytoscape"))
 assert_dir(JS_CYTOSCAPE_PATH)
-assert_file(JS_CYTOSCAPE_PATH+'/cytoscape.min.js')
+assert_file(JS_CYTOSCAPE_PATH + '/cytoscape.min.js')
 
 # assert_file(PHEWAS_FILES+"/auwerx/PheWAS_pval_EMMA_norm.RData")
diff --git a/wqflask/utility/type_checking.py b/wqflask/utility/type_checking.py
index 6b029317..662bf794 100644
--- a/wqflask/utility/type_checking.py
+++ b/wqflask/utility/type_checking.py
@@ -23,19 +23,19 @@ def is_str(value):
     except:
         return False
 
-def get_float(vars_obj,name,default=None):
+def get_float(vars_obj, name, default=None):
     if name in vars_obj:
         if is_float(vars_obj[name]):
             return float(vars_obj[name])
     return default
 
-def get_int(vars_obj,name,default=None):
+def get_int(vars_obj, name, default=None):
     if name in vars_obj:
         if is_int(vars_obj[name]):
             return float(vars_obj[name])
     return default
 
-def get_string(vars_obj,name,default=None):
+def get_string(vars_obj, name, default=None):
     if name in vars_obj:
         if not vars_obj[name] is None:
             return str(vars_obj[name])
diff --git a/wqflask/utility/webqtlUtil.py b/wqflask/utility/webqtlUtil.py
index 5681fadf..ed59b0eb 100644
--- a/wqflask/utility/webqtlUtil.py
+++ b/wqflask/utility/webqtlUtil.py
@@ -33,38 +33,38 @@ from math import *
 from base import webqtlConfig
 
 # NL, 07/27/2010. moved from webqtlForm.py
-#Dict of Parents and F1 information, In the order of [F1, Mat, Pat]
-ParInfo ={
-'BXH':['BHF1', 'HBF1',  'C57BL/6J', 'C3H/HeJ'],
-'AKXD':['AKF1', 'KAF1', 'AKR/J', 'DBA/2J'],
-'BXD':['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'C57BL-6JxC57BL-6NJF2':['', '', 'C57BL/6J', 'C57BL/6NJ'],
-'BXD300':['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'B6BTBRF2':['B6BTBRF1', 'BTBRB6F1', 'C57BL/6J', 'BTBRT<+>tf/J'],
-'BHHBF2':['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
-'BHF2':['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
-'B6D2F2':['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'BDF2-1999':['B6D2F2', 'D2B6F2', 'C57BL/6J', 'DBA/2J'],
-'BDF2-2005':['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'CTB6F2':['CTB6F2', 'B6CTF2', 'C57BL/6J', 'Castaneous'],
-'CXB':['CBF1', 'BCF1', 'C57BL/6ByJ', 'BALB/cByJ'],
-'AXBXA':['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
-'AXB':['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
-'BXA':['BAF1', 'ABF1', 'C57BL/6J', 'A/J'],
-'LXS':['LSF1', 'SLF1', 'ISS', 'ILS'],
-'HXBBXH':['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv'],
-'BayXSha':['BayXShaF1', 'ShaXBayF1', 'Bay-0', 'Shahdara'],
-'ColXBur':['ColXBurF1', 'BurXColF1', 'Col-0', 'Bur-0'],
-'ColXCvi':['ColXCviF1', 'CviXColF1', 'Col-0', 'Cvi'],
-'SXM':['SMF1', 'MSF1', 'Steptoe', 'Morex'],
-'HRDP':['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv']
+# Dict of Parents and F1 information, In the order of [F1, Mat, Pat]
+ParInfo = {
+'BXH': ['BHF1', 'HBF1', 'C57BL/6J', 'C3H/HeJ'],
+'AKXD': ['AKF1', 'KAF1', 'AKR/J', 'DBA/2J'],
+'BXD': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+'C57BL-6JxC57BL-6NJF2': ['', '', 'C57BL/6J', 'C57BL/6NJ'],
+'BXD300': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+'B6BTBRF2': ['B6BTBRF1', 'BTBRB6F1', 'C57BL/6J', 'BTBRT<+>tf/J'],
+'BHHBF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
+'BHF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
+'B6D2F2': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+'BDF2-1999': ['B6D2F2', 'D2B6F2', 'C57BL/6J', 'DBA/2J'],
+'BDF2-2005': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+'CTB6F2': ['CTB6F2', 'B6CTF2', 'C57BL/6J', 'Castaneous'],
+'CXB': ['CBF1', 'BCF1', 'C57BL/6ByJ', 'BALB/cByJ'],
+'AXBXA': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
+'AXB': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
+'BXA': ['BAF1', 'ABF1', 'C57BL/6J', 'A/J'],
+'LXS': ['LSF1', 'SLF1', 'ISS', 'ILS'],
+'HXBBXH': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv'],
+'BayXSha': ['BayXShaF1', 'ShaXBayF1', 'Bay-0', 'Shahdara'],
+'ColXBur': ['ColXBurF1', 'BurXColF1', 'Col-0', 'Bur-0'],
+'ColXCvi': ['ColXCviF1', 'CviXColF1', 'Col-0', 'Cvi'],
+'SXM': ['SMF1', 'MSF1', 'Steptoe', 'Morex'],
+'HRDP': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv']
 }
 
 #########################################
 #      Accessory Functions
 #########################################
 
-def genRandStr(prefix = "", length=8, chars=string.ascii_letters+string.digits):
+def genRandStr(prefix="", length=8, chars=string.ascii_letters + string.digits):
     from random import choice
     _str = prefix[:]
     for i in range(length):
@@ -83,12 +83,12 @@ def ListNotNull(lst):
             return 1
     return None
 
-def readLineCSV(line): ### dcrowell July 2008
+def readLineCSV(line):  # dcrowell July 2008
     """Parses a CSV string of text and returns a list containing each element as a string.
     Used by correlationPage"""
     returnList = line.split('","')
-    returnList[-1]=returnList[-1][:-2]
-    returnList[0]=returnList[0][1:]
+    returnList[-1] = returnList[-1][:-2]
+    returnList[0] = returnList[0][1:]
     return returnList
 
 def cmpEigenValue(A, B):
@@ -107,7 +107,7 @@ def hasAccessToConfidentialPhenotypeTrait(privilege, userName, authorized_users)
     if webqtlConfig.USERDICT[privilege] > webqtlConfig.USERDICT['user']:
         access_to_confidential_phenotype_trait = 1
     else:
-        AuthorizedUsersList=[x.strip() for x in authorized_users.split(',')]
+        AuthorizedUsersList = [x.strip() for x in authorized_users.split(',')]
         if userName in AuthorizedUsersList:
             access_to_confidential_phenotype_trait = 1
     return access_to_confidential_phenotype_trait
diff --git a/wqflask/wqflask/__init__.py b/wqflask/wqflask/__init__.py
index 0564cfa7..bab87115 100644
--- a/wqflask/wqflask/__init__.py
+++ b/wqflask/wqflask/__init__.py
@@ -7,11 +7,11 @@ from flask import g
 from flask import Flask
 from utility import formatting
 from wqflask.markdown_routes import glossary_blueprint
-from wqflask.markdown_routes import  references_blueprint
-from wqflask.markdown_routes import  links_blueprint
+from wqflask.markdown_routes import references_blueprint
+from wqflask.markdown_routes import links_blueprint
 from wqflask.markdown_routes import policies_blueprint
-from wqflask.markdown_routes import  environments_blueprint
-from wqflask.markdown_routes import  facilities_blueprint
+from wqflask.markdown_routes import environments_blueprint
+from wqflask.markdown_routes import facilities_blueprint
 
 app = Flask(__name__)
 
diff --git a/wqflask/wqflask/api/correlation.py b/wqflask/wqflask/api/correlation.py
index f5b50dcd..e0b7fea0 100644
--- a/wqflask/wqflask/api/correlation.py
+++ b/wqflask/wqflask/api/correlation.py
@@ -16,16 +16,16 @@ from utility import webqtlUtil, helper_functions, corr_result_helpers
 from utility.benchmark import Bench
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 def do_correlation(start_vars):
     assert('db' in start_vars)
     assert('target_db' in start_vars)
     assert('trait_id' in start_vars)
 
-    this_dataset = data_set.create_dataset(dataset_name = start_vars['db'])
-    target_dataset = data_set.create_dataset(dataset_name = start_vars['target_db'])
-    this_trait = create_trait(dataset = this_dataset, name = start_vars['trait_id'])
+    this_dataset = data_set.create_dataset(dataset_name=start_vars['db'])
+    target_dataset = data_set.create_dataset(dataset_name=start_vars['target_db'])
+    this_trait = create_trait(dataset=this_dataset, name=start_vars['trait_id'])
     this_trait = retrieve_sample_data(this_trait, this_dataset)
 
     corr_params = init_corr_params(start_vars)
@@ -38,26 +38,26 @@ def do_correlation(start_vars):
         if corr_params['type'] == "tissue":
             [sample_r, num_overlap, sample_p, symbol] = corr_results[trait]
             result_dict = {
-                "trait"     : trait,
-                "sample_r"  : sample_r,
-                "#_strains" : num_overlap,
-                "p_value"   : sample_p,
-                "symbol"    : symbol
+                "trait": trait,
+                "sample_r": sample_r,
+                "#_strains": num_overlap,
+                "p_value": sample_p,
+                "symbol": symbol
             }
         elif corr_params['type'] == "literature" or corr_params['type'] == "lit":
             [gene_id, sample_r] = corr_results[trait]
             result_dict = {
-                "trait"     : trait,
-                "sample_r"  : sample_r,
-                "gene_id"   : gene_id
+                "trait": trait,
+                "sample_r": sample_r,
+                "gene_id": gene_id
             }
         else:
             [sample_r, sample_p, num_overlap] = corr_results[trait]
             result_dict = {
-                "trait"     : trait,
-                "sample_r"  : sample_r,
-                "#_strains" : num_overlap,
-                "p_value"   : sample_p
+                "trait": trait,
+                "sample_r": sample_r,
+                "#_strains": num_overlap,
+                "p_value": sample_p
             }
 
         final_results.append(result_dict)
@@ -76,7 +76,7 @@ def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
         corr_results = do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_params)
         sorted_results = collections.OrderedDict(sorted(list(corr_results.items()),
                                                         key=lambda t: -abs(t[1][1])))
-    elif corr_params['type'] == "literature" or corr_params['type'] == "lit": #ZS: Just so a user can use either "lit" or "literature"
+    elif corr_params['type'] == "literature" or corr_params['type'] == "lit":  # ZS: Just so a user can use either "lit" or "literature"
         trait_geneid_dict = this_dataset.retrieve_genes("GeneId")
         corr_results = do_literature_correlation_for_all_traits(this_trait, this_dataset, trait_geneid_dict, corr_params)
         sorted_results = collections.OrderedDict(sorted(list(corr_results.items()),
@@ -92,8 +92,8 @@ def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
     return sorted_results
 
 def do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_params, tissue_dataset_id=1):
-    #Gets tissue expression values for the primary trait
-    primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(symbol_list = [this_trait.symbol])
+    # Gets tissue expression values for the primary trait
+    primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(symbol_list=[this_trait.symbol])
 
     if this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
         primary_trait_tissue_values = primary_trait_tissue_vals_dict[this_trait.symbol.lower()]
@@ -227,9 +227,9 @@ def init_corr_params(start_vars):
         return_count = int(start_vars['return_count'])
 
     corr_params = {
-        'method'       : method,
-        'type'         : type,
-        'return_count' : return_count
+        'method': method,
+        'type': type,
+        'return_count': return_count
     }
 
     return corr_params
diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index eaddecd7..a64524dd 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -87,14 +87,14 @@ def phenotypes_exist(group_name):
     results = g.db.execute(
         ("SELECT Name FROM PublishFreeze "
          "WHERE PublishFreeze.Name = "
-         "'{}'").format(group_name+"Publish")).fetchone()
+         "'{}'").format(group_name + "Publish")).fetchone()
     return bool(results)
 
 
 def genotypes_exist(group_name):
     results = g.db.execute(
         ("SELECT Name FROM GenoFreeze " +
-         "WHERE GenoFreeze.Name = '{}'").format(group_name+"Geno")).fetchone()
+         "WHERE GenoFreeze.Name = '{}'").format(group_name + "Geno")).fetchone()
     return bool(results)
 
 
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index d59a69df..fbfbc879 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -8,15 +8,15 @@ from utility import helper_functions
 from wqflask.marker_regression import gemma_mapping, rqtl_mapping, qtlreaper_mapping, plink_mapping
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 def do_mapping_for_api(start_vars):
     assert('db' in start_vars)
     assert('trait_id' in start_vars)
 
-    dataset = data_set.create_dataset(dataset_name = start_vars['db'])
+    dataset = data_set.create_dataset(dataset_name=start_vars['db'])
     dataset.group.get_markers()
-    this_trait = create_trait(dataset = dataset, name = start_vars['trait_id'])
+    this_trait = create_trait(dataset=dataset, name=start_vars['trait_id'])
     this_trait = retrieve_sample_data(this_trait, dataset)
 
     samples = []
@@ -36,11 +36,11 @@ def do_mapping_for_api(start_vars):
 
     mapping_params = initialize_parameters(start_vars, dataset, this_trait)
 
-    covariates = "" #ZS: It seems to take an empty string as default. This should probably be changed.
+    covariates = ""  # ZS: It seems to take an empty string as default. This should probably be changed.
 
     if mapping_params['mapping_method'] == "gemma":
         header_row = ["name", "chr", "Mb", "lod_score", "p_value"]
-        if mapping_params['use_loco'] == "True": #ZS: gemma_mapping returns both results and the filename for LOCO, so need to only grab the former for api
+        if mapping_params['use_loco'] == "True":  # ZS: gemma_mapping returns both results and the filename for LOCO, so need to only grab the former for api
             result_markers = gemma_mapping.run_gemma(this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])[0]
         else:
             result_markers = gemma_mapping.run_gemma(this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])
@@ -118,7 +118,7 @@ def initialize_parameters(start_vars, dataset, this_trait):
 
     mapping_params['maf'] = 0.01
     if 'maf' in start_vars:
-        mapping_params['maf'] = start_vars['maf'] # Minor allele frequency
+        mapping_params['maf'] = start_vars['maf']  # Minor allele frequency
 
     mapping_params['use_loco'] = True
     if 'use_loco' in start_vars:
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index 60e163f2..b0559a07 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -23,13 +23,13 @@ from wqflask.api import correlation, mapping, gen_menu
 from utility.tools import flat_files
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 version = "pre1"
 
 @app.route("/api/v_{}/".format(version))
 def hello_world():
-    return flask.jsonify({"hello":"world"})
+    return flask.jsonify({"hello": "world"})
 
 @app.route("/api/v_{}/species".format(version))
 def get_species_list():
@@ -38,10 +38,10 @@ def get_species_list():
     species_list = []
     for species in the_species:
         species_dict = {
-          "Id"         : species[0],
-          "Name"       : species[1],
-          "FullName"   : species[2],
-          "TaxonomyId" : species[3]
+          "Id": species[0],
+          "Name": species[1],
+          "FullName": species[2],
+          "TaxonomyId": species[3]
         }
         species_list.append(species_dict)
 
@@ -49,17 +49,17 @@ def get_species_list():
 
 @app.route("/api/v_{}/species/<path:species_name>".format(version))
 @app.route("/api/v_{}/species/<path:species_name>.<path:file_format>".format(version))
-def get_species_info(species_name, file_format = "json"):
+def get_species_info(species_name, file_format="json"):
     results = g.db.execute("""SELECT SpeciesId, Name, FullName, TaxonomyId 
                               FROM Species 
                               WHERE (Name="{0}" OR FullName="{0}" OR SpeciesName="{0}");""".format(species_name))
 
     the_species = results.fetchone()
     species_dict = { 
-      "Id"         : the_species[0],
-      "Name"       : the_species[1],
-      "FullName"   : the_species[2],
-      "TaxonomyId" : the_species[3]
+      "Id": the_species[0],
+      "Name": the_species[1],
+      "FullName": the_species[2],
+      "TaxonomyId": the_species[3]
     }
     
     return flask.jsonify(species_dict)
@@ -87,14 +87,14 @@ def get_groups_list(species_name=None):
         groups_list = []
         for group in the_groups:
             group_dict = {
-              "Id"              : group[0],
-              "SpeciesId"       : group[1],
-              "DisplayName"     : group[2],
-              "Name"            : group[3],
-              "FullName"        : group[4],
-              "public"          : group[5],
-              "MappingMethodId" : group[6],
-              "GeneticType"     : group[7]
+              "Id": group[0],
+              "SpeciesId": group[1],
+              "DisplayName": group[2],
+              "Name": group[3],
+              "FullName": group[4],
+              "public": group[5],
+              "MappingMethodId": group[6],
+              "GeneticType": group[7]
             }
             groups_list.append(group_dict)
 
@@ -106,7 +106,7 @@ def get_groups_list(species_name=None):
 @app.route("/api/v_{}/group/<path:group_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/group/<path:species_name>/<path:group_name>".format(version))
 @app.route("/api/v_{}/group/<path:species_name>/<path:group_name>.<path:file_format>".format(version))
-def get_group_info(group_name, species_name = None, file_format = "json"):
+def get_group_info(group_name, species_name=None, file_format="json"):
     if species_name:
         results = g.db.execute("""SELECT InbredSet.InbredSetId, InbredSet.SpeciesId, InbredSet.InbredSetName, 
                                          InbredSet.Name, InbredSet.FullName, InbredSet.public, 
@@ -131,14 +131,14 @@ def get_group_info(group_name, species_name = None, file_format = "json"):
     group = results.fetchone()
     if group:
         group_dict = {
-          "Id"              : group[0],
-          "SpeciesId"       : group[1],
-          "DisplayName"     : group[2],
-          "Name"            : group[3],
-          "FullName"        : group[4],
-          "public"          : group[5],
-          "MappingMethodId" : group[6],
-          "GeneticType"     : group[7]
+          "Id": group[0],
+          "SpeciesId": group[1],
+          "DisplayName": group[2],
+          "Name": group[3],
+          "FullName": group[4],
+          "public": group[5],
+          "MappingMethodId": group[6],
+          "GeneticType": group[7]
         }
 
         return flask.jsonify(group_dict)
@@ -179,17 +179,17 @@ def get_datasets_for_group(group_name, species_name=None):
         datasets_list = []
         for dataset in the_datasets:
             dataset_dict = {
-              "Id"                 : dataset[0],
-              "ProbeFreezeId"      : dataset[1],
-              "AvgID"              : dataset[2],
-              "Short_Abbreviation" : dataset[3],
-              "Long_Abbreviation"  : dataset[4],
-              "FullName"           : dataset[5],
-              "ShortName"          : dataset[6],
-              "CreateTime"         : dataset[7],
-              "public"             : dataset[8],
-              "confidentiality"    : dataset[9],
-              "DataScale"          : dataset[10]
+              "Id": dataset[0],
+              "ProbeFreezeId": dataset[1],
+              "AvgID": dataset[2],
+              "Short_Abbreviation": dataset[3],
+              "Long_Abbreviation": dataset[4],
+              "FullName": dataset[5],
+              "ShortName": dataset[6],
+              "CreateTime": dataset[7],
+              "public": dataset[8],
+              "confidentiality": dataset[9],
+              "DataScale": dataset[10]
             }
             datasets_list.append(dataset_dict)
 
@@ -201,10 +201,10 @@ def get_datasets_for_group(group_name, species_name=None):
 @app.route("/api/v_{}/dataset/<path:dataset_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/dataset/<path:group_name>/<path:dataset_name>".format(version))
 @app.route("/api/v_{}/dataset/<path:group_name>/<path:dataset_name>.<path:file_format>".format(version))
-def get_dataset_info(dataset_name, group_name = None, file_format="json"):
-    #ZS: First get ProbeSet (mRNA expression) datasets and then get Phenotype datasets
+def get_dataset_info(dataset_name, group_name=None, file_format="json"):
+    # ZS: First get ProbeSet (mRNA expression) datasets and then get Phenotype datasets
 
-    datasets_list = [] #ZS: I figure I might as well return a list if there are multiple matches, though I don"t know if this will actually happen in practice
+    datasets_list = []  # ZS: I figure I might as well return a list if there are multiple matches, though I don"t know if this will actually happen in practice
 
     probeset_query = """
                 SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, ProbeSetFreeze.FullName,
@@ -235,16 +235,16 @@ def get_dataset_info(dataset_name, group_name = None, file_format="json"):
 
     if dataset:
         dataset_dict = {
-          "dataset_type" : "mRNA expression",
-          "id"           : dataset[0],
-          "name"         : dataset[1],
-          "full_name"    : dataset[2],
-          "short_name"   : dataset[3],
-          "data_scale"   : dataset[4],
-          "tissue_id"    : dataset[5],
-          "tissue"       : dataset[6],
-          "public"       : dataset[7],
-          "confidential" : dataset[8]
+          "dataset_type": "mRNA expression",
+          "id": dataset[0],
+          "name": dataset[1],
+          "full_name": dataset[2],
+          "short_name": dataset[3],
+          "data_scale": dataset[4],
+          "tissue_id": dataset[5],
+          "tissue": dataset[6],
+          "public": dataset[7],
+          "confidential": dataset[8]
         }
 
         datasets_list.append(dataset_dict)
@@ -272,25 +272,25 @@ def get_dataset_info(dataset_name, group_name = None, file_format="json"):
         if dataset:
             if dataset[5]:
                 dataset_dict = {
-                  "dataset_type" : "phenotype",
-                  "id"           : dataset[0],
-                  "name"         : dataset[1],
-                  "description"  : dataset[2],
-                  "pubmed_id"    : dataset[5],
-                  "title"        : dataset[6],
-                  "year"         : dataset[7]
+                  "dataset_type": "phenotype",
+                  "id": dataset[0],
+                  "name": dataset[1],
+                  "description": dataset[2],
+                  "pubmed_id": dataset[5],
+                  "title": dataset[6],
+                  "year": dataset[7]
                 }
             elif dataset[4]:
                 dataset_dict = {
-                  "dataset_type" : "phenotype",
-                  "id"           : dataset[0],
-                  "name"         : dataset[3],
-                  "description"  : dataset[4]
+                  "dataset_type": "phenotype",
+                  "id": dataset[0],
+                  "name": dataset[3],
+                  "description": dataset[4]
                 }
             else:
                 dataset_dict = {
-                  "dataset_type" : "phenotype",
-                  "id"           : dataset[0]
+                  "dataset_type": "phenotype",
+                  "id": dataset[0]
                 }
 
             datasets_list.append(dataset_dict)
@@ -304,7 +304,7 @@ def get_dataset_info(dataset_name, group_name = None, file_format="json"):
 
 @app.route("/api/v_{}/traits/<path:dataset_name>".format(version), methods=("GET",))
 @app.route("/api/v_{}/traits/<path:dataset_name>.<path:file_format>".format(version), methods=("GET",))
-def fetch_traits(dataset_name, file_format = "json"):
+def fetch_traits(dataset_name, file_format="json"):
     trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(dataset_name, request.args)
     if ("ids_only" in request.args) and (len(trait_ids) > 0):
         if file_format == "json":
@@ -432,7 +432,7 @@ def fetch_traits(dataset_name, file_format = "json"):
 
 @app.route("/api/v_{}/sample_data/<path:dataset_name>".format(version))
 @app.route("/api/v_{}/sample_data/<path:dataset_name>.<path:file_format>".format(version))
-def all_sample_data(dataset_name, file_format = "csv"):
+def all_sample_data(dataset_name, file_format="csv"):
     trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(dataset_name, request.args)
 
     if len(trait_ids) > 0:
@@ -538,7 +538,7 @@ def all_sample_data(dataset_name, file_format = "csv"):
 
 @app.route("/api/v_{}/sample_data/<path:dataset_name>/<path:trait_name>".format(version))
 @app.route("/api/v_{}/sample_data/<path:dataset_name>/<path:trait_name>.<path:file_format>".format(version))
-def trait_sample_data(dataset_name, trait_name, file_format = "json"):
+def trait_sample_data(dataset_name, trait_name, file_format="json"):
     probeset_query = """
                         SELECT
                             Strain.Name, Strain.Name2, ProbeSetData.value, ProbeSetData.Id, ProbeSetSE.error
@@ -610,10 +610,10 @@ def trait_sample_data(dataset_name, trait_name, file_format = "json"):
             sample_list = []
             for sample in sample_data:
                 sample_dict = {
-                  "sample_name"   : sample[0],
-                  "sample_name_2" : sample[1],
-                  "value"         : sample[2],
-                  "data_id"       : sample[3]
+                  "sample_name": sample[0],
+                  "sample_name_2": sample[1],
+                  "value": sample[2],
+                  "data_id": sample[3]
                 }
                 if sample[4]:
                     sample_dict["se"] = sample[4]
@@ -629,7 +629,7 @@ def trait_sample_data(dataset_name, trait_name, file_format = "json"):
 @app.route("/api/v_{}/trait/<path:dataset_name>/<path:trait_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/trait_info/<path:dataset_name>/<path:trait_name>".format(version))
 @app.route("/api/v_{}/trait_info/<path:dataset_name>/<path:trait_name>.<path:file_format>".format(version))
-def get_trait_info(dataset_name, trait_name, file_format = "json"):
+def get_trait_info(dataset_name, trait_name, file_format="json"):
     probeset_query = """
                         SELECT
                             ProbeSet.Id, ProbeSet.Name, ProbeSet.Symbol, ProbeSet.description, ProbeSet.Chr, ProbeSet.Mb, ProbeSet.alias,
@@ -648,24 +648,24 @@ def get_trait_info(dataset_name, trait_name, file_format = "json"):
     trait_info = probeset_results.fetchone()
     if trait_info:
         trait_dict = {
-            "id"          : trait_info[0],
-            "name"        : trait_info[1],
-            "symbol"      : trait_info[2],
-            "description" : trait_info[3],
-            "chr"         : trait_info[4],
-            "mb"          : trait_info[5],
-            "alias"       :trait_info[6],
-            "mean"        : trait_info[7],
-            "se"          : trait_info[8],
-            "locus"       : trait_info[9],
-            "lrs"         : trait_info[10],
-            "p_value"     : trait_info[11],
-            "additive"    : trait_info[12]
+            "id": trait_info[0],
+            "name": trait_info[1],
+            "symbol": trait_info[2],
+            "description": trait_info[3],
+            "chr": trait_info[4],
+            "mb": trait_info[5],
+            "alias": trait_info[6],
+            "mean": trait_info[7],
+            "se": trait_info[8],
+            "locus": trait_info[9],
+            "lrs": trait_info[10],
+            "p_value": trait_info[11],
+            "additive": trait_info[12]
         }
 
         return flask.jsonify(trait_dict)
     else:
-        if "Publish" in dataset_name: #ZS: Check if the user input the dataset_name as BXDPublish, etc (which is always going to be the group name + "Publish"
+        if "Publish" in dataset_name:  # ZS: Check if the user input the dataset_name as BXDPublish, etc (which is always going to be the group name + "Publish"
             dataset_name = dataset_name.replace("Publish", "")
         
         group_id = get_group_id(dataset_name)
@@ -684,10 +684,10 @@ def get_trait_info(dataset_name, trait_name, file_format = "json"):
         trait_info = pheno_results.fetchone()
         if trait_info:
             trait_dict = {
-                "id"       : trait_info[0],
-                "locus"    : trait_info[1],
-                "lrs"      : trait_info[2],
-                "additive" : trait_info[3]
+                "id": trait_info[0],
+                "locus": trait_info[1],
+                "lrs": trait_info[2],
+                "additive": trait_info[3]
             }
 
             return flask.jsonify(trait_dict)
@@ -699,7 +699,7 @@ def get_corr_results():
     results = correlation.do_correlation(request.args)
 
     if len(results) > 0:
-        return flask.jsonify(results) #ZS: I think flask.jsonify expects a dict/list instead of JSON
+        return flask.jsonify(results)  # ZS: I think flask.jsonify expects a dict/list instead of JSON
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
@@ -754,7 +754,7 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                         output_lines.append(line.split())
                         i += 1
 
-            csv_writer = csv.writer(si, delimiter = "\t", escapechar = "\\", quoting = csv.QUOTE_NONE)
+            csv_writer = csv.writer(si, delimiter="\t", escapechar="\\", quoting = csv.QUOTE_NONE)
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
     elif file_format == "rqtl2":
@@ -802,7 +802,7 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                     output_lines.append([line.strip() for line in line.split(",")])
                     i += 1
 
-            csv_writer = csv.writer(si, delimiter = ",")
+            csv_writer = csv.writer(si, delimiter=",")
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
@@ -826,8 +826,8 @@ def return_error(code, source, title, details):
     json_ob = {"errors": [
         {
             "status": code,
-            "source": { "pointer": source },
-            "title" : title,
+            "source": {"pointer": source},
+            "title": title,
             "detail": details
         }
     ]}
@@ -842,8 +842,8 @@ def get_dataset_trait_ids(dataset_name, start_vars):
         limit_string = ""
 
     if "Geno" in dataset_name:
-        data_type = "Geno" #ZS: Need to pass back the dataset type
-        query =    """
+        data_type = "Geno"  # ZS: Need to pass back the dataset type
+        query = """
                             SELECT
                                 GenoXRef.GenoId, Geno.Name, GenoXRef.GenoFreezeId
                             FROM
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 0291f2b8..6a1b88ca 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -68,18 +68,18 @@ def collections_add():
         uc_id = g.user_session.add_collection(collection_name, set())
         collections = g.user_session.user_collections
 
-    #ZS: One of these might be unnecessary
+    # ZS: One of these might be unnecessary
     if 'traits' in request.args:
-        traits=request.args['traits']
+        traits = request.args['traits']
         return render_template("collections/add.html",
-                                traits = traits,
-                                collections = collections,
+                                traits=traits,
+                                collections=collections,
                               )
     else:
         hash = request.args['hash']
         return render_template("collections/add.html",
-                                hash = hash,
-                                collections = collections,
+                                hash=hash,
+                                collections=collections,
                               )
 
 @app.route("/collections/new")
@@ -139,8 +139,8 @@ def list_collections():
 
     user_collections = list(g.user_session.user_collections)
     return render_template("collections/list.html",
-                            params = params,
-                            collections = user_collections,
+                            params=params,
+                            collections=user_collections,
                             )
 
 @app.route("/collections/remove", methods=('POST',))
@@ -196,7 +196,7 @@ def view_collection():
         name, dataset_name = atrait.split(':')
         if dataset_name == "Temp":
             group = name.split("_")[2]
-            dataset = create_dataset(dataset_name, dataset_type = "Temp", group_name = group)
+            dataset = create_dataset(dataset_name, dataset_type="Temp", group_name=group)
             trait_ob = create_trait(name=name, dataset=dataset)
         else:
             dataset = create_dataset(dataset_name)
@@ -207,7 +207,7 @@ def view_collection():
         json_version.append(jsonable(trait_ob))
 
     collection_info = dict(trait_obs=trait_obs,
-                           uc = uc)
+                           uc=uc)
 
     if "json" in params:
         return json.dumps(json_version)
diff --git a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
index 5855ccf0..c135faa3 100644
--- a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
+++ b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -23,7 +23,7 @@ from pprint import pformat as pf
 from base.trait import create_trait
 from base import data_set
 from utility import webqtlUtil, helper_functions, corr_result_helpers
-import utility.webqtlUtil #this is for parallel computing only.
+import utility.webqtlUtil  # this is for parallel computing only.
 from wqflask.correlation import correlation_functions
 
 from MySQLdb import escape_string as escape
@@ -41,7 +41,7 @@ class ComparisonBarChart:
         self.all_sample_list = []
         self.traits = []
         self.insufficient_shared_samples = False
-        this_group = self.trait_list[0][1].group.name #ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        this_group = self.trait_list[0][1].group.name  # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
         for trait_db in self.trait_list:
             
             if trait_db[1].group.name != this_group:
@@ -74,9 +74,9 @@ class ComparisonBarChart:
                         this_trait_vals.append('')
                 self.sample_data.append(this_trait_vals)
 
-            self.js_data = dict(traits = [trait.name for trait in self.traits],
-                                samples = self.all_sample_list,
-                                sample_data = self.sample_data,)
+            self.js_data = dict(traits=[trait.name for trait in self.traits],
+                                samples=self.all_sample_list,
+                                sample_data=self.sample_data,)
         
     def get_trait_db_obs(self, trait_db_list):
 
diff --git a/wqflask/wqflask/correlation/corr_scatter_plot.py b/wqflask/wqflask/correlation/corr_scatter_plot.py
index d5dc26f5..22941ad5 100644
--- a/wqflask/wqflask/correlation/corr_scatter_plot.py
+++ b/wqflask/wqflask/correlation/corr_scatter_plot.py
@@ -9,18 +9,18 @@ from scipy import stats
 import numpy as np
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class CorrScatterPlot:
     """Page that displays a correlation scatterplot with a line fitted to it"""
 
     def __init__(self, params):
         if "Temp" in params['dataset_1']:
-            self.dataset_1 = data_set.create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = params['dataset_1'].split("_")[1])
+            self.dataset_1 = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_1'].split("_")[1])
         else:
             self.dataset_1 = data_set.create_dataset(params['dataset_1'])
         if "Temp" in params['dataset_2']:
-            self.dataset_2 = data_set.create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = params['dataset_2'].split("_")[1])
+            self.dataset_2 = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_2'].split("_")[1])
         else:
             self.dataset_2 = data_set.create_dataset(params['dataset_2'])
 
@@ -60,8 +60,8 @@ class CorrScatterPlot:
         else:
             slope_string = '%.3f' % slope
         
-        x_buffer = (max(vals_1) - min(vals_1))*0.1
-        y_buffer = (max(vals_2) - min(vals_2))*0.1
+        x_buffer = (max(vals_1) - min(vals_1)) * 0.1
+        y_buffer = (max(vals_2) - min(vals_2)) * 0.1
 
         x_range = [min(vals_1) - x_buffer, max(vals_1) + x_buffer]
         y_range = [min(vals_2) - y_buffer, max(vals_2) + y_buffer]
@@ -80,8 +80,8 @@ class CorrScatterPlot:
         else:
             srslope_string = '%.3f' % srslope
 
-        x_buffer = (max(rx) - min(rx))*0.1
-        y_buffer = (max(ry) - min(ry))*0.1
+        x_buffer = (max(rx) - min(rx)) * 0.1
+        y_buffer = (max(ry) - min(ry)) * 0.1
 
         sr_range = [min(rx) - x_buffer, max(rx) + x_buffer]
 
@@ -92,33 +92,33 @@ class CorrScatterPlot:
             self.collections_exist = "True"
 
         self.js_data = dict(
-            data = self.data,
-            rdata = self.rdata,
-            indIDs = self.indIDs,
-            trait_1 = self.trait_1.dataset.name + ": " + str(self.trait_1.name),
-            trait_2 = self.trait_2.dataset.name + ": " + str(self.trait_2.name),
-            samples_1 = samples_1,
-            samples_2 = samples_2,
-            num_overlap = num_overlap,
-            vals_1 = vals_1,
-            vals_2 = vals_2,
-            x_range = x_range,
-            y_range = y_range,
-            sr_range = sr_range,
-            intercept_coords = intercept_coords,
-            sr_intercept_coords = sr_intercept_coords,
-
-            slope = slope,
-            slope_string = slope_string,
-            intercept = intercept,
-            r_value = r_value,
-            p_value = p_value,
-
-            srslope = srslope,
-            srslope_string = srslope_string,
-            srintercept = srintercept,
-            srr_value = srr_value,
-            srp_value = srp_value
+            data=self.data,
+            rdata=self.rdata,
+            indIDs=self.indIDs,
+            trait_1=self.trait_1.dataset.name + ": " + str(self.trait_1.name),
+            trait_2=self.trait_2.dataset.name + ": " + str(self.trait_2.name),
+            samples_1=samples_1,
+            samples_2=samples_2,
+            num_overlap=num_overlap,
+            vals_1=vals_1,
+            vals_2=vals_2,
+            x_range=x_range,
+            y_range=y_range,
+            sr_range=sr_range,
+            intercept_coords=intercept_coords,
+            sr_intercept_coords=sr_intercept_coords,
+
+            slope=slope,
+            slope_string=slope_string,
+            intercept=intercept,
+            r_value=r_value,
+            p_value=p_value,
+
+            srslope=srslope,
+            srslope_string=srslope_string,
+            srintercept=srintercept,
+            srr_value=srr_value,
+            srp_value=srp_value
 
             #trait3 = self.trait_3.data,
             #vals_3 = vals_3
@@ -129,10 +129,10 @@ class CorrScatterPlot:
 def get_intercept_coords(slope, intercept, x_range, y_range):
     intercept_coords = []
 
-    y1 = slope*x_range[0] + intercept
-    y2 = slope*x_range[1] + intercept
-    x1 = (y1-intercept)/slope
-    x2 = (y2-intercept)/slope
+    y1 = slope * x_range[0] + intercept
+    y2 = slope * x_range[1] + intercept
+    x1 = (y1 - intercept) / slope
+    x2 = (y2 - intercept) / slope
 
     intercept_coords.append([x1, y1])
     intercept_coords.append([x2, y2])
diff --git a/wqflask/wqflask/correlation/correlation_functions.py b/wqflask/wqflask/correlation/correlation_functions.py
index fd7691d4..0f24241a 100644
--- a/wqflask/wqflask/correlation/correlation_functions.py
+++ b/wqflask/wqflask/correlation/correlation_functions.py
@@ -34,19 +34,19 @@ from flask import Flask, g
 
 
 #####################################################################################
-#Input: primaryValue(list): one list of expression values of one probeSet,
+# Input: primaryValue(list): one list of expression values of one probeSet,
 #       targetValue(list): one list of expression values of one probeSet,
 #               method(string): indicate correlation method ('pearson' or 'spearman')
-#Output: corr_result(list): first item is Correlation Value, second item is tissue number,
+# Output: corr_result(list): first item is Correlation Value, second item is tissue number,
 #                           third item is PValue
-#Function: get correlation value,Tissue quantity ,p value result by using R;
-#Note : This function is special case since both primaryValue and targetValue are from
-#the same dataset. So the length of these two parameters is the same. They are pairs.
-#Also, in the datatable TissueProbeSetData, all Tissue values are loaded based on
-#the same tissue order
+# Function: get correlation value,Tissue quantity ,p value result by using R;
+# Note : This function is special case since both primaryValue and targetValue are from
+# the same dataset. So the length of these two parameters is the same. They are pairs.
+# Also, in the datatable TissueProbeSetData, all Tissue values are loaded based on
+# the same tissue order
 #####################################################################################
 
-def cal_zero_order_corr_for_tiss (primaryValue=[], targetValue=[], method='pearson'):
+def cal_zero_order_corr_for_tiss(primaryValue=[], targetValue=[], method='pearson'):
 
     R_primary = rpy2.robjects.FloatVector(list(range(len(primaryValue))))
     N = len(primaryValue)
@@ -55,27 +55,27 @@ def cal_zero_order_corr_for_tiss (primaryValue=[], targetValue=[], method='pears
 
     R_target = rpy2.robjects.FloatVector(list(range(len(targetValue))))
     for i in range(len(targetValue)):
-        R_target[i]=targetValue[i]
+        R_target[i] = targetValue[i]
 
     R_corr_test = rpy2.robjects.r['cor.test']
-    if method =='spearman':
+    if method == 'spearman':
         R_result = R_corr_test(R_primary, R_target, method='spearman')
     else:
         R_result = R_corr_test(R_primary, R_target)
 
-    corr_result =[]
-    corr_result.append( R_result[3][0])
-    corr_result.append( N )
-    corr_result.append( R_result[2][0])
+    corr_result = []
+    corr_result.append(R_result[3][0])
+    corr_result.append(N)
+    corr_result.append(R_result[2][0])
 
     return corr_result
 
 
 ########################################################################################################
-#input: cursor, symbolList (list), dataIdDict(Dict): key is symbol
-#output: SymbolValuePairDict(dictionary):one dictionary of Symbol and Value Pair.
+# input: cursor, symbolList (list), dataIdDict(Dict): key is symbol
+# output: SymbolValuePairDict(dictionary):one dictionary of Symbol and Value Pair.
 #        key is symbol, value is one list of expression values of one probeSet.
-#function: wrapper function for getSymbolValuePairDict function
+# function: wrapper function for getSymbolValuePairDict function
 #          build gene symbol list if necessary, cut it into small lists if necessary,
 #          then call getSymbolValuePairDict function and merge the results.
 ########################################################################################################
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index cb341e79..051ac1cb 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -78,7 +78,7 @@ class CorrelationResults:
 
         with Bench("Doing correlations"):
             if start_vars['dataset'] == "Temp":
-                self.dataset = data_set.create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = start_vars['group'])
+                self.dataset = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = start_vars['group'])
                 self.trait_id = start_vars['trait_id']
                 self.this_trait = create_trait(dataset=self.dataset,
                                            name=self.trait_id,
@@ -109,8 +109,8 @@ class CorrelationResults:
             self.get_formatted_corr_type()
             self.return_number = int(start_vars['corr_return_results'])
 
-            #The two if statements below append samples to the sample list based upon whether the user
-            #rselected Primary Samples Only, Other Samples Only, or All Samples
+            # The two if statements below append samples to the sample list based upon whether the user
+            # rselected Primary Samples Only, Other Samples Only, or All Samples
 
             primary_samples = self.dataset.group.samplelist
             if self.dataset.group.parlist != None:
@@ -118,13 +118,13 @@ class CorrelationResults:
             if self.dataset.group.f1list != None:
                 primary_samples += self.dataset.group.f1list
 
-            #If either BXD/whatever Only or All Samples, append all of that group's samplelist
+            # If either BXD/whatever Only or All Samples, append all of that group's samplelist
             if corr_samples_group != 'samples_other':
                 self.process_samples(start_vars, primary_samples)
 
-            #If either Non-BXD/whatever or All Samples, get all samples from this_trait.data and
-            #exclude the primary samples (because they would have been added in the previous
-            #if statement if the user selected All Samples)
+            # If either Non-BXD/whatever or All Samples, get all samples from this_trait.data and
+            # exclude the primary samples (because they would have been added in the previous
+            # if statement if the user selected All Samples)
             if corr_samples_group != 'samples_primary':
                 if corr_samples_group == 'samples_other':
                     primary_samples = [x for x in primary_samples if x not in (
@@ -173,7 +173,7 @@ class CorrelationResults:
                                                                    key=lambda t: -abs(t[1][0])))
 
 
-            #ZS: Convert min/max chromosome to an int for the location range option
+            # ZS: Convert min/max chromosome to an int for the location range option
             range_chr_as_int = None
             for order_id, chr_info in list(self.dataset.species.chromosomes.chromosomes.items()):
                 if 'loc_chr' in start_vars:
@@ -259,15 +259,15 @@ class CorrelationResults:
     def do_tissue_correlation_for_trait_list(self, tissue_dataset_id=1):
         """Given a list of correlation results (self.correlation_results), gets the tissue correlation value for each"""
 
-        #Gets tissue expression values for the primary trait
+        # Gets tissue expression values for the primary trait
         primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
-            symbol_list = [self.this_trait.symbol])
+            symbol_list=[self.this_trait.symbol])
 
         if self.this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
             primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower()]
             gene_symbol_list = [trait.symbol for trait in self.correlation_results if trait.symbol]
 
-            corr_result_tissue_vals_dict= correlation_functions.get_trait_symbol_and_tissue_values(
+            corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
                                                     symbol_list=gene_symbol_list)
 
             for trait in self.correlation_results:
@@ -282,15 +282,15 @@ class CorrelationResults:
                     trait.tissue_pvalue = result[2]
 
     def do_tissue_correlation_for_all_traits(self, tissue_dataset_id=1):
-        #Gets tissue expression values for the primary trait
+        # Gets tissue expression values for the primary trait
         primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
-            symbol_list = [self.this_trait.symbol])
+            symbol_list=[self.this_trait.symbol])
 
         if self.this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
             primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower()]
 
             #print("trait_gene_symbols: ", pf(trait_gene_symbols.values()))
-            corr_result_tissue_vals_dict= correlation_functions.get_trait_symbol_and_tissue_values(
+            corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
                                                     symbol_list=list(self.trait_symbol_dict.values()))
 
             #print("corr_result_tissue_vals: ", pf(corr_result_tissue_vals_dict))
@@ -443,7 +443,7 @@ class CorrelationResults:
         self.this_trait_vals, target_vals, num_overlap = corr_result_helpers.normalize_values(self.this_trait_vals, target_vals)
 
         if num_overlap > 5:
-            #ZS: 2015 could add biweight correlation, see http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3465711/
+            # ZS: 2015 could add biweight correlation, see http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3465711/
             if self.corr_method == 'bicor':
                 sample_r, sample_p = do_bicor(self.this_trait_vals, target_vals)
             elif self.corr_method == 'pearson':
@@ -475,16 +475,16 @@ def do_bicor(this_trait_vals, target_trait_vals):
     r_library("WGCNA")
     r_bicor = ro.r["bicorAndPvalue"]        # Map the bicorAndPvalue function
 
-    r_options(stringsAsFactors = False)
+    r_options(stringsAsFactors=False)
 
     this_vals = ro.Vector(this_trait_vals)
     target_vals = ro.Vector(target_trait_vals)
 
-    the_r, the_p, _fisher_transform, _the_t, _n_obs = [numpy.asarray(x) for x in r_bicor(x = this_vals, y = target_vals)]
+    the_r, the_p, _fisher_transform, _the_t, _n_obs = [numpy.asarray(x) for x in r_bicor(x=this_vals, y=target_vals)]
 
     return the_r, the_p
 
-def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_api = False):
+def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_api=False):
     results_list = []
     for i, trait in enumerate(corr_results):
         if trait.view == False:
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index d0b4a156..94c8931f 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -52,7 +52,7 @@ class CorrelationMatrix:
         self.traits = []
         self.insufficient_shared_samples = False
         self.do_PCA = True
-        this_group = self.trait_list[0][1].group.name #ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        this_group = self.trait_list[0][1].group.name  # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
         for trait_db in self.trait_list:
             this_group = trait_db[1].group.name
             this_trait = trait_db[0]
@@ -76,10 +76,10 @@ class CorrelationMatrix:
                     this_trait_vals.append('')
             self.sample_data.append(this_trait_vals)
 
-        if len(this_trait_vals) < len(self.trait_list): #Shouldn't do PCA if there are more traits than observations/samples
+        if len(this_trait_vals) < len(self.trait_list):  # Shouldn't do PCA if there are more traits than observations/samples
             self.do_PCA = False
 
-        self.lowest_overlap = 8 #ZS: Variable set to the lowest overlapping samples in order to notify user, or 8, whichever is lower (since 8 is when we want to display warning)
+        self.lowest_overlap = 8  # ZS: Variable set to the lowest overlapping samples in order to notify user, or 8, whichever is lower (since 8 is when we want to display warning)
 
         self.corr_results = []
         self.pca_corr_results = []
@@ -93,7 +93,7 @@ class CorrelationMatrix:
 
             corr_result_row = []
             pca_corr_result_row = []
-            is_spearman = False #ZS: To determine if it's above or below the diagonal
+            is_spearman = False  # ZS: To determine if it's above or below the diagonal
             for target in self.trait_list:
                 target_trait = target[0]
                 target_db = target[1]
@@ -168,12 +168,12 @@ class CorrelationMatrix:
         except:
             self.pca_works = "False"
 
-        self.js_data = dict(traits = [trait.name for trait in self.traits],
-                            groups = groups,
-                            cols = list(range(len(self.traits))),
-                            rows = list(range(len(self.traits))),
-                            samples = self.all_sample_list,
-                            sample_data = self.sample_data,)
+        self.js_data = dict(traits=[trait.name for trait in self.traits],
+                            groups=groups,
+                            cols=list(range(len(self.traits))),
+                            rows=list(range(len(self.traits))),
+                            samples=self.all_sample_list,
+                            sample_data=self.sample_data,)
 
     def calculate_pca(self, cols, corr_eigen_value, corr_eigen_vectors):
         base = importr('base')
@@ -183,7 +183,7 @@ class CorrelationMatrix:
 
         m = robjects.r.matrix(corr_results_to_list, nrow=len(cols))
         eigen = base.eigen(m)
-        pca = stats.princomp(m, cor = "TRUE")
+        pca = stats.princomp(m, cor="TRUE")
         self.loadings = pca.rx('loadings')
         self.scores = pca.rx('scores')
         self.scale = pca.rx('scale')
@@ -193,15 +193,15 @@ class CorrelationMatrix:
 
         pca_traits = []
         for i, vector in enumerate(trait_array_vectors):
-            #ZS: Check if below check is necessary
-            #if corr_eigen_value[i-1] > 100.0/len(self.trait_list):
-            pca_traits.append((vector*-1.0).tolist())
+            # ZS: Check if below check is necessary
+            # if corr_eigen_value[i-1] > 100.0/len(self.trait_list):
+            pca_traits.append((vector * -1.0).tolist())
 
         this_group_name = self.trait_list[0][1].group.name
-        temp_dataset = data_set.create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = this_group_name)
+        temp_dataset = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = this_group_name)
         temp_dataset.group.get_samplelist()
         for i, pca_trait in enumerate(pca_traits):
-            trait_id = "PCA" + str(i+1) + "_" + temp_dataset.group.species + "_" + this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
+            trait_id = "PCA" + str(i + 1) + "_" + temp_dataset.group.species + "_" + this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
             this_vals_string = ""
             position = 0
             for sample in temp_dataset.group.all_samples_ordered():
@@ -228,7 +228,7 @@ class CorrelationMatrix:
             else:
                the_range = 2
             for j in range(the_range):
-                position = i + len(self.trait_list)*j
+                position = i + len(self.trait_list) * j
                 loadings_row.append(self.loadings[0][position])
             loadings_array.append(loadings_row)
         return loadings_array
@@ -271,14 +271,14 @@ def zScore(trait_data_array):
         i = 0
         for data in trait_data_array:
             N = len(data)
-            S = reduce(lambda x, y: x+y, data, 0.)
-            SS = reduce(lambda x, y: x+y*y, data, 0.)
-            mean = S/N
-            var = SS - S*S/N
-            stdev = math.sqrt(var/(N-1))
+            S = reduce(lambda x, y: x + y, data, 0.)
+            SS = reduce(lambda x, y: x + y * y, data, 0.)
+            mean = S / N
+            var = SS - S * S / N
+            stdev = math.sqrt(var / (N - 1))
             if stdev == 0:
                 stdev = 1e-100
-            data2 = [(x-mean)/stdev for x in data]
+            data2 = [(x - mean) / stdev for x in data]
             trait_data_array[i] = data2
             i += 1
         return trait_data_array
@@ -298,8 +298,8 @@ def sortEigenVectors(vector):
         for item in combines:
             A.append(item[0])
             B.append(item[1])
-        sum = reduce(lambda x, y: x+y, A, 0.0)
-        A = [x*100.0/sum for x in A] 
+        sum = reduce(lambda x, y: x + y, A, 0.0)
+        A = [x * 100.0 / sum for x in A] 
         return [A, B]
     except:
         return []
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index 1556e370..2fa90a93 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -25,33 +25,33 @@ from utility.tools import locate, GN2_BRANCH_URL
 from rpy2.robjects.packages import importr
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
-
-## Get pointers to some common R functions
-r_library       = ro.r["library"]             # Map the library function
-r_options       = ro.r["options"]             # Map the options function
-r_t             = ro.r["t"]                   # Map the t function
-r_unlist        = ro.r["unlist"]              # Map the unlist function
-r_list          = ro.r.list                   # Map the list function
-r_png           = ro.r["png"]                 # Map the png function for plotting
-r_dev_off       = ro.r["dev.off"]             # Map the dev.off function
-r_write_table   = ro.r["write.table"]         # Map the write.table function
-r_data_frame    = ro.r["data.frame"]         # Map the write.table function
-r_as_numeric    = ro.r["as.numeric"]         # Map the write.table function
+logger = utility.logger.getLogger(__name__)
+
+# Get pointers to some common R functions
+r_library = ro.r["library"]             # Map the library function
+r_options = ro.r["options"]             # Map the options function
+r_t = ro.r["t"]                   # Map the t function
+r_unlist = ro.r["unlist"]              # Map the unlist function
+r_list = ro.r.list                   # Map the list function
+r_png = ro.r["png"]                 # Map the png function for plotting
+r_dev_off = ro.r["dev.off"]             # Map the dev.off function
+r_write_table = ro.r["write.table"]         # Map the write.table function
+r_data_frame = ro.r["data.frame"]         # Map the write.table function
+r_as_numeric = ro.r["as.numeric"]         # Map the write.table function
 
 class CTL:
     def __init__(self):
         logger.info("Initialization of CTL")
         #log = r_file("/tmp/genenetwork_ctl.log", open = "wt")
-        #r_sink(log)                                                       # Uncomment the r_sink() commands to log output from stdout/stderr to a file
+        # r_sink(log)                                                       # Uncomment the r_sink() commands to log output from stdout/stderr to a file
         #r_sink(log, type = "message")
         r_library("ctl")                                                   # Load CTL - Should only be done once, since it is quite expensive
-        r_options(stringsAsFactors = False)
+        r_options(stringsAsFactors=False)
         logger.info("Initialization of CTL done, package loaded in R session")
-        self.r_CTLscan            = ro.r["CTLscan"]                        # Map the CTLscan function
-        self.r_CTLsignificant     = ro.r["CTLsignificant"]                 # Map the CTLsignificant function
-        self.r_lineplot           = ro.r["ctl.lineplot"]                   # Map the ctl.lineplot function
-        self.r_plotCTLobject      = ro.r["plot.CTLobject"]                 # Map the CTLsignificant function
+        self.r_CTLscan = ro.r["CTLscan"]                        # Map the CTLscan function
+        self.r_CTLsignificant = ro.r["CTLsignificant"]                 # Map the CTLsignificant function
+        self.r_lineplot = ro.r["ctl.lineplot"]                   # Map the ctl.lineplot function
+        self.r_plotCTLobject = ro.r["plot.CTLobject"]                 # Map the CTLsignificant function
         self.nodes_list = []
         self.edges_list = []
         logger.info("Obtained pointers to CTL functions")
@@ -59,23 +59,23 @@ class CTL:
         self.gn2_url = GN2_BRANCH_URL
 
     def addNode(self, gt):
-        node_dict = { 'data' : {'id' : str(gt.name) + ":" + str(gt.dataset.name),
-                                'sid' : str(gt.name), 
-                                'dataset' : str(gt.dataset.name),
-                                'label' : gt.name,
-                                'symbol' : gt.symbol,
-                                'geneid' : gt.geneid,
-                                'omim' : gt.omim } }
+        node_dict = {'data': {'id': str(gt.name) + ":" + str(gt.dataset.name),
+                                'sid': str(gt.name), 
+                                'dataset': str(gt.dataset.name),
+                                'label': gt.name,
+                                'symbol': gt.symbol,
+                                'geneid': gt.geneid,
+                                'omim': gt.omim}}
         self.nodes_list.append(node_dict)
 
     def addEdge(self, gtS, gtT, significant, x):
-        edge_data = {'id' : str(gtS.symbol) + '_' + significant[1][x] + '_' + str(gtT.symbol),
-                     'source' : str(gtS.name) + ":" + str(gtS.dataset.name),
-                     'target' : str(gtT.name) + ":" + str(gtT.dataset.name),
-                     'lod' : significant[3][x],
-                     'color' : "#ff0000",
-                     'width' : significant[3][x] }
-        edge_dict = { 'data' : edge_data }
+        edge_data = {'id': str(gtS.symbol) + '_' + significant[1][x] + '_' + str(gtT.symbol),
+                     'source': str(gtS.name) + ":" + str(gtS.dataset.name),
+                     'target': str(gtT.name) + ":" + str(gtT.dataset.name),
+                     'lod': significant[3][x],
+                     'color': "#ff0000",
+                     'width': significant[3][x]}
+        edge_dict = {'data': edge_data}
         self.edges_list.append(edge_dict)
 
     def run_analysis(self, requestform):
@@ -114,7 +114,7 @@ class CTL:
         genotypes = list(itertools.chain(*markers))
         logger.debug(len(genotypes) / len(individuals), "==", len(parser.markers))
 
-        rGeno = r_t(ro.r.matrix(r_unlist(genotypes), nrow=len(markernames), ncol=len(individuals), dimnames = r_list(markernames, individuals), byrow=True))
+        rGeno = r_t(ro.r.matrix(r_unlist(genotypes), nrow=len(markernames), ncol=len(individuals), dimnames=r_list(markernames, individuals), byrow=True))
 
         # Create a phenotype matrix
         traits = []
@@ -122,7 +122,7 @@ class CTL:
           logger.debug("retrieving data for", trait)
           if trait != "":
             ts = trait.split(':')
-            gt = create_trait(name = ts[0], dataset_name = ts[1])
+            gt = create_trait(name=ts[0], dataset_name=ts[1])
             gt = retrieve_sample_data(gt, dataset, individuals)
             for ind in individuals:
               if ind in list(gt.data.keys()):
@@ -130,23 +130,23 @@ class CTL:
               else:
                 traits.append("-999")
 
-        rPheno = r_t(ro.r.matrix(r_as_numeric(r_unlist(traits)), nrow=len(self.trait_db_list), ncol=len(individuals), dimnames = r_list(self.trait_db_list, individuals), byrow=True))
+        rPheno = r_t(ro.r.matrix(r_as_numeric(r_unlist(traits)), nrow=len(self.trait_db_list), ncol=len(individuals), dimnames=r_list(self.trait_db_list, individuals), byrow=True))
 
         logger.debug(rPheno)
 
         # Use a data frame to store the objects
-        rPheno = r_data_frame(rPheno, check_names = False)
-        rGeno = r_data_frame(rGeno, check_names = False)
+        rPheno = r_data_frame(rPheno, check_names=False)
+        rGeno = r_data_frame(rGeno, check_names=False)
 
         # Debug: Print the genotype and phenotype files to disk
         #r_write_table(rGeno, "~/outputGN/geno.csv")
         #r_write_table(rPheno, "~/outputGN/pheno.csv")
 
         # Perform the CTL scan
-        res = self.r_CTLscan(rGeno, rPheno, strategy = strategy, nperm = nperm, parametric = parametric, nthreads=6)
+        res = self.r_CTLscan(rGeno, rPheno, strategy=strategy, nperm=nperm, parametric = parametric, nthreads=6)
 
         # Get significant interactions
-        significant = self.r_CTLsignificant(res, significance = significance)
+        significant = self.r_CTLsignificant(res, significance=significance)
 
         # Create an image for output
         self.results = {}
@@ -158,7 +158,7 @@ class CTL:
 
         # Create the lineplot
         r_png(self.results['imgloc1'], width=1000, height=600, type='cairo-png')
-        self.r_lineplot(res, significance = significance)
+        self.r_lineplot(res, significance=significance)
         r_dev_off()
 
         n = 2                                                 # We start from 2, since R starts from 1 :)
@@ -167,7 +167,7 @@ class CTL:
           self.results['imgurl' + str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
           self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + self.results['imgurl' + str(n)]
           r_png(self.results['imgloc' + str(n)], width=1000, height=600, type='cairo-png')
-          self.r_plotCTLobject(res, (n-1), significance = significance, main='Phenotype ' + trait)
+          self.r_plotCTLobject(res, (n - 1), significance=significance, main='Phenotype ' + trait)
           r_dev_off()
           n = n + 1
 
@@ -180,8 +180,8 @@ class CTL:
             logger.debug(significant[0][x], significant[1][x], significant[2][x])     # Debug to console
             tsS = significant[0][x].split(':')                                        # Source
             tsT = significant[2][x].split(':')                                        # Target
-            gtS = create_trait(name = tsS[0], dataset_name = tsS[1])            # Retrieve Source info from the DB
-            gtT = create_trait(name = tsT[0], dataset_name = tsT[1])            # Retrieve Target info from the DB
+            gtS = create_trait(name=tsS[0], dataset_name=tsS[1])            # Retrieve Source info from the DB
+            gtT = create_trait(name=tsT[0], dataset_name=tsT[1])            # Retrieve Target info from the DB
             self.addNode(gtS)
             self.addNode(gtT)
             self.addEdge(gtS, gtT, significant, x)
diff --git a/wqflask/wqflask/database.py b/wqflask/wqflask/database.py
index adeed6ad..b6e85494 100644
--- a/wqflask/wqflask/database.py
+++ b/wqflask/wqflask/database.py
@@ -6,7 +6,7 @@ from sqlalchemy.ext.declarative import declarative_base
 from utility.tools import SQL_URI
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 
 engine = create_engine(SQL_URI, encoding="latin1")
diff --git a/wqflask/wqflask/do_search.py b/wqflask/wqflask/do_search.py
index 364a3eed..115182e4 100644
--- a/wqflask/wqflask/do_search.py
+++ b/wqflask/wqflask/do_search.py
@@ -32,7 +32,7 @@ class DoSearch:
         self.search_type = search_type
 
         if self.dataset:
-            #Get group information for dataset and the species id
+            # Get group information for dataset and the species id
             self.species_id = webqtlDatabaseFunction.retrieve_species_id(self.dataset.group.name)
 
     def execute(self, query):
@@ -137,7 +137,7 @@ class MrnaAssaySearch(DoSearch):
 
         return where_clause
 
-    def compile_final_query(self, from_clause = '', where_clause = ''):
+    def compile_final_query(self, from_clause='', where_clause=''):
         """Generates the final query string"""
 
         from_clause = self.normalize_spaces(from_clause)
@@ -153,7 +153,7 @@ class MrnaAssaySearch(DoSearch):
                                     escape(str(self.dataset.id))))
         return query
 
-    def run_combined(self, from_clause = '', where_clause = ''):
+    def run_combined(self, from_clause='', where_clause=''):
         """Generates and runs a combined search of an mRNA expression dataset"""
 
         logger.debug("Running ProbeSetSearch")
@@ -218,10 +218,10 @@ class PhenotypeSearch(DoSearch):
     def get_where_clause(self):
         """Generate clause for WHERE portion of query"""
 
-        #Todo: Zach will figure out exactly what both these lines mean
-        #and comment here
+        # Todo: Zach will figure out exactly what both these lines mean
+        # and comment here
 
-        #if "'" not in self.search_term[0]:
+        # if "'" not in self.search_term[0]:
         search_term = "[[:<:]]" + self.handle_wildcard(self.search_term[0]) + "[[:>:]]"
         if "_" in self.search_term[0]:
             if len(self.search_term[0].split("_")[0]) == 3:
@@ -236,7 +236,7 @@ class PhenotypeSearch(DoSearch):
 
         return where_clause
 
-    def compile_final_query(self, from_clause = '', where_clause = ''):
+    def compile_final_query(self, from_clause='', where_clause=''):
         """Generates the final query string"""
 
         from_clause = self.normalize_spaces(from_clause)
@@ -292,7 +292,7 @@ class PhenotypeSearch(DoSearch):
     def run(self):
         """Generates and runs a simple search of a phenotype dataset"""
 
-        query = self.compile_final_query(where_clause = self.get_where_clause())
+        query = self.compile_final_query(where_clause=self.get_where_clause())
 
         return self.execute(query)
 
@@ -334,7 +334,7 @@ class GenotypeSearch(DoSearch):
 
         return where_clause
 
-    def compile_final_query(self, from_clause = '', where_clause = ''):
+    def compile_final_query(self, from_clause='', where_clause=''):
         """Generates the final query string"""
 
         from_clause = self.normalize_spaces(from_clause)
@@ -344,26 +344,26 @@ class GenotypeSearch(DoSearch):
             query = (self.base_query +
                     """WHERE Geno.Id = GenoXRef.GenoId
                         and GenoXRef.GenoFreezeId = GenoFreeze.Id
-                        and GenoFreeze.Id = %s"""% (escape(str(self.dataset.id))))
+                        and GenoFreeze.Id = %s""" % (escape(str(self.dataset.id))))
         else:
             query = (self.base_query +
                     """WHERE %s
                         and Geno.Id = GenoXRef.GenoId
                         and GenoXRef.GenoFreezeId = GenoFreeze.Id
-                        and GenoFreeze.Id = %s"""% (where_clause,
+                        and GenoFreeze.Id = %s""" % (where_clause,
                                                 escape(str(self.dataset.id))))
 
         return query
 
     def run(self):
         """Generates and runs a simple search of a genotype dataset"""
-        #Todo: Zach will figure out exactly what both these lines mean
-        #and comment here
+        # Todo: Zach will figure out exactly what both these lines mean
+        # and comment here
 
         if self.search_term[0] == "*":
             self.query = self.compile_final_query()
         else:
-            self.query = self.compile_final_query(where_clause = self.get_where_clause())
+            self.query = self.compile_final_query(where_clause=self.get_where_clause())
 
         return self.execute(self.query)
 
@@ -393,7 +393,7 @@ class RifSearch(MrnaAssaySearch):
 class WikiSearch(MrnaAssaySearch):
     """Searches GeneWiki for traits other people have annotated"""
 
-    DoSearch.search_types['ProbeSet_WIKI'] =  "WikiSearch"
+    DoSearch.search_types['ProbeSet_WIKI'] = "WikiSearch"
 
     def get_from_clause(self):
         return ", GeneRIF "
@@ -403,7 +403,7 @@ class WikiSearch(MrnaAssaySearch):
             and GeneRIF.versionId=0 and GeneRIF.display>0
             and (GeneRIF.comment REGEXP '%s' or GeneRIF.initial = '%s')
                 """ % (self.dataset.type,
-                       "[[:<:]]"+str(self.search_term[0])+"[[:>:]]",
+                       "[[:<:]]" + str(self.search_term[0]) + "[[:>:]]",
                        str(self.search_term[0]))
         return where_clause
 
@@ -418,7 +418,7 @@ class WikiSearch(MrnaAssaySearch):
 class GoSearch(MrnaAssaySearch):
     """Searches for synapse-associated genes listed in the Gene Ontology."""
 
-    DoSearch.search_types['ProbeSet_GO'] =  "GoSearch"
+    DoSearch.search_types['ProbeSet_GO'] = "GoSearch"
 
     def get_from_clause(self):
         from_clause = """, db_GeneOntology.term as GOterm,
@@ -429,7 +429,7 @@ class GoSearch(MrnaAssaySearch):
 
     def get_where_clause(self):
         field = 'GOterm.acc'
-        go_id = 'GO:' + ('0000000'+self.search_term[0])[-7:]
+        go_id = 'GO:' + ('0000000' + self.search_term[0])[-7:]
 
         statements = ("""%s.symbol=GOgene_product.symbol and
            GOassociation.gene_product_id=GOgene_product.id and
@@ -448,7 +448,7 @@ class GoSearch(MrnaAssaySearch):
 
         return self.execute(query)
 
-#ZS: Not sure what the best way to deal with LRS searches is
+# ZS: Not sure what the best way to deal with LRS searches is
 class LrsSearch(DoSearch):
     """Searches for genes with a QTL within the given LRS values
 
@@ -486,8 +486,8 @@ class LrsSearch(DoSearch):
             assert isinstance(self.search_term, (list, tuple))
             lrs_min, lrs_max = self.search_term[:2]
             if self.search_type == "LOD":
-                lrs_min = lrs_min*4.61
-                lrs_max = lrs_max*4.61
+                lrs_min = lrs_min * 4.61
+                lrs_max = lrs_max * 4.61
 
             where_clause = """ %sXRef.LRS > %s and
                              %sXRef.LRS < %s """ % self.mescape(self.dataset.type,
@@ -496,7 +496,7 @@ class LrsSearch(DoSearch):
                                                                 max(lrs_min, lrs_max))
 
             if len(self.search_term) > 2:
-                #If the user typed, for example "Chr4", the "Chr" substring needs to be removed so that all search elements can be converted to floats
+                # If the user typed, for example "Chr4", the "Chr" substring needs to be removed so that all search elements can be converted to floats
                 chr_num = self.search_term[2]
                 if "chr" in self.search_term[2].lower():
                     chr_num = self.search_term[2].lower().replace("chr", "")
@@ -518,7 +518,7 @@ class LrsSearch(DoSearch):
             logger.debug("self.search_term is:", self.search_term)
             lrs_val = self.search_term[0]
             if self.search_type == "LOD":
-                lrs_val = lrs_val*4.61
+                lrs_val = lrs_val * 4.61
 
             where_clause = """ %sXRef.LRS %s %s """ % self.mescape(self.dataset.type,
                                                                         self.search_operator,
@@ -546,7 +546,7 @@ class MrnaLrsSearch(LrsSearch, MrnaAssaySearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(from_clause = self.from_clause, where_clause = self.where_clause)
+        self.query = self.compile_final_query(from_clause=self.from_clause, where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -560,7 +560,7 @@ class PhenotypeLrsSearch(LrsSearch, PhenotypeSearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(from_clause = self.from_clause, where_clause = self.where_clause)
+        self.query = self.compile_final_query(from_clause=self.from_clause, where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -599,7 +599,7 @@ class CisTransLrsSearch(DoSearch):
                 lrs_max = lrs_max * 4.61
 
             sub_clause = """ %sXRef.LRS > %s and
-                %sXRef.LRS < %s  and """  % (
+                %sXRef.LRS < %s  and """ % (
                     escape(self.dataset.type),
                     escape(str(min(lrs_min, lrs_max))),
                     escape(self.dataset.type),
@@ -607,7 +607,7 @@ class CisTransLrsSearch(DoSearch):
                 )
         else:
             # Deal with >, <, >=, and <=
-            sub_clause = """ %sXRef.LRS %s %s and """  % (
+            sub_clause = """ %sXRef.LRS %s %s and """ % (
                     escape(self.dataset.type),
                     escape(self.search_operator),
                     escape(self.search_term[0])
@@ -667,7 +667,7 @@ class CisLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
     """
 
     for search_key in ('LRS', 'LOD'):
-        DoSearch.search_types['ProbeSet_CIS'+search_key] = "CisLrsSearch"
+        DoSearch.search_types['ProbeSet_CIS' + search_key] = "CisLrsSearch"
 
     def get_where_clause(self):
         return CisTransLrsSearch.get_where_clause(self, "cis")
@@ -697,7 +697,7 @@ class TransLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
     """
 
     for search_key in ('LRS', 'LOD'):
-        DoSearch.search_types['ProbeSet_TRANS'+search_key] = "TransLrsSearch"
+        DoSearch.search_types['ProbeSet_TRANS' + search_key] = "TransLrsSearch"
 
     def get_where_clause(self):
         return CisTransLrsSearch.get_where_clause(self, "trans")
@@ -740,7 +740,7 @@ class MeanSearch(MrnaAssaySearch):
         self.where_clause = self.get_where_clause()
         logger.debug("where_clause is:", pf(self.where_clause))
 
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -775,7 +775,7 @@ class RangeSearch(MrnaAssaySearch):
     def run(self):
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -815,7 +815,7 @@ class PositionSearch(DoSearch):
     def run(self):
 
         self.get_where_clause()
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -823,12 +823,12 @@ class MrnaPositionSearch(PositionSearch, MrnaAssaySearch):
     """Searches for genes located within a specified range on a specified chromosome"""
 
     for search_key in ('POSITION', 'POS', 'MB'):
-        DoSearch.search_types['ProbeSet_'+search_key] = "MrnaPositionSearch"
+        DoSearch.search_types['ProbeSet_' + search_key] = "MrnaPositionSearch"
 
     def run(self):
 
         self.where_clause = self.get_where_clause()
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -836,12 +836,12 @@ class GenotypePositionSearch(PositionSearch, GenotypeSearch):
     """Searches for genes located within a specified range on a specified chromosome"""
 
     for search_key in ('POSITION', 'POS', 'MB'):
-        DoSearch.search_types['Geno_'+search_key] = "GenotypePositionSearch"
+        DoSearch.search_types['Geno_' + search_key] = "GenotypePositionSearch"
 
     def run(self):
 
         self.where_clause = self.get_where_clause()
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -873,7 +873,7 @@ class PvalueSearch(MrnaAssaySearch):
 
         logger.debug("where_clause is:", pf(self.where_clause))
 
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         logger.sql(self.query)
         return self.execute(self.query)
@@ -888,7 +888,7 @@ class AuthorSearch(PhenotypeSearch):
         self.where_clause = """ Publication.Authors REGEXP "[[:<:]]%s[[:>:]]" and
                                 """ % (self.search_term[0])
 
-        self.query = self.compile_final_query(where_clause = self.where_clause)
+        self.query = self.compile_final_query(where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -924,8 +924,8 @@ def get_aliases(symbol, species):
     return filtered_aliases
 
 if __name__ == "__main__":
-    ### Usually this will be used as a library, but call it from the command line for testing
-    ### And it runs the code below
+    # Usually this will be used as a library, but call it from the command line for testing
+    # And it runs the code below
 
     import MySQLdb
     import sys
diff --git a/wqflask/wqflask/export_traits.py b/wqflask/wqflask/export_traits.py
index 6fb760e0..95c20673 100644
--- a/wqflask/wqflask/export_traits.py
+++ b/wqflask/wqflask/export_traits.py
@@ -13,7 +13,7 @@ from base.trait import create_trait, retrieve_trait_info
 from pprint import pformat as pf
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 def export_search_results_csv(targs):
 
diff --git a/wqflask/wqflask/external_tools/send_to_bnw.py b/wqflask/wqflask/external_tools/send_to_bnw.py
index c5c79e98..9836eb9c 100644
--- a/wqflask/wqflask/external_tools/send_to_bnw.py
+++ b/wqflask/wqflask/external_tools/send_to_bnw.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -22,7 +22,7 @@ from base.trait import GeneralTrait
 from utility import helper_functions, corr_result_helpers
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class SendToBNW:
     def __init__(self, start_vars):
@@ -40,7 +40,7 @@ class SendToBNW:
 
         shared_samples = list(set(trait_samples_list[0]).intersection(*trait_samples_list))
 
-        self.form_value = "" #ZS: string that is passed to BNW through form
+        self.form_value = ""  # ZS: string that is passed to BNW through form
         values_list = []
         for trait_db in self.trait_list:
             this_trait = trait_db[0]
diff --git a/wqflask/wqflask/external_tools/send_to_geneweaver.py b/wqflask/wqflask/external_tools/send_to_geneweaver.py
index 47e4c53a..36f1b8e5 100644
--- a/wqflask/wqflask/external_tools/send_to_geneweaver.py
+++ b/wqflask/wqflask/external_tools/send_to_geneweaver.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -27,7 +27,7 @@ from base.species import TheSpecies
 from utility import helper_functions, corr_result_helpers
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class SendToGeneWeaver:
     def __init__(self, start_vars):
@@ -74,7 +74,7 @@ def test_chip(trait_list):
                                  FROM GeneChip, ProbeFreeze, ProbeSetFreeze
                                  WHERE GeneChip.Id = ProbeFreeze.ChipId and
                                      ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and
-                                     ProbeSetFreeze.Name = '%s'"""  % dataset.name).fetchone()
+                                     ProbeSetFreeze.Name = '%s'""" % dataset.name).fetchone()
 
         if result:
             chip_name = result[0]
diff --git a/wqflask/wqflask/external_tools/send_to_webgestalt.py b/wqflask/wqflask/external_tools/send_to_webgestalt.py
index e1e5e655..f50eeb8b 100644
--- a/wqflask/wqflask/external_tools/send_to_webgestalt.py
+++ b/wqflask/wqflask/external_tools/send_to_webgestalt.py
@@ -1,4 +1,4 @@
-## Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
+# Copyright (C) University of Tennessee Health Science Center, Memphis, TN.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Affero General Public License
@@ -27,7 +27,7 @@ from base.species import TheSpecies
 from utility import helper_functions, corr_result_helpers
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class SendToWebGestalt:
     def __init__(self, start_vars):
@@ -47,16 +47,16 @@ class SendToWebGestalt:
             id_type = "entrezgene"
 
             self.hidden_vars = { 
-                             'gene_list'                  : "\n".join(gene_id_list),
-                             'id_type'                    : "entrezgene",
-                             'ref_set'                    : "genome",
-                             'enriched_database_category' : "geneontology",
-                             'enriched_database_name'     : "Biological_Process",
-                             'sig_method'                 : "fdr",
-                             'sig_value'                  : "0.05",
-                             'enrich_method'              : "ORA",
-                             'fdr_method'                 : "BH",
-                             'min_num'                    : "2"
+                             'gene_list': "\n".join(gene_id_list),
+                             'id_type': "entrezgene",
+                             'ref_set': "genome",
+                             'enriched_database_category': "geneontology",
+                             'enriched_database_name': "Biological_Process",
+                             'sig_method': "fdr",
+                             'sig_value': "0.05",
+                             'enrich_method': "ORA",
+                             'fdr_method': "BH",
+                             'min_num': "2"
                                }
 
             species = self.trait_list[0][1].group.species
@@ -78,7 +78,7 @@ def test_chip(trait_list):
                                  FROM GeneChip, ProbeFreeze, ProbeSetFreeze
                                  WHERE GeneChip.Id = ProbeFreeze.ChipId and
                                      ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id and
-                                     ProbeSetFreeze.Name = '%s'"""  % dataset.name).fetchone()
+                                     ProbeSetFreeze.Name = '%s'""" % dataset.name).fetchone()
 
         if result:
             chip_name = result[0]
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index 69ee9623..f29c0e4d 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -40,8 +40,8 @@ def view_group():
          user_info = get_user_by_unique_column("user_id", user_id)
          members_info.append(user_info)
 
-   #ZS: This whole part might not scale well with many resources
-   resources_info  = []
+   # ZS: This whole part might not scale well with many resources
+   resources_info = []
    all_resources = get_resources()
    for resource_id in all_resources:
       resource_info = get_resource_info(resource_id)
@@ -82,10 +82,10 @@ def add_users(user_type='members'):
    group_id = request.form['group_id']
    if user_type == "admins":
       user_emails = request.form['admin_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins = True)
+      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins=True)
    elif user_type == "members":
       user_emails = request.form['member_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins = False)
+      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins=False)
 
    return redirect(url_for('view_group', id=group_id))
 
@@ -103,7 +103,7 @@ def add_or_edit_group():
    if "group_name" in params:
       member_user_ids = set()
       admin_user_ids = set()
-      admin_user_ids.add(g.user_session.user_id) #ZS: Always add the user creating the group as an admin
+      admin_user_ids.add(g.user_session.user_id)  # ZS: Always add the user creating the group as an admin
       if "admin_emails_to_add" in params:
          admin_emails = params['admin_emails_to_add'].split(",")
          for email in admin_emails:
@@ -124,22 +124,22 @@ def add_or_edit_group():
    else:
       return render_template("admin/create_group.html")
 
-#ZS: Will integrate this later, for now just letting users be added directly
-def send_group_invites(group_id, user_email_list = [], user_type="members"):
+# ZS: Will integrate this later, for now just letting users be added directly
+def send_group_invites(group_id, user_email_list=[], user_type="members"):
    for user_email in user_email_list:
       user_details = get_user_by_unique_column("email_address", user_email)
       if user_details:
          group_info = get_group_info(group_id)
-         #ZS: Probably not necessary since the group should normally always exist if group_id is being passed here,
+         # ZS: Probably not necessary since the group should normally always exist if group_id is being passed here,
          #    but it's technically possible to hit it if Redis is cleared out before submitting the new users or something
          if group_info:
-            #ZS: Don't add user if they're already an admin or if they're being added a regular user and are already a regular user,
+            # ZS: Don't add user if they're already an admin or if they're being added a regular user and are already a regular user,
             #    but do add them if they're a regular user and are added as an admin
             if (user_details['user_id'] in group_info['admins']) or \
                ((user_type == "members") and (user_details['user_id'] in group_info['members'])):
                continue
             else:
-               send_verification_email(user_details, template_name = "email/group_verification.txt", key_prefix = "verification_code", subject = "You've been invited to join a GeneNetwork user group")
+               send_verification_email(user_details, template_name="email/group_verification.txt", key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
       else:
          temp_password = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
          user_details = {
@@ -152,4 +152,4 @@ def send_group_invites(group_id, user_email_list = [], user_type="members"):
          save_user(user_details, user_details['user_id'])
          send_invitation_email(user_email, temp_password)
 
-#@app.route()
+# @app.route()
diff --git a/wqflask/wqflask/gsearch.py b/wqflask/wqflask/gsearch.py
index 9bf23d57..8cb81dcc 100644
--- a/wqflask/wqflask/gsearch.py
+++ b/wqflask/wqflask/gsearch.py
@@ -102,7 +102,7 @@ class GSearch:
                     this_trait['locus_chr'] = line[16]
                     this_trait['locus_mb'] = line[17]
 
-                    dataset_ob = SimpleNamespace(id=this_trait["dataset_id"], type="ProbeSet",species=this_trait["species"])
+                    dataset_ob = SimpleNamespace(id=this_trait["dataset_id"], type="ProbeSet", species=this_trait["species"])
                     if dataset_ob.id not in dataset_to_permissions:
                         permissions = check_resource_availability(dataset_ob)
                         dataset_to_permissions[dataset_ob.id] = permissions
diff --git a/wqflask/wqflask/heatmap/heatmap.py b/wqflask/wqflask/heatmap/heatmap.py
index 20e3559a..f8ef7028 100644
--- a/wqflask/wqflask/heatmap/heatmap.py
+++ b/wqflask/wqflask/heatmap/heatmap.py
@@ -12,7 +12,7 @@ from utility.logger import getLogger
 
 Redis = Redis()
 
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 class Heatmap:
 
@@ -24,7 +24,7 @@ class Heatmap:
         self.num_permutations = 5000
         self.dataset = self.trait_list[0][1]
 
-        self.json_data = {} #The dictionary that will be used to create the json object that contains all the data needed to create the figure
+        self.json_data = {}  # The dictionary that will be used to create the json object that contains all the data needed to create the figure
 
         self.all_sample_list = []
         self.traits = []
@@ -83,7 +83,7 @@ class Heatmap:
             self.json_data[trait] = self.trait_results[trait]
 
         self.js_data = dict(
-            json_data = self.json_data
+            json_data=self.json_data
         )
 
     def gen_reaper_results(self):
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index d0dd7aea..9779878e 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -2,14 +2,14 @@ import string
 
 from flask import Flask, g
 
-#Just return a list of dictionaries
-#each dictionary contains sub-dictionary
+# Just return a list of dictionaries
+# each dictionary contains sub-dictionary
 def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 	fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
 	'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
 	'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
 	
-	##List All Species in the Gene Table
+	# List All Species in the Gene Table
 	speciesDict = {}
 	results = g.db.execute("""
                 SELECT Species.Name, GeneList.SpeciesId
@@ -20,7 +20,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 	for item in results:
 		speciesDict[item[0]] = item[1]
 	
-	##List current Species and other Species
+	# List current Species and other Species
 	speciesId = speciesDict[species]
 	otherSpecies = [[X, speciesDict[X]] for X in list(speciesDict.keys())]
 	otherSpecies.remove([species, speciesId])
@@ -43,8 +43,8 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 			newdict = {}
 			for j, item in enumerate(fetchFields):
 				newdict[item] = result[j]
-			#count SNPs if possible	
-			if diffCol and species=='mouse':
+			# count SNPs if possible	
+			if diffCol and species == 'mouse':
 				newdict["snpCount"] = g.db.execute("""
                                         SELECT count(*)
                                         FROM BXDSnpPosition
@@ -52,16 +52,16 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                               Mb >= %2.6f AND Mb < %2.6f AND
                                               StrainId1 = %d AND StrainId2 = %d
                                         """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
-				newdict["snpDensity"] = newdict["snpCount"]/(newdict["TxEnd"]-newdict["TxStart"])/1000.0
+				newdict["snpDensity"] = newdict["snpCount"] / (newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
 			else:
 				newdict["snpDensity"] = newdict["snpCount"] = 0
 			
 			try:
-				newdict['GeneLength'] = 1000.0*(newdict['TxEnd'] - newdict['TxStart'])
+				newdict['GeneLength'] = 1000.0 * (newdict['TxEnd'] - newdict['TxStart'])
 			except:
 				pass
 			
-			#load gene from other Species by the same name
+			# load gene from other Species by the same name
 			for item in otherSpecies:
 				othSpec, othSpecId = item
 				newdict2 = {}
@@ -74,7 +74,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 					for j, item in enumerate(fetchFields):
 						newdict2[item] = resultsOther[j]
 							
-					#count SNPs if possible, could be a separate function	
+					# count SNPs if possible, could be a separate function	
 					if diffCol and othSpec == 'mouse':
 						newdict2["snpCount"] = g.db.execute("""
                                                     SELECT count(*)
@@ -84,12 +84,12 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                                           StrainId1 = %d AND StrainId2 = %d
                                                     """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
 
-						newdict2["snpDensity"] = newdict2["snpCount"]/(newdict2["TxEnd"]-newdict2["TxStart"])/1000.0
+						newdict2["snpDensity"] = newdict2["snpCount"] / (newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
 					else:
 						newdict2["snpDensity"] = newdict2["snpCount"] = 0
 						
 					try:
-						newdict2['GeneLength'] = 1000.0*(newdict2['TxEnd'] - newdict2['TxStart'])
+						newdict2['GeneLength'] = 1000.0 * (newdict2['TxEnd'] - newdict2['TxStart'])
 					except:
 						pass
 						
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index 4074f098..3753d1ce 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -51,7 +51,7 @@ try:  # Only import this for Python3
     from functools import reduce
 except:
     pass
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 RED = ImageColor.getrgb("red")
 BLUE = ImageColor.getrgb("blue")
@@ -390,24 +390,24 @@ class DisplayMappingResults:
         else:
             self.genotype = self.dataset.group.read_genotype_file()
 
-        #Darwing Options
+        # Darwing Options
         try:
            if self.selectedChr > -1:
-               self.graphWidth  = min(self.GRAPH_MAX_WIDTH, max(self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
            else:
-               self.graphWidth  = min(self.GRAPH_MAX_WIDTH, max(self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
         except:
            if self.selectedChr > -1:
-               self.graphWidth  = self.GRAPH_DEFAULT_WIDTH
+               self.graphWidth = self.GRAPH_DEFAULT_WIDTH
            else:
-               self.graphWidth  = self.MULT_GRAPH_DEFAULT_WIDTH
+               self.graphWidth = self.MULT_GRAPH_DEFAULT_WIDTH
 
-## BEGIN HaplotypeAnalyst
+# BEGIN HaplotypeAnalyst
         if 'haplotypeAnalystCheck' in list(start_vars.keys()):
             self.haplotypeAnalystChecked = start_vars['haplotypeAnalystCheck']
         else:
             self.haplotypeAnalystChecked = False
-## END HaplotypeAnalyst
+# END HaplotypeAnalyst
 
         self.graphHeight = self.GRAPH_DEFAULT_HEIGHT
         self.dominanceChecked = False
@@ -446,7 +446,7 @@ class DisplayMappingResults:
         except:
             self.lrsMax = 0
 
-        #Trait Infos
+        # Trait Infos
         self.identification = ""
 
         ################################################################
@@ -471,10 +471,10 @@ class DisplayMappingResults:
                         Chr_Length.OrderId
                 """ % (self.dataset.group.name, ", ".join(["'%s'" % X[0] for X in self.ChrList[1:]])))
 
-        self.ChrLengthMbList = [x[0]/1000000.0 for x in self.ChrLengthMbList]
-        self.ChrLengthMbSum = reduce(lambda x, y:x+y, self.ChrLengthMbList, 0.0)
+        self.ChrLengthMbList = [x[0] / 1000000.0 for x in self.ChrLengthMbList]
+        self.ChrLengthMbSum = reduce(lambda x, y: x + y, self.ChrLengthMbList, 0.0)
         if self.ChrLengthMbList:
-            self.MbGraphInterval = self.ChrLengthMbSum/(len(self.ChrLengthMbList)*12) #Empirical Mb interval
+            self.MbGraphInterval = self.ChrLengthMbSum / (len(self.ChrLengthMbList) * 12)  # Empirical Mb interval
         else:
             self.MbGraphInterval = 1
 
@@ -482,18 +482,18 @@ class DisplayMappingResults:
         for i, _chr in enumerate(self.genotype):
             self.ChrLengthCMList.append(_chr[-1].cM - _chr[0].cM)
 
-        self.ChrLengthCMSum = reduce(lambda x, y:x+y, self.ChrLengthCMList, 0.0)
+        self.ChrLengthCMSum = reduce(lambda x, y: x + y, self.ChrLengthCMList, 0.0)
 
         if self.plotScale == 'physic':
-            self.GraphInterval = self.MbGraphInterval #Mb
+            self.GraphInterval = self.MbGraphInterval  # Mb
         else:
-            self.GraphInterval = self.cMGraphInterval #cM
+            self.GraphInterval = self.cMGraphInterval  # cM
 
-## BEGIN HaplotypeAnalyst
-## count the amount of individuals to be plotted, and increase self.graphHeight
+# BEGIN HaplotypeAnalyst
+# count the amount of individuals to be plotted, and increase self.graphHeight
         if self.haplotypeAnalystChecked and self.selectedChr > -1:
             thisTrait = self.this_trait
-            smd=[]
+            smd = []
             for sample in self.sample_vals_dict.keys():
                 if self.sample_vals_dict[sample] != "x":
                     temp = GeneralObject(name=sample, value=float(self.sample_vals_dict[sample]))
@@ -501,19 +501,19 @@ class DisplayMappingResults:
                 else:
                     continue
             samplelist = list(self.genotype.prgy)
-            for j, _geno in enumerate (self.genotype[0][1].genotype):
+            for j, _geno in enumerate(self.genotype[0][1].genotype):
                 for item in smd:
                     if item.name == samplelist[j]:
                         self.NR_INDIVIDUALS = self.NR_INDIVIDUALS + 1
 # default:
-            self.graphHeight = self.graphHeight + 2 * (self.NR_INDIVIDUALS+10) * self.EACH_GENE_HEIGHT
-## END HaplotypeAnalyst
+            self.graphHeight = self.graphHeight + 2 * (self.NR_INDIVIDUALS + 10) * self.EACH_GENE_HEIGHT
+# END HaplotypeAnalyst
 
 
 
 
         #########################
-        ## Get the sorting column
+        # Get the sorting column
         #########################
         RISet = self.dataset.group.name
         if RISet in ('AXB', 'BXA', 'AXBXA'):
@@ -529,7 +529,7 @@ class DisplayMappingResults:
         elif RISet in ('LXS'):
             self.diffCol = ['ILS', 'ISS']
         else:
-            self.diffCol= []
+            self.diffCol = []
 
         for i, strain in enumerate(self.diffCol):
             self.diffCol[i] = g.db.execute("select Id from Strain where Symbol = %s", strain).fetchone()[0]
@@ -546,7 +546,7 @@ class DisplayMappingResults:
         geneTable = ""
 
         self.geneCol = None
-        if self.plotScale == 'physic' and self.selectedChr > -1 and (self.intervalAnalystChecked  or self.geneChecked):
+        if self.plotScale == 'physic' and self.selectedChr > -1 and (self.intervalAnalystChecked or self.geneChecked):
             # Draw the genes for this chromosome / region of this chromosome
             webqtldatabase = self.dataset.name
 
@@ -580,11 +580,11 @@ class DisplayMappingResults:
         showLocusForm = ""
         intCanvas = Image.new("RGBA", size=(self.graphWidth, self.graphHeight))
         with Bench("Drawing Plot"):
-            gifmap = self.plotIntMapping(intCanvas, startMb = self.startMb, endMb = self.endMb, showLocusForm= showLocusForm)
+            gifmap = self.plotIntMapping(intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm)
 
         self.gifmap = gifmap.__str__()
 
-        self.filename= webqtlUtil.genRandStr("Itvl_")
+        self.filename = webqtlUtil.genRandStr("Itvl_")
         intCanvas.save(
             "{}.png".format(
                 os.path.join(webqtlConfig.GENERATED_IMAGE_DIR, self.filename)),
@@ -594,20 +594,20 @@ class DisplayMappingResults:
             border="0", usemap='#WebQTLImageMap'
         )
 
-        #Scales plot differently for high resolution
+        # Scales plot differently for high resolution
         if self.draw2X:
-            intCanvasX2 = Image.new("RGBA", size=(self.graphWidth*2, self.graphHeight*2))
-            gifmapX2 = self.plotIntMapping(intCanvasX2, startMb = self.startMb, endMb = self.endMb, showLocusForm= showLocusForm, zoom=2)
+            intCanvasX2 = Image.new("RGBA", size=(self.graphWidth * 2, self.graphHeight * 2))
+            gifmapX2 = self.plotIntMapping(intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm, zoom=2)
             intCanvasX2.save(
                 "{}.png".format(
                     os.path.join(webqtlConfig.GENERATED_IMAGE_DIR,
-                                 self.filename+"X2")),
+                                 self.filename + "X2")),
                 format='png')
 
         ################################################################
         # Outputs goes here
         ################################################################
-        #this form is used for opening Locus page or trait page, only available for genetic mapping
+        # this form is used for opening Locus page or trait page, only available for genetic mapping
         if showLocusForm:
             showLocusForm = HtmlGenWrapper.create_form_tag(
                 cgi=os.path.join(webqtlConfig.CGIDIR, webqtlConfig.SCRIPTFILE),
@@ -615,7 +615,7 @@ class DisplayMappingResults:
                 name=showLocusForm,
                 submit=HtmlGenWrapper.create_input_tag(type_='hidden'))
 
-            hddn = {'FormID':'showDatabase', 'ProbeSetID':'_','database':fd.RISet+"Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
+            hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet+"Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
             for key in hddn.keys():
                 showLocusForm.append(HtmlGenWrapper.create_input_tag(
                     name=key, value=hddn[key], type_='hidden'))
@@ -636,9 +636,9 @@ class DisplayMappingResults:
             btminfo.append(HtmlGenWrapper.create_br_tag())
             btminfo.append('Mapping using genotype data as a trait will result in infinity LRS at one locus. In order to display the result properly, all LRSs higher than 100 are capped at 100.')
 
-    def plotIntMapping(self, canvas, offset= (80, 120, 90, 100), zoom = 1, startMb = None, endMb = None, showLocusForm = ""):
+    def plotIntMapping(self, canvas, offset=(80, 120, 90, 100), zoom=1, startMb= None, endMb = None, showLocusForm = ""):
         im_drawer = ImageDraw.Draw(canvas)
-        #calculating margins
+        # calculating margins
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         if self.multipleInterval:
             yTopOffset = max(90, yTopOffset)
@@ -659,34 +659,34 @@ class DisplayMappingResults:
             xLeftOffset += 20
             fontZoom = 1.5
 
-        xLeftOffset = int(xLeftOffset*fontZoom)
-        xRightOffset = int(xRightOffset*fontZoom)
-        yBottomOffset = int(yBottomOffset*fontZoom)
+        xLeftOffset = int(xLeftOffset * fontZoom)
+        xRightOffset = int(xRightOffset * fontZoom)
+        yBottomOffset = int(yBottomOffset * fontZoom)
 
         cWidth = canvas.size[0]
         cHeight = canvas.size[1]
         plotWidth = cWidth - xLeftOffset - xRightOffset
         plotHeight = cHeight - yTopOffset - yBottomOffset
 
-        #Drawing Area Height
+        # Drawing Area Height
         drawAreaHeight = plotHeight
         if self.plotScale == 'physic' and self.selectedChr > -1:
             if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-                drawAreaHeight -= 4*self.BAND_HEIGHT + 4*self.BAND_SPACING+ 10*zoom
+                drawAreaHeight -= 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING + 10 * zoom
             else:
-                drawAreaHeight -= 3*self.BAND_HEIGHT + 3*self.BAND_SPACING+ 10*zoom
+                drawAreaHeight -= 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
             if self.geneChecked:
-                drawAreaHeight -= self.NUM_GENE_ROWS*self.EACH_GENE_HEIGHT + 3*self.BAND_SPACING + 10*zoom
+                drawAreaHeight -= self.NUM_GENE_ROWS * self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
         else:
             if self.selectedChr > -1:
                 drawAreaHeight -= 20
             else:
                 drawAreaHeight -= 30
 
-## BEGIN HaplotypeAnalyst
+# BEGIN HaplotypeAnalyst
         if self.haplotypeAnalystChecked and self.selectedChr > -1:
-            drawAreaHeight -= self.EACH_GENE_HEIGHT * (self.NR_INDIVIDUALS+10) * 2 * zoom
-## END HaplotypeAnalyst
+            drawAreaHeight -= self.EACH_GENE_HEIGHT * (self.NR_INDIVIDUALS + 10) * 2 * zoom
+# END HaplotypeAnalyst
 
         if zoom == 2:
             drawAreaHeight -= 60
@@ -696,42 +696,42 @@ class DisplayMappingResults:
 
         newoffset = (xLeftOffset, xRightOffset, yTopOffset, yBottomOffset)
         # Draw the alternating-color background first and get plotXScale
-        plotXScale = self.drawGraphBackground(canvas, gifmap, offset=newoffset, zoom= zoom, startMb=startMb, endMb = endMb)
+        plotXScale = self.drawGraphBackground(canvas, gifmap, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
-        #draw bootstap
+        # draw bootstap
         if self.bootChecked and not self.multipleInterval:
-            self.drawBootStrapResult(canvas, self.nboot, drawAreaHeight, plotXScale, offset=newoffset, zoom= zoom, startMb=startMb, endMb = endMb)
+            self.drawBootStrapResult(canvas, self.nboot, drawAreaHeight, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
         # Draw clickable region and gene band if selected
         if self.plotScale == 'physic' and self.selectedChr > -1:
-            self.drawClickBand(canvas, gifmap, plotXScale, offset=newoffset, zoom = zoom, startMb=startMb, endMb = endMb)
+            self.drawClickBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
             if self.geneChecked and self.geneCol:
-                self.drawGeneBand(canvas, gifmap, plotXScale, offset=newoffset, zoom = zoom, startMb=startMb, endMb = endMb)
+                self.drawGeneBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
             if self.SNPChecked:
-                self.drawSNPTrackNew(canvas, offset=newoffset, zoom = 2*zoom, startMb=startMb, endMb = endMb)
-## BEGIN HaplotypeAnalyst
+                self.drawSNPTrackNew(canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb = endMb)
+# BEGIN HaplotypeAnalyst
             if self.haplotypeAnalystChecked:
-                self.drawHaplotypeBand(canvas, gifmap, plotXScale, offset=newoffset, zoom = zoom, startMb=startMb, endMb = endMb)
-## END HaplotypeAnalyst
+                self.drawHaplotypeBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+# END HaplotypeAnalyst
         # Draw X axis
-        self.drawXAxis(canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=newoffset, zoom = zoom, startMb=startMb, endMb = endMb)
+        self.drawXAxis(canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
         # Draw QTL curve
-        self.drawQTL(canvas, drawAreaHeight, gifmap, plotXScale, offset=newoffset, zoom= zoom, startMb=startMb, endMb = endMb)
+        self.drawQTL(canvas, drawAreaHeight, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
-        #draw legend
+        # draw legend
         if self.multipleInterval:
             self.drawMultiTraitName(fd, canvas, gifmap, showLocusForm, offset=newoffset)
         elif self.legendChecked:
-            self.drawLegendPanel(canvas, offset=newoffset, zoom = zoom)
+            self.drawLegendPanel(canvas, offset=newoffset, zoom=zoom)
         else:
             pass
 
-        #draw position, no need to use a separate function
-        self.drawProbeSetPosition(canvas, plotXScale, offset=newoffset, zoom = zoom)
+        # draw position, no need to use a separate function
+        self.drawProbeSetPosition(canvas, plotXScale, offset=newoffset, zoom=zoom)
 
         return gifmap
 
-    def drawBootStrapResult(self, canvas, nboot, drawAreaHeight, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawBootStrapResult(self, canvas, nboot, drawAreaHeight, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -741,9 +741,9 @@ class DisplayMappingResults:
         if zoom == 2:
             fontZoom = 1.5
 
-        bootHeightThresh = drawAreaHeight*3/4
+        bootHeightThresh = drawAreaHeight * 3 / 4
 
-        #break bootstrap result into groups
+        # break bootstrap result into groups
         BootCoord = []
         i = 0
         previous_chr = None
@@ -751,7 +751,7 @@ class DisplayMappingResults:
         startX = xLeftOffset
 
         BootChrCoord = []
-        if self.selectedChr == -1: #ZS: If viewing full genome/all chromosomes
+        if self.selectedChr == -1:  # ZS: If viewing full genome/all chromosomes
             for i, result in enumerate(self.qtlresults):
                 if result['chr'] != previous_chr:
                     previous_chr = result['chr']
@@ -759,28 +759,28 @@ class DisplayMappingResults:
                     if previous_chr_as_int != 1:
                         BootCoord.append(BootChrCoord)
                         BootChrCoord = []
-                        startX += (self.ChrLengthDistList[previous_chr_as_int - 2] + self.GraphInterval)*plotXScale
+                        startX += (self.ChrLengthDistList[previous_chr_as_int - 2] + self.GraphInterval) * plotXScale
                 if self.plotScale == 'physic':
-                    Xc = startX + (result['Mb']-self.startMb)*plotXScale
+                    Xc = startX + (result['Mb'] - self.startMb) * plotXScale
                 else:
-                    Xc = startX + (result['cM']-self.qtlresults[0]['cM'])*plotXScale
+                    Xc = startX + (result['cM'] - self.qtlresults[0]['cM']) * plotXScale
                 BootChrCoord.append([Xc, self.bootResult[i]])
         else:
             for i, result in enumerate(self.qtlresults):
                 if str(result['chr']) == str(self.ChrList[self.selectedChr][0]):
                     if self.plotScale == 'physic':
-                        Xc = startX + (result['Mb']-self.startMb)*plotXScale
+                        Xc = startX + (result['Mb'] - self.startMb) * plotXScale
                     else:
-                        Xc = startX + (result['cM']-self.qtlresults[0]['cM'])*plotXScale
+                        Xc = startX + (result['cM'] - self.qtlresults[0]['cM']) * plotXScale
                     BootChrCoord.append([Xc, self.bootResult[i]])
             BootCoord = [BootChrCoord]
 
-        #reduce bootResult
+        # reduce bootResult
         if self.selectedChr > -1:
             maxBootBar = 80.0
         else:
             maxBootBar = 200.0
-        stepBootStrap = plotWidth/maxBootBar
+        stepBootStrap = plotWidth / maxBootBar
         reducedBootCoord = []
         maxBootCount = 0
 
@@ -801,8 +801,8 @@ class DisplayMappingResults:
                     bootCount = BootChrCoord[i][1]
                 # end else
             # end for
-            #add last piece
-            if BootChrCoord[-1][0] - bootStartPixX  > stepBootStrap/2.0:
+            # add last piece
+            if BootChrCoord[-1][0] - bootStartPixX > stepBootStrap / 2.0:
                 reducedBootCoord.append([bootStartPixX, BootChrCoord[-1][0], bootCount])
             else:
                 reducedBootCoord[-1][2] += bootCount
@@ -815,64 +815,64 @@ class DisplayMappingResults:
             if item[2] > 0:
                 if item[0] < xLeftOffset:
                     item[0] = xLeftOffset
-                if item[0] > xLeftOffset+plotWidth:
-                    item[0] = xLeftOffset+plotWidth
+                if item[0] > xLeftOffset + plotWidth:
+                    item[0] = xLeftOffset + plotWidth
                 if item[1] < xLeftOffset:
                     item[1] = xLeftOffset
-                if item[1] > xLeftOffset+plotWidth:
-                    item[1] = xLeftOffset+plotWidth
+                if item[1] > xLeftOffset + plotWidth:
+                    item[1] = xLeftOffset + plotWidth
                 if item[0] != item[1]:
                     im_drawer.rectangle(
                         xy=((item[0], yZero),
-                            (item[1], yZero - item[2]*bootHeightThresh/maxBootCount)),
+                            (item[1], yZero - item[2] * bootHeightThresh / maxBootCount)),
                         fill=self.BOOTSTRAP_BOX_COLOR, outline=BLACK)
 
-        ###draw boot scale
-        highestPercent = (maxBootCount*100.0)/nboot
+        # draw boot scale
+        highestPercent = (maxBootCount * 100.0) / nboot
         bootScale = Plot.detScale(0, highestPercent)
-        bootScale = Plot.frange(bootScale[0], bootScale[1], bootScale[1]/bootScale[2])
+        bootScale = Plot.frange(bootScale[0], bootScale[1], bootScale[1] / bootScale[2])
         bootScale = bootScale[:-1] + [highestPercent]
 
-        bootOffset = 50*fontZoom
-        bootScaleFont=ImageFont.truetype(font=VERDANA_FILE, size=13*fontZoom)
+        bootOffset = 50 * fontZoom
+        bootScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=13 * fontZoom)
         im_drawer.rectangle(
-            xy=((canvas.size[0]-bootOffset, yZero-bootHeightThresh),
-                (canvas.size[0]-bootOffset-15*zoom, yZero)),
-            fill = YELLOW, outline=BLACK)
+            xy=((canvas.size[0] - bootOffset, yZero - bootHeightThresh),
+                (canvas.size[0] - bootOffset - 15*zoom, yZero)),
+            fill=YELLOW, outline=BLACK)
         im_drawer.line(
-            xy=((canvas.size[0]-bootOffset+4, yZero),
-                (canvas.size[0]-bootOffset, yZero)),
+            xy=((canvas.size[0] - bootOffset + 4, yZero),
+                (canvas.size[0] - bootOffset, yZero)),
             fill=BLACK)
         TEXT_Y_DISPLACEMENT = -8
-        im_drawer.text(xy=(canvas.size[0]-bootOffset+10, yZero+TEXT_Y_DISPLACEMENT), text='0%',
+        im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, yZero+TEXT_Y_DISPLACEMENT), text='0%',
                        font=bootScaleFont, fill=BLACK)
 
         for item in bootScale:
             if item == 0:
                 continue
-            bootY = yZero-bootHeightThresh*item/highestPercent
+            bootY = yZero - bootHeightThresh * item / highestPercent
             im_drawer.line(
-                xy=((canvas.size[0]-bootOffset+4, bootY),
-                 (canvas.size[0]-bootOffset, bootY)),
+                xy=((canvas.size[0] - bootOffset + 4, bootY),
+                 (canvas.size[0] - bootOffset, bootY)),
                 fill=BLACK)
-            im_drawer.text(xy=(canvas.size[0]-bootOffset+10, bootY+TEXT_Y_DISPLACEMENT),
-                           text='%2.1f'%item, font=bootScaleFont, fill=BLACK)
+            im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, bootY+TEXT_Y_DISPLACEMENT),
+                           text='%2.1f' % item, font=bootScaleFont, fill=BLACK)
 
         if self.legendChecked:
             if hasattr(self.traitList[0], 'chr') and hasattr(self.traitList[0], 'mb'):
                 startPosY = 30
             else:
                 startPosY = 15
-            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12*fontZoom)
+            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
             leftOffset = canvas.size[0] - xRightOffset - 190
             im_drawer.rectangle(
-                xy=((leftOffset, startPosY-6), (leftOffset+12, startPosY+6)),
+                xy=((leftOffset, startPosY - 6), (leftOffset + 12, startPosY + 6)),
                 fill=YELLOW, outline=BLACK)
-            im_drawer.text(xy=(canvas.size[0] - xRightOffset - 170, startPosY+TEXT_Y_DISPLACEMENT),
+            im_drawer.text(xy=(canvas.size[0] - xRightOffset - 170, startPosY + TEXT_Y_DISPLACEMENT),
                            text='Frequency of the Peak LRS',
                            font=smallLabelFont, fill=BLACK)
 
-    def drawProbeSetPosition(self, canvas, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawProbeSetPosition(self, canvas, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         if len(self.traitList) != 1:
             return
@@ -896,21 +896,21 @@ class DisplayMappingResults:
         if self.plotScale == "physic":
             this_chr = str(self.ChrList[self.selectedChr][0])
         else:
-            this_chr = str(self.ChrList[self.selectedChr][1]+1)
+            this_chr = str(self.ChrList[self.selectedChr][1] + 1)
 
         if self.plotScale == 'physic':
             if self.selectedChr > -1:
                 if this_chr != Chr or Mb < self.startMb or Mb > self.endMb:
                     return
                 else:
-                    locPixel = xLeftOffset + (Mb-self.startMb)*plotXScale
+                    locPixel = xLeftOffset + (Mb - self.startMb) * plotXScale
             else:
                 locPixel = xLeftOffset
                 for i, _chr in enumerate(self.ChrList[1:]):
                     if _chr[0] != Chr:
-                        locPixel += (self.ChrLengthDistList[i] + self.GraphInterval)*plotXScale
+                        locPixel += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
                     else:
-                        locPixel += Mb*plotXScale
+                        locPixel += Mb * plotXScale
                         break
         else:
             if self.selectedChr > -1:
@@ -918,33 +918,33 @@ class DisplayMappingResults:
                     if qtlresult['chr'] != self.selectedChr:
                         continue
 
-                    if i==0 and qtlresult['Mb'] >= Mb:
-                        locPixel=-1
+                    if i == 0 and qtlresult['Mb'] >= Mb:
+                        locPixel = -1
                         break
 
-                    #the trait's position is between two traits
-                    if i > 0 and self.qtlresults[i-1]['Mb'] < Mb and qtlresult['Mb'] >= Mb:
-                        locPixel = xLeftOffset + plotXScale*(self.qtlresults[i-1]['Mb']+(qtlresult['Mb']-self.qtlresults[i-1]['Mb'])*(Mb - self.qtlresults[i-1]['Mb'])/(qtlresult['Mb']-self.qtlresults[i-1]['Mb']))
+                    # the trait's position is between two traits
+                    if i > 0 and self.qtlresults[i - 1]['Mb'] < Mb and qtlresult['Mb'] >= Mb:
+                        locPixel = xLeftOffset + plotXScale * (self.qtlresults[i - 1]['Mb'] + (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']) * (Mb - self.qtlresults[i - 1]['Mb']) / (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']))
                         break
 
-                    #the trait's position is on the right of the last genotype
-                    if i==len(self.qtlresults) and Mb>=qtlresult['Mb']:
+                    # the trait's position is on the right of the last genotype
+                    if i == len(self.qtlresults) and Mb >= qtlresult['Mb']:
                         locPixel = -1
             else:
                 locPixel = xLeftOffset
                 for i, _chr in enumerate(self.ChrList):
-                    if i < (len(self.ChrList)-1):
+                    if i < (len(self.ChrList) - 1):
                         if _chr != Chr:
-                            locPixel += (self.ChrLengthDistList[i] + self.GraphInterval)*plotXScale
+                            locPixel += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
                         else:
-                            locPixel += (Mb*(_chr[-1].cM-_chr[0].cM)/self.ChrLengthCMList[i])*plotXScale
+                            locPixel += (Mb * (_chr[-1].cM - _chr[0].cM) / self.ChrLengthCMList[i]) * plotXScale
                             break
         if locPixel >= 0 and self.plotScale == 'physic':
-            traitPixel = ((locPixel, yZero), (locPixel-7, yZero+14), (locPixel+7, yZero+14))
+            traitPixel = ((locPixel, yZero), (locPixel - 7, yZero + 14), (locPixel + 7, yZero + 14))
             draw_open_polygon(canvas, xy=traitPixel, outline=BLACK,
                               fill=self.TRANSCRIPT_LOCATION_COLOR)
 
-    def drawSNPTrackNew(self, canvas, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawSNPTrackNew(self, canvas, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.diffCol:
             return
@@ -963,36 +963,36 @@ class DisplayMappingResults:
         #chrName = self.genotype[0].name
         chrName = self.ChrList[self.selectedChr][0]
 
-        stepMb = (endMb-startMb)/plotWidth
+        stepMb = (endMb - startMb) / plotWidth
         strainId1, strainId2 = self.diffCol
         SNPCounts = []
 
-        while startMb<endMb:
+        while startMb < endMb:
             snp_count = g.db.execute("""
                     select
                             count(*) from BXDSnpPosition
                     where
                             Chr = '%s' AND Mb >= %2.6f AND Mb < %2.6f AND
                             StrainId1 = %d AND StrainId2 = %d
-                    """ % (chrName, startMb, startMb+stepMb, strainId1, strainId2)).fetchone()[0]
+                    """ % (chrName, startMb, startMb + stepMb, strainId1, strainId2)).fetchone()[0]
             SNPCounts.append(snp_count)
             startMb += stepMb
 
         if (len(SNPCounts) > 0):
             maxCount = max(SNPCounts)
-            if maxCount>0:
+            if maxCount > 0:
                 for i in range(xLeftOffset, xLeftOffset + plotWidth):
-                    snpDensity = float(SNPCounts[i-xLeftOffset]*SNP_HEIGHT_MODIFIER/maxCount)
+                    snpDensity = float(SNPCounts[i - xLeftOffset] * SNP_HEIGHT_MODIFIER / maxCount)
                     im_drawer.line(
-                        xy=((i, drawSNPLocationY+(snpDensity)*zoom),
-                           (i, drawSNPLocationY-(snpDensity)*zoom)),
+                        xy=((i, drawSNPLocationY + (snpDensity) * zoom),
+                           (i, drawSNPLocationY - (snpDensity) * zoom)),
                         fill=self.SNP_COLOR, width=1)
 
-    def drawMultiTraitName(self, fd, canvas, gifmap, showLocusForm, offset= (40, 120, 80, 10), zoom = 1):
+    def drawMultiTraitName(self, fd, canvas, gifmap, showLocusForm, offset=(40, 120, 80, 10), zoom=1):
         nameWidths = []
         yPaddingTop = 10
-        colorFont=ImageFont.truetype(font=TREBUC_FILE, size=12)
-        if len(self.qtlresults) >20 and self.selectedChr > -1:
+        colorFont = ImageFont.truetype(font=TREBUC_FILE, size=12)
+        if len(self.qtlresults) > 20 and self.selectedChr > -1:
             rightShift = 20
             rightShiftStep = 60
             rectWidth = 10
@@ -1004,7 +1004,7 @@ class DisplayMappingResults:
         for k, thisTrait in enumerate(self.traitList):
             thisLRSColor = self.colorCollection[k]
             kstep = k % 4
-            if k!=0 and kstep==0:
+            if k != 0 and kstep == 0:
                 if nameWidths:
                     rightShiftStep = max(nameWidths[-4:]) + rectWidth + 20
                 rightShift += rightShiftStep
@@ -1014,19 +1014,19 @@ class DisplayMappingResults:
             nameWidths.append(nameWidth)
 
             im_drawer.rectangle(
-                xy=((rightShift, yPaddingTop+kstep*15),
-                    (rectWidth+rightShift, yPaddingTop+10+kstep*15)),
+                xy=((rightShift, yPaddingTop + kstep * 15),
+                    (rectWidth + rightShift, yPaddingTop + 10+kstep*15)),
                 fill=thisLRSColor, outline=BLACK)
             im_drawer.text(
-                text=name, xy=(rectWidth+2+rightShift, yPaddingTop+10+kstep*15),
+                text=name, xy=(rectWidth + 2 + rightShift, yPaddingTop + 10 + kstep * 15),
                 font=colorFont, fill=BLACK)
             if thisTrait.db:
-                COORDS = "%d,%d,%d,%d" %(rectWidth+2+rightShift, yPaddingTop+kstep*15, rectWidth+2+rightShift+nameWidth, yPaddingTop+10+kstep*15,)
-                HREF= "javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm, thisTrait.db.name, thisTrait.name)
+                COORDS = "%d,%d,%d,%d" % (rectWidth + 2 + rightShift, yPaddingTop + kstep * 15, rectWidth + 2 + rightShift + nameWidth, yPaddingTop + 10 + kstep * 15,)
+                HREF = "javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm, thisTrait.db.name, thisTrait.name)
                 Areas = HtmlGenWrapper.create_area_tag(shape='rect', coords=COORDS, href=HREF)
-                gifmap.append(Areas) ### TODO
+                gifmap.append(Areas)  # TODO
 
-    def drawLegendPanel(self, canvas, offset= (40, 120, 80, 10), zoom = 1):
+    def drawLegendPanel(self, canvas, offset=(40, 120, 80, 10), zoom=1):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -1037,80 +1037,80 @@ class DisplayMappingResults:
         if zoom == 2:
             fontZoom = 1.5
 
-        labelFont=ImageFont.truetype(font=TREBUC_FILE, size=12*fontZoom)
+        labelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
         startPosY = 15
-        stepPosY = 12*fontZoom
+        stepPosY = 12 * fontZoom
 
         startPosX = canvas.size[0] - xRightOffset - 415
         if hasattr(self.traitList[0], 'chr') and hasattr(self.traitList[0], 'mb'):
             startPosY = 15
             nCol = 2
-            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12*fontZoom)
+            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
 
             leftOffset = canvas.size[0] - xRightOffset - 190
             draw_open_polygon(
                 canvas,
                 xy=(
-                    (leftOffset + 6, startPosY-7),
-                    (leftOffset - 1, startPosY+7),
-                    (leftOffset + 13, startPosY+7)),
+                    (leftOffset + 6, startPosY - 7),
+                    (leftOffset - 1, startPosY + 7),
+                    (leftOffset + 13, startPosY + 7)),
                 outline=BLACK, fill=self.TRANSCRIPT_LOCATION_COLOR
             )
             TEXT_Y_DISPLACEMENT = -8
             im_drawer.text(
                 text="Sequence Site",
-                xy=(leftOffset + 20, startPosY+TEXT_Y_DISPLACEMENT), font=smallLabelFont,
+                xy=(leftOffset + 20, startPosY + TEXT_Y_DISPLACEMENT), font=smallLabelFont,
                 fill=self.TOP_RIGHT_INFO_COLOR)
 
         if self.manhattan_plot != True:
             im_drawer.line(
-                xy=((startPosX, startPosY), (startPosX+32, startPosY)),
+                xy=((startPosX, startPosY), (startPosX + 32, startPosY)),
                 fill=self.LRS_COLOR, width=2)
             im_drawer.text(
-                text=self.LRS_LOD, xy=(startPosX+40, startPosY+TEXT_Y_DISPLACEMENT),
+                text=self.LRS_LOD, xy=(startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
                 font=labelFont, fill=BLACK)
             startPosY += stepPosY
 
         if self.additiveChecked:
             im_drawer.line(
-                xy=((startPosX, startPosY), (startPosX+17, startPosY)),
+                xy=((startPosX, startPosY), (startPosX + 17, startPosY)),
                 fill=self.ADDITIVE_COLOR_POSITIVE, width=2)
             im_drawer.line(
-                xy=((startPosX+18, startPosY), (startPosX+32, startPosY)),
+                xy=((startPosX + 18, startPosY), (startPosX + 32, startPosY)),
                 fill=self.ADDITIVE_COLOR_NEGATIVE, width=2)
             im_drawer.text(
-                text='Additive Effect', xy=(startPosX+40, startPosY+TEXT_Y_DISPLACEMENT),
+                text='Additive Effect', xy=(startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
                 font=labelFont, fill=BLACK)
             startPosY += stepPosY
 
         if self.genotype.type == 'intercross' and self.dominanceChecked:
             im_drawer.line(
-                xy=((startPosX, startPosY), (startPosX+17, startPosY)),
+                xy=((startPosX, startPosY), (startPosX + 17, startPosY)),
                 fill=self.DOMINANCE_COLOR_POSITIVE, width=4)
             im_drawer.line(
-                xy=((startPosX+18, startPosY), (startPosX+35, startPosY)),
+                xy=((startPosX + 18, startPosY), (startPosX + 35, startPosY)),
                 fill=self.DOMINANCE_COLOR_NEGATIVE, width=4)
             im_drawer.text(
-                text='Dominance Effect', xy=(startPosX+42, startPosY+5),
+                text='Dominance Effect', xy=(startPosX + 42, startPosY + 5),
                 font=labelFont, fill=BLACK)
             startPosY += stepPosY
 
         if self.haplotypeAnalystChecked:
             im_drawer.line(
-                xy=((startPosX-34, startPosY), (startPosX-17, startPosY)),
+                xy=((startPosX - 34, startPosY), (startPosX - 17, startPosY)),
                 fill=self.HAPLOTYPE_POSITIVE, width=4)
             im_drawer.line(
-                xy=((startPosX-17, startPosY), (startPosX, startPosY)),
+                xy=((startPosX - 17, startPosY), (startPosX, startPosY)),
                 fill=self.HAPLOTYPE_NEGATIVE, width=4)
             im_drawer.line(
-                xy=((startPosX, startPosY), (startPosX+17, startPosY)),
+                xy=((startPosX, startPosY), (startPosX + 17, startPosY)),
                 fill=self.HAPLOTYPE_HETEROZYGOUS, width=4)
             im_drawer.line(
-                xy=((startPosX+17, startPosY), (startPosX+34, startPosY)),
+                xy=((startPosX + 17, startPosY), (startPosX + 34, startPosY)),
                 fill=self.HAPLOTYPE_RECOMBINATION, width=4)
             im_drawer.text(
                 text='Haplotypes (Pat, Mat, Het, Unk)',
-                xy=(startPosX+41, startPosY+TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
+                xy=(startPosX + 41, startPosY + TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
             startPosY += stepPosY
 
         if self.permChecked and self.nperm > 0:
@@ -1118,20 +1118,20 @@ class DisplayMappingResults:
             if self.multipleInterval and not self.bootChecked:
                 thisStartX = canvas.size[0] - xRightOffset - 205
             im_drawer.line(
-                xy=((thisStartX, startPosY), ( startPosX + 32, startPosY)),
+                xy=((thisStartX, startPosY), (startPosX + 32, startPosY)),
                 fill=self.SIGNIFICANT_COLOR, width=self.SIGNIFICANT_WIDTH)
             im_drawer.line(
-                xy=((thisStartX, startPosY + stepPosY), ( startPosX + 32, startPosY + stepPosY)),
+                xy=((thisStartX, startPosY + stepPosY), (startPosX + 32, startPosY + stepPosY)),
                 fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH)
             im_drawer.text(
                 text='Significant %s = %2.2f' % (self.LRS_LOD, self.significant),
-                xy=(thisStartX+40, startPosY+TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
+                xy=(thisStartX + 40, startPosY + TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
             im_drawer.text(
                 text='Suggestive %s = %2.2f' % (self.LRS_LOD, self.suggestive),
-                xy=(thisStartX+40, startPosY + TEXT_Y_DISPLACEMENT +stepPosY), font=labelFont,
+                xy=(thisStartX + 40, startPosY + TEXT_Y_DISPLACEMENT + stepPosY), font=labelFont,
                 fill=BLACK)
 
-        labelFont = ImageFont.truetype(font=VERDANA_FILE, size=12*fontZoom)
+        labelFont = ImageFont.truetype(font=VERDANA_FILE, size=12 * fontZoom)
         labelColor = BLACK
 
         if self.dataset.type == "Publish" or self.dataset.type == "Geno":
@@ -1195,17 +1195,17 @@ class DisplayMappingResults:
                 identification += "Trait: %s" % (self.this_trait.name)
             identification += " with %s samples" % (self.n_samples)
 
-            d = 4+ max(
+            d = 4 + max(
                 im_drawer.textsize(identification, font=labelFont)[0],
                 im_drawer.textsize(string1, font=labelFont)[0],
                 im_drawer.textsize(string2, font=labelFont)[0])
             im_drawer.text(
                 text=identification,
-                xy=(xLeftOffset, y_constant*fontZoom), font=labelFont,
+                xy=(xLeftOffset, y_constant * fontZoom), font=labelFont,
                 fill=labelColor)
             y_constant += 15
         else:
-            d = 4+ max(
+            d = 4 + max(
                 im_drawer.textsize(string1, font=labelFont)[0],
                 im_drawer.textsize(string2, font=labelFont)[0])
 
@@ -1223,28 +1223,28 @@ class DisplayMappingResults:
                 transform_text += "Invert +/-"
 
             im_drawer.text(
-                text=transform_text, xy=(xLeftOffset, y_constant*fontZoom),
+                text=transform_text, xy=(xLeftOffset, y_constant * fontZoom),
                 font=labelFont, fill=labelColor)
             y_constant += 15
         im_drawer.text(
-            text=string1, xy=(xLeftOffset, y_constant*fontZoom),
+            text=string1, xy=(xLeftOffset, y_constant * fontZoom),
             font=labelFont, fill=labelColor)
         y_constant += 15
         im_drawer.text(
-            text=string2, xy=(xLeftOffset, y_constant*fontZoom),
+            text=string2, xy=(xLeftOffset, y_constant * fontZoom),
             font=labelFont, fill=labelColor)
         y_constant += 15
         if string3 != '':
             im_drawer.text(
-                text=string3, xy=(xLeftOffset, y_constant*fontZoom),
+                text=string3, xy=(xLeftOffset, y_constant * fontZoom),
                 font=labelFont, fill=labelColor)
             y_constant += 15
             if string4 != '':
                 im_drawer.text(
-                    text=string4, xy=(xLeftOffset, y_constant*fontZoom),
+                    text=string4, xy=(xLeftOffset, y_constant * fontZoom),
                     font=labelFont, fill=labelColor)
 
-    def drawGeneBand(self, canvas, gifmap, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawGeneBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
             return
@@ -1264,9 +1264,9 @@ class DisplayMappingResults:
             if self.dataset.group.species == "mouse":
                 txStart = theGO["TxStart"]
                 txEnd = theGO["TxEnd"]
-                geneLength = (txEnd - txStart)*1000.0
-                tenPercentLength = geneLength*0.0001
-                SNPdensity = theGO["snpCount"]/geneLength
+                geneLength = (txEnd - txStart) * 1000.0
+                tenPercentLength = geneLength * 0.0001
+                SNPdensity = theGO["snpCount"] / geneLength
 
                 exonStarts = list(map(float, theGO['exonStarts'].split(",")[:-1]))
                 exonEnds = list(map(float, theGO['exonEnds'].split(",")[:-1]))
@@ -1277,23 +1277,23 @@ class DisplayMappingResults:
                 strand = theGO["Strand"]
                 exonCount = theGO["exonCount"]
 
-                geneStartPix = xLeftOffset + plotXScale*(float(txStart) - startMb)
-                geneEndPix = xLeftOffset + plotXScale*(float(txEnd) - startMb) #at least one pixel
+                geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb)
+                geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  # at least one pixel
 
                 if (geneEndPix < xLeftOffset):
-                    return; # this gene is not on the screen
+                    return;  # this gene is not on the screen
                 elif (geneEndPix > xLeftOffset + plotWidth):
-                    geneEndPix = xLeftOffset + plotWidth; # clip the last in-range gene
+                    geneEndPix = xLeftOffset + plotWidth;  # clip the last in-range gene
                 if (geneStartPix > xLeftOffset + plotWidth):
-                    return; # we are outside the valid on-screen range, so stop drawing genes
+                    return;  # we are outside the valid on-screen range, so stop drawing genes
                 elif (geneStartPix < xLeftOffset):
-                    geneStartPix = xLeftOffset; # clip the first in-range gene
+                    geneStartPix = xLeftOffset;  # clip the first in-range gene
 
-                #color the gene based on SNP density
-                #found earlier, needs to be recomputed as snps are added
-                #always apply colors now, even if SNP Track not checked - Zach 11/24/2010
+                # color the gene based on SNP density
+                # found earlier, needs to be recomputed as snps are added
+                # always apply colors now, even if SNP Track not checked - Zach 11/24/2010
 
-                densities=[1.0000000000000001e-05, 0.094094033555233408, 0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
+                densities = [1.0000000000000001e-05, 0.094094033555233408, 0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
                 if SNPdensity < densities[0]:
                     myColor = BLACK
                 elif SNPdensity < densities[1]:
@@ -1310,11 +1310,11 @@ class DisplayMappingResults:
                     myColor = DARKRED
 
                 outlineColor = myColor
-                fillColor    = myColor
+                fillColor = myColor
 
                 TITLE = "Gene: %s (%s)\nFrom %2.3f to %2.3f Mb (%s)\nNum. exons: %d." % (geneSymbol, accession, float(txStart), float(txEnd), strand, exonCount)
                 # NL: 06-02-2011 Rob required to change this link for gene related
-                HREF=geneNCBILink %geneSymbol
+                HREF = geneNCBILink % geneSymbol
 
             elif self.dataset.group.species == "rat":
                 exonStarts = []
@@ -1327,85 +1327,85 @@ class DisplayMappingResults:
                 strand = theGO["Strand"]
                 exonCount = 0
 
-                geneStartPix = xLeftOffset + plotXScale*(float(txStart) - startMb)
-                geneEndPix = xLeftOffset + plotXScale*(float(txEnd) - startMb) #at least one pixel
+                geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb)
+                geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  # at least one pixel
 
                 if (geneEndPix < xLeftOffset):
-                    return; # this gene is not on the screen
+                    return;  # this gene is not on the screen
                 elif (geneEndPix > xLeftOffset + plotWidth):
-                    geneEndPix = xLeftOffset + plotWidth; # clip the last in-range gene
+                    geneEndPix = xLeftOffset + plotWidth;  # clip the last in-range gene
                 if (geneStartPix > xLeftOffset + plotWidth):
-                    return; # we are outside the valid on-screen range, so stop drawing genes
+                    return;  # we are outside the valid on-screen range, so stop drawing genes
                 elif (geneStartPix < xLeftOffset):
-                    geneStartPix = xLeftOffset; # clip the first in-range gene
+                    geneStartPix = xLeftOffset;  # clip the first in-range gene
 
                 outlineColor = DARKBLUE
                 fillColor = DARKBLUE
                 TITLE = "Gene: %s\nFrom %2.3f to %2.3f Mb (%s)" % (geneSymbol, float(txStart), float(txEnd), strand)
                 # NL: 06-02-2011 Rob required to change this link for gene related
-                HREF=geneNCBILink %geneSymbol
+                HREF = geneNCBILink % geneSymbol
             else:
                 outlineColor = ORANGE
                 fillColor = ORANGE
                 TITLE = "Gene: %s" % geneSymbol
 
-            #Draw Genes
-            geneYLocation = yPaddingTop + (gIndex % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT*zoom
+            # Draw Genes
+            geneYLocation = yPaddingTop + (gIndex % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT * zoom
             if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-                geneYLocation += 4*self.BAND_HEIGHT + 4*self.BAND_SPACING
+                geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
             else:
-                geneYLocation += 3*self.BAND_HEIGHT + 3*self.BAND_SPACING
+                geneYLocation += 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING
 
-            #draw the detail view
+            # draw the detail view
             if self.endMb - self.startMb <= self.DRAW_DETAIL_MB and geneEndPix - geneStartPix > self.EACH_GENE_ARROW_SPACING * 3:
                 utrColor = ImageColor.getrgb("rgb(66%, 66%, 66%)")
                 arrowColor = ImageColor.getrgb("rgb(70%, 70%, 70%)")
 
-                #draw the line that runs the entire length of the gene
+                # draw the line that runs the entire length of the gene
                 im_drawer.line(
                     xy=(
-                        (geneStartPix, geneYLocation + self.EACH_GENE_HEIGHT/2*zoom),
-                        ( geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT/2*zoom)),
+                        (geneStartPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 * zoom),
+                        (geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 *zoom)),
                     fill=outlineColor, width=1)
 
-                #draw the arrows
+                # draw the arrows
                 if geneEndPix - geneStartPix < 1:
                     genePixRange = 1
                 else:
                     genePixRange = int(geneEndPix - geneStartPix)
                 for xCoord in range(0, genePixRange):
 
-                    if (xCoord % self.EACH_GENE_ARROW_SPACING == 0 and xCoord + self.EACH_GENE_ARROW_SPACING < geneEndPix-geneStartPix) or xCoord == 0:
+                    if (xCoord % self.EACH_GENE_ARROW_SPACING == 0 and xCoord + self.EACH_GENE_ARROW_SPACING < geneEndPix - geneStartPix) or xCoord == 0:
                         if strand == "+":
                             im_drawer.line(
                                 xy=((geneStartPix + xCoord, geneYLocation),
                                     (geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
-                                     geneYLocation +(self.EACH_GENE_HEIGHT / 2)*zoom)),
+                                     geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
                             im_drawer.line(
                                 xy=((geneStartPix + xCoord,
-                                     geneYLocation + self.EACH_GENE_HEIGHT*zoom),
-                                    (geneStartPix + xCoord+self.EACH_GENE_ARROW_WIDTH,
+                                     geneYLocation + self.EACH_GENE_HEIGHT * zoom),
+                                    (geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
                         else:
                             im_drawer.line(
                                 xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
                                      geneYLocation),
-                                    ( geneStartPix + xCoord,
-                                      geneYLocation +(self.EACH_GENE_HEIGHT / 2)*zoom)),
+                                    (geneStartPix + xCoord,
+                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
                             im_drawer.line(
                                 xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
-                                     geneYLocation + self.EACH_GENE_HEIGHT*zoom),
-                                    ( geneStartPix + xCoord,
-                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2)*zoom)),
+                                     geneYLocation + self.EACH_GENE_HEIGHT * zoom),
+                                    (geneStartPix + xCoord,
+                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
 
-                #draw the blocks for the exon regions
+                # draw the blocks for the exon regions
                 for i in range(0, len(exonStarts)):
-                    exonStartPix = (exonStarts[i]-startMb)*plotXScale + xLeftOffset
-                    exonEndPix = (exonEnds[i]-startMb)*plotXScale + xLeftOffset
+                    exonStartPix = (exonStarts[i] - startMb) * plotXScale + xLeftOffset
+                    exonEndPix = (exonEnds[i] - startMb) * plotXScale + xLeftOffset
                     if (exonStartPix < xLeftOffset):
                         exonStartPix = xLeftOffset
                     if (exonEndPix < xLeftOffset):
@@ -1416,13 +1416,13 @@ class DisplayMappingResults:
                         exonStartPix = xLeftOffset + plotWidth
                     im_drawer.rectangle(
                         xy=((exonStartPix, geneYLocation),
-                            (exonEndPix, (geneYLocation + self.EACH_GENE_HEIGHT*zoom))),
-                        outline = outlineColor, fill = fillColor)
+                            (exonEndPix, (geneYLocation + self.EACH_GENE_HEIGHT * zoom))),
+                        outline=outlineColor, fill=fillColor)
 
-                #draw gray blocks for 3' and 5' UTR blocks
+                # draw gray blocks for 3' and 5' UTR blocks
                 if cdsStart and cdsEnd:
-                    utrStartPix = (txStart-startMb)*plotXScale + xLeftOffset
-                    utrEndPix = (cdsStart-startMb)*plotXScale + xLeftOffset
+                    utrStartPix = (txStart - startMb) * plotXScale + xLeftOffset
+                    utrEndPix = (cdsStart - startMb) * plotXScale + xLeftOffset
                     if (utrStartPix < xLeftOffset):
                         utrStartPix = xLeftOffset
                     if (utrEndPix < xLeftOffset):
@@ -1439,13 +1439,13 @@ class DisplayMappingResults:
                             labelText = "5'"
                         im_drawer.text(
                             text=labelText,
-                            xy=(utrStartPix-9, geneYLocation+self.EACH_GENE_HEIGHT),
+                            xy=(utrStartPix - 9, geneYLocation + self.EACH_GENE_HEIGHT),
                             font=ImageFont.truetype(font=ARIAL_FILE, size=2))
 
-                    #the second UTR region
+                    # the second UTR region
 
-                    utrStartPix = (cdsEnd-startMb)*plotXScale + xLeftOffset
-                    utrEndPix = (txEnd-startMb)*plotXScale + xLeftOffset
+                    utrStartPix = (cdsEnd - startMb) * plotXScale + xLeftOffset
+                    utrEndPix = (txEnd - startMb) * plotXScale + xLeftOffset
                     if (utrStartPix < xLeftOffset):
                         utrStartPix = xLeftOffset
                     if (utrEndPix < xLeftOffset):
@@ -1462,17 +1462,17 @@ class DisplayMappingResults:
                             labelText = "3'"
                             im_drawer.text(
                                 text=labelText,
-                                xy=(utrEndPix+2, geneYLocation+self.EACH_GENE_HEIGHT),
+                                xy=(utrEndPix + 2, geneYLocation + self.EACH_GENE_HEIGHT),
                                 font=ImageFont.truetype(font=ARIAL_FILE, size=2))
 
-            #draw the genes as rectangles
+            # draw the genes as rectangles
             else:
                 im_drawer.rectangle(
                     xy=((geneStartPix, geneYLocation),
-                        (geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT*zoom))),
-                    outline= outlineColor, fill = fillColor)
+                        (geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT * zoom))),
+                    outline=outlineColor, fill=fillColor)
 
-            COORDS = "%d, %d, %d, %d" %(geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
+            COORDS = "%d, %d, %d, %d" % (geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
             # NL: 06-02-2011 Rob required to display NCBI info in a new window
             gifmap.append(
                 HtmlGenWrapper.create_area_tag(
@@ -1482,8 +1482,8 @@ class DisplayMappingResults:
                     title=TITLE,
                     target="_blank"))
 
-## BEGIN HaplotypeAnalyst
-    def drawHaplotypeBand(self, canvas, gifmap, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+# BEGIN HaplotypeAnalyst
+    def drawHaplotypeBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
             return
 
@@ -1496,7 +1496,7 @@ class DisplayMappingResults:
 
         samplelist = list(self.genotype.prgy)
 
-        smd=[]
+        smd = []
         for sample in self.sample_vals_dict.keys():
             if self.sample_vals_dict[sample] != "x" and sample in samplelist:
                 temp = GeneralObject(name=sample, value=float(self.sample_vals_dict[sample]))
@@ -1504,24 +1504,24 @@ class DisplayMappingResults:
             else:
                 continue
 
-        smd.sort(key = lambda A: A.value)
+        smd.sort(key=lambda A: A.value)
         smd.reverse()
 
         oldgeneEndPix = -1
-        #Initializing plotRight, error before
+        # Initializing plotRight, error before
         plotRight = xRightOffset
 
         im_drawer = ImageDraw.Draw(canvas)
 
-#### find out PlotRight
+# find out PlotRight
         for _chr in self.genotype:
             if _chr.name == self.ChrList[self.selectedChr][0]:
                 for i, _locus in enumerate(_chr):
                     txStart = _chr[i].Mb
-                    txEnd   = _chr[i].Mb
+                    txEnd = _chr[i].Mb
 
-                    geneStartPix = xLeftOffset + plotXScale*(float(txStart) - startMb)  - 0
-                    geneEndPix = xLeftOffset + plotXScale*(float(txEnd) - startMb) - 0
+                    geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb) - 0
+                    geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb) - 0
 
                     drawit = 1
                     if (geneStartPix < xLeftOffset):
@@ -1530,27 +1530,27 @@ class DisplayMappingResults:
                         drawit = 0;
 
                     if drawit == 1:
-                        if _chr[i].name != " - " :
+                        if _chr[i].name != " - ":
                             plotRight = geneEndPix + 4
 
-#### end find out PlotRight
+# end find out PlotRight
 
         firstGene = 1
         lastGene = 0
 
-        #Sets the length to the length of the strain list. Beforehand, "oldgeno = self.genotype[0][i].genotype"
-        #was the only place it was initialized, which worked as long as the very start (startMb = None/0) wasn't being mapped.
-        #Now there should always be some value set for "oldgeno" - Zach 12/14/2010
-        oldgeno = [None]*len(self.strainlist)
+        # Sets the length to the length of the strain list. Beforehand, "oldgeno = self.genotype[0][i].genotype"
+        # was the only place it was initialized, which worked as long as the very start (startMb = None/0) wasn't being mapped.
+        # Now there should always be some value set for "oldgeno" - Zach 12/14/2010
+        oldgeno = [None] * len(self.strainlist)
 
         for i, _chr in enumerate(self.genotype):
             if _chr.name == self.ChrList[self.selectedChr][0]:
                 for j, _locus in enumerate(_chr):
                     txStart = _chr[j].Mb
-                    txEnd   = _chr[j].Mb
+                    txEnd = _chr[j].Mb
 
-                    geneStartPix = xLeftOffset + plotXScale*(float(txStart) - startMb)  - 0
-                    geneEndPix   = xLeftOffset + plotXScale*(float(txEnd)   - startMb)  + 0
+                    geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb) - 0
+                    geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  + 0
 
                     if oldgeneEndPix >= xLeftOffset:
                         drawStart = oldgeneEndPix + 4
@@ -1582,36 +1582,36 @@ class DisplayMappingResults:
                     if drawit == 1:
                         myColor = DARKBLUE
                         outlineColor = myColor
-                        fillColor    = myColor
+                        fillColor = myColor
 
-                        maxind=0
+                        maxind = 0
 
-                        #Draw Genes
+                        # Draw Genes
 
-                        geneYLocation = yPaddingTop + self.NUM_GENE_ROWS * (self.EACH_GENE_HEIGHT)*zoom
+                        geneYLocation = yPaddingTop + self.NUM_GENE_ROWS * (self.EACH_GENE_HEIGHT) * zoom
                         if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-                            geneYLocation += 4*self.BAND_HEIGHT + 4*self.BAND_SPACING
+                            geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
                         else:
-                            geneYLocation += 3*self.BAND_HEIGHT + 3*self.BAND_SPACING
+                            geneYLocation += 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING
 
-                        if _chr[j].name != " - " :
+                        if _chr[j].name != " - ":
 
                             if (firstGene == 1) and (lastGene != 1):
                                 oldgeneEndPix = drawStart = xLeftOffset
                                 oldgeno = _chr[j].genotype
                                 continue
 
-                            for k, _geno in enumerate (_chr[j].genotype):
-                                plotbxd=0
+                            for k, _geno in enumerate(_chr[j].genotype):
+                                plotbxd = 0
                                 if samplelist[k] in [item.name for item in smd]:
-                                    plotbxd=1
+                                    plotbxd = 1
 
                                 if (plotbxd == 1):
                                     ind = 0
                                     if samplelist[k] in [item.name for item in smd]:
                                         ind = [item.name for item in smd].index(samplelist[k])
 
-                                    maxind=max(ind, maxind)
+                                    maxind = max(ind, maxind)
 
                                     # lines
                                     if (oldgeno[k] == -1 and _geno == -1):
@@ -1621,27 +1621,27 @@ class DisplayMappingResults:
                                     elif (oldgeno[k] == 0 and _geno == 0):
                                         mylineColor = self.HAPLOTYPE_HETEROZYGOUS
                                     else:
-                                        mylineColor = self.HAPLOTYPE_RECOMBINATION # XZ: Unknown
+                                        mylineColor = self.HAPLOTYPE_RECOMBINATION  # XZ: Unknown
 
                                     im_drawer.line(
                                         xy=((drawStart,
-                                             geneYLocation+7+2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
                                             (drawEnd,
-                                             geneYLocation+7+2*ind*self.EACH_GENE_HEIGHT*zoom)),
-                                        fill= mylineColor, width=zoom*(self.EACH_GENE_HEIGHT+2))
+                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
+                                        fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
-                                    fillColor=BLACK
-                                    outlineColor=BLACK
+                                    fillColor = BLACK
+                                    outlineColor = BLACK
                                     if lastGene == 0:
                                         im_drawer.rectangle(
                                             xy=((geneStartPix,
-                                                 geneYLocation+2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                                 geneYLocation + 2 * ind*self.EACH_GENE_HEIGHT*zoom),
                                                 (geneEndPix,
-                                                 geneYLocation+2*ind*self.EACH_GENE_HEIGHT+ 2*self.EACH_GENE_HEIGHT*zoom)),
+                                                 geneYLocation + 2 *ind*self.EACH_GENE_HEIGHT + 2*self.EACH_GENE_HEIGHT*zoom)),
                                             outline=outlineColor, fill=fillColor)
 
 
-                                    COORDS = "%d, %d, %d, %d" %(geneStartPix, geneYLocation+ind*self.EACH_GENE_HEIGHT, geneEndPix+1, (geneYLocation + ind*self.EACH_GENE_HEIGHT))
+                                    COORDS = "%d, %d, %d, %d" % (geneStartPix, geneYLocation + ind * self.EACH_GENE_HEIGHT, geneEndPix + 1, (geneYLocation + ind * self.EACH_GENE_HEIGHT))
                                     TITLE = "Strain: %s, marker (%s) \n Position  %2.3f Mb." % (samplelist[k], _chr[j].name, float(txStart))
                                     HREF = ''
                                     gifmap.append(
@@ -1658,10 +1658,10 @@ class DisplayMappingResults:
                                         mylineColor = self.HAPLOTYPE_RECOMBINATION
                                     im_drawer.line(
                                         xy=((plotRight,
-                                            geneYLocation+7+2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                            geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
                                             (drawEnd,
-                                            geneYLocation+7+2*ind*self.EACH_GENE_HEIGHT*zoom)),
-                                        fill= mylineColor, width=zoom*(self.EACH_GENE_HEIGHT+2))
+                                            geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
+                                        fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
 
                             if lastGene == 0:
@@ -1670,7 +1670,7 @@ class DisplayMappingResults:
                                     font=ImageFont.truetype(font=VERDANA_FILE,
                                                             size=12),
                                     xy=(geneStartPix,
-                                        geneYLocation+17+2*maxind*self.EACH_GENE_HEIGHT*zoom),
+                                        geneYLocation + 17 + 2*maxind*self.EACH_GENE_HEIGHT*zoom),
                                     fill=BLACK, angle=-90)
 
                             oldgeneEndPix = geneEndPix;
@@ -1683,9 +1683,9 @@ class DisplayMappingResults:
             if _chr.name == self.ChrList[self.selectedChr][0]:
                 for j, _geno in enumerate(_chr[1].genotype):
 
-                    plotbxd=0
+                    plotbxd = 0
                     if samplelist[j] in [item.name for item in smd]:
-                        plotbxd=1
+                        plotbxd = 1
 
                     if (plotbxd == 1):
                         ind = [item.name for item in smd].index(samplelist[j]) - 1
@@ -1695,19 +1695,19 @@ class DisplayMappingResults:
                         im_drawer.text(
                             text="%s" % (samplelist[j]),
                             xy=((xLeftOffset + plotWidth + 10),
-                                geneYLocation+11+2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
                             font=ImageFont.truetype(font=VERDANA_FILE, size=12),
                             fill=BLACK)
                         im_drawer.text(
                             text="%2.2f" % (expr),
                             xy=((xLeftOffset + plotWidth + 60),
-                                geneYLocation+11+2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
                             font=ImageFont.truetype(font=VERDANA_FILE, size=12),
                             fill=BLACK)
 
-## END HaplotypeAnalyst
+# END HaplotypeAnalyst
 
-    def drawClickBand(self, canvas, gifmap, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawClickBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1:
             return
@@ -1724,12 +1724,12 @@ class DisplayMappingResults:
         # but it makes the HTML huge, and takes forever to render the page in the first place)
         # Draw the bands that you can click on to go to UCSC / Ensembl
         MAX_CLICKABLE_REGION_DIVISIONS = 100
-        clickableRegionLabelFont=ImageFont.truetype(font=VERDANA_FILE, size=9)
-        pixelStep = max(5, int(float(plotWidth)/MAX_CLICKABLE_REGION_DIVISIONS))
+        clickableRegionLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=9)
+        pixelStep = max(5, int(float(plotWidth) / MAX_CLICKABLE_REGION_DIVISIONS))
         # pixelStep: every N pixels, we make a new clickable area for the user to go to that area of the genome.
 
-        numBasesCurrentlyOnScreen = self.kONE_MILLION*abs(startMb - endMb) # Number of bases on screen now
-        flankingWidthInBases = int ( min( (float(numBasesCurrentlyOnScreen) / 2.0), (5*self.kONE_MILLION) ) )
+        numBasesCurrentlyOnScreen = self.kONE_MILLION * abs(startMb - endMb)  # Number of bases on screen now
+        flankingWidthInBases = int (min((float(numBasesCurrentlyOnScreen) / 2.0), (5*self.kONE_MILLION)))
         webqtlZoomWidth = numBasesCurrentlyOnScreen / 16.0
         # Flanking width should be such that we either zoom in to a 10 million base region, or we show the clicked region at the same scale as we are currently seeing.
 
@@ -1739,22 +1739,22 @@ class DisplayMappingResults:
         paddingTop = yTopOffset
         if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
             phenogenPaddingTop = paddingTop + (self.BAND_HEIGHT + self.BAND_SPACING)
-            ucscPaddingTop = paddingTop + 2*(self.BAND_HEIGHT + self.BAND_SPACING)
-            ensemblPaddingTop = paddingTop + 3*(self.BAND_HEIGHT + self.BAND_SPACING)
+            ucscPaddingTop = paddingTop + 2 * (self.BAND_HEIGHT + self.BAND_SPACING)
+            ensemblPaddingTop = paddingTop + 3 * (self.BAND_HEIGHT + self.BAND_SPACING)
         else:
             ucscPaddingTop = paddingTop + (self.BAND_HEIGHT + self.BAND_SPACING)
-            ensemblPaddingTop = paddingTop + 2*(self.BAND_HEIGHT + self.BAND_SPACING)
+            ensemblPaddingTop = paddingTop + 2 * (self.BAND_HEIGHT + self.BAND_SPACING)
 
         if zoom == 1:
             for pixel in range(xLeftOffset, xLeftOffset + plotWidth, pixelStep):
 
-                calBase = self.kONE_MILLION*(startMb + (endMb-startMb)*(pixel-xLeftOffset-0.0)/plotWidth)
+                calBase = self.kONE_MILLION * (startMb + (endMb - startMb) * (pixel - xLeftOffset - 0.0) / plotWidth)
 
                 xBrowse1 = pixel
                 xBrowse2 = min(xLeftOffset + plotWidth, (pixel + pixelStep - 1))
 
-                WEBQTL_COORDS = "%d, %d, %d, %d" % (xBrowse1, paddingTop, xBrowse2, (paddingTop+self.BAND_HEIGHT))
-                WEBQTL_HREF = "javascript:rangeView('%s', %f, %f)" % (self.selectedChr - 1, max(0, (calBase-webqtlZoomWidth))/1000000.0, (calBase+webqtlZoomWidth)/1000000.0)
+                WEBQTL_COORDS = "%d, %d, %d, %d" % (xBrowse1, paddingTop, xBrowse2, (paddingTop + self.BAND_HEIGHT))
+                WEBQTL_HREF = "javascript:rangeView('%s', %f, %f)" % (self.selectedChr - 1, max(0, (calBase - webqtlZoomWidth)) / 1000000.0, (calBase + webqtlZoomWidth) / 1000000.0)
 
                 WEBQTL_TITLE = "Click to view this section of the genome in WebQTL"
                 gifmap.append(
@@ -1769,15 +1769,15 @@ class DisplayMappingResults:
                     outline=self.CLICKABLE_WEBQTL_REGION_COLOR,
                     fill=self.CLICKABLE_WEBQTL_REGION_COLOR)
                 im_drawer.line(
-                    xy=((xBrowse1, paddingTop), ( xBrowse1, (paddingTop + self.BAND_HEIGHT))),
+                    xy=((xBrowse1, paddingTop), (xBrowse1, (paddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_WEBQTL_REGION_OUTLINE_COLOR)
 
                 if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-                    PHENOGEN_COORDS = "%d, %d, %d, %d" % (xBrowse1, phenogenPaddingTop, xBrowse2, (phenogenPaddingTop+self.BAND_HEIGHT))
+                    PHENOGEN_COORDS = "%d, %d, %d, %d" % (xBrowse1, phenogenPaddingTop, xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))
                     if self.dataset.group.species == "mouse":
-                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases)
+                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                     else:
-                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases)
+                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                     PHENOGEN_TITLE = "Click to view this section of the genome in PhenoGen"
                     gifmap.append(
                         HtmlGenWrapper.create_area_tag(
@@ -1787,18 +1787,18 @@ class DisplayMappingResults:
                             title=PHENOGEN_TITLE))
                     im_drawer.rectangle(
                         xy=((xBrowse1, phenogenPaddingTop),
-                            (xBrowse2, (phenogenPaddingTop+self.BAND_HEIGHT))),
+                            (xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))),
                         outline=self.CLICKABLE_PHENOGEN_REGION_COLOR,
                         fill=self.CLICKABLE_PHENOGEN_REGION_COLOR)
                     im_drawer.line(
-                        xy=((xBrowse1, phenogenPaddingTop), ( xBrowse1, (phenogenPaddingTop+self.BAND_HEIGHT))),
+                        xy=((xBrowse1, phenogenPaddingTop), (xBrowse1, (phenogenPaddingTop + self.BAND_HEIGHT))),
                         fill=self.CLICKABLE_PHENOGEN_REGION_OUTLINE_COLOR)
 
-                UCSC_COORDS = "%d, %d, %d, %d" %(xBrowse1, ucscPaddingTop, xBrowse2, (ucscPaddingTop+self.BAND_HEIGHT))
+                UCSC_COORDS = "%d, %d, %d, %d" % (xBrowse1, ucscPaddingTop, xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))
                 if self.dataset.group.species == "mouse":
-                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d&hgt.customText=%s/snp/chr%s" % (self._ucscDb, self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases, webqtlConfig.PORTADDR, self.selectedChr)
+                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d&hgt.customText=%s/snp/chr%s" % (self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases, webqtlConfig.PORTADDR, self.selectedChr)
                 else:
-                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d" % (self._ucscDb, self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases)
+                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d" % (self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 UCSC_TITLE = "Click to view this section of the genome in the UCSC Genome Browser"
                 gifmap.append(
                     HtmlGenWrapper.create_area_tag(
@@ -1808,19 +1808,19 @@ class DisplayMappingResults:
                         title=UCSC_TITLE))
                 im_drawer.rectangle(
                     xy=((xBrowse1, ucscPaddingTop),
-                        (xBrowse2, (ucscPaddingTop+self.BAND_HEIGHT))),
+                        (xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))),
                     outline=self.CLICKABLE_UCSC_REGION_COLOR,
                     fill=self.CLICKABLE_UCSC_REGION_COLOR)
                 im_drawer.line(
                     xy=((xBrowse1, ucscPaddingTop),
-                        (xBrowse1, (ucscPaddingTop+self.BAND_HEIGHT))),
+                        (xBrowse1, (ucscPaddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_UCSC_REGION_OUTLINE_COLOR)
 
-                ENSEMBL_COORDS = "%d, %d, %d, %d" %(xBrowse1, ensemblPaddingTop, xBrowse2, (ensemblPaddingTop+self.BAND_HEIGHT))
+                ENSEMBL_COORDS = "%d, %d, %d, %d" % (xBrowse1, ensemblPaddingTop, xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))
                 if self.dataset.group.species == "mouse":
-                    ENSEMBL_HREF = "http://www.ensembl.org/Mus_musculus/contigview?highlight=&chr=%s&vc_start=%d&vc_end=%d&x=35&y=12" % (self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases)
+                    ENSEMBL_HREF = "http://www.ensembl.org/Mus_musculus/contigview?highlight=&chr=%s&vc_start=%d&vc_end=%d&x=35&y=12" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 else:
-                    ENSEMBL_HREF = "http://www.ensembl.org/Rattus_norvegicus/contigview?chr=%s&start=%d&end=%d" % (self.selectedChr, max(0, calBase-flankingWidthInBases), calBase+flankingWidthInBases)
+                    ENSEMBL_HREF = "http://www.ensembl.org/Rattus_norvegicus/contigview?chr=%s&start=%d&end=%d" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 ENSEMBL_TITLE = "Click to view this section of the genome in the Ensembl Genome Browser"
                 gifmap.append(HtmlGenWrapper.create_area_tag(
                     shape='rect',
@@ -1829,36 +1829,36 @@ class DisplayMappingResults:
                     title=ENSEMBL_TITLE))
                 im_drawer.rectangle(
                     xy=((xBrowse1, ensemblPaddingTop),
-                        (xBrowse2, (ensemblPaddingTop+self.BAND_HEIGHT))),
+                        (xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))),
                     outline=self.CLICKABLE_ENSEMBL_REGION_COLOR,
                     fill=self.CLICKABLE_ENSEMBL_REGION_COLOR)
                 im_drawer.line(
                     xy=((xBrowse1, ensemblPaddingTop),
-                        (xBrowse1, (ensemblPaddingTop+self.BAND_HEIGHT))),
+                        (xBrowse1, (ensemblPaddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_ENSEMBL_REGION_OUTLINE_COLOR)
             # end for
 
             im_drawer.text(
                 text="Click to view the corresponding section of the genome in an 8x expanded WebQTL map",
-                xy=((xLeftOffset + 10), paddingTop),# + self.BAND_HEIGHT/2),
+                xy=((xLeftOffset + 10), paddingTop),  # + self.BAND_HEIGHT/2),
                 font=clickableRegionLabelFont,
                 fill=self.CLICKABLE_WEBQTL_TEXT_COLOR)
             if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
                 im_drawer.text(
                     text="Click to view the corresponding section of the genome in PhenoGen",
-                    xy=((xLeftOffset + 10), phenogenPaddingTop),# + self.BAND_HEIGHT/2),
+                    xy=((xLeftOffset + 10), phenogenPaddingTop),  # + self.BAND_HEIGHT/2),
                     font=clickableRegionLabelFont, fill=self.CLICKABLE_PHENOGEN_TEXT_COLOR)
             im_drawer.text(
                 text="Click to view the corresponding section of the genome in the UCSC Genome Browser",
-                xy=((xLeftOffset + 10), ucscPaddingTop),# + self.BAND_HEIGHT/2),
+                xy=((xLeftOffset + 10), ucscPaddingTop),  # + self.BAND_HEIGHT/2),
                 font=clickableRegionLabelFont, fill=self.CLICKABLE_UCSC_TEXT_COLOR)
             im_drawer.text(
                 text="Click to view the corresponding section of the genome in the Ensembl Genome Browser",
-                xy=((xLeftOffset+10), ensemblPaddingTop),# + self.BAND_HEIGHT/2),
+                xy=((xLeftOffset + 10), ensemblPaddingTop),  # + self.BAND_HEIGHT/2),
                 font=clickableRegionLabelFont, fill=self.CLICKABLE_ENSEMBL_TEXT_COLOR)
 
-            #draw the gray text
-            chrFont = ImageFont.truetype(font=VERDANA_BOLD_FILE, size=26*zoom)
+            # draw the gray text
+            chrFont = ImageFont.truetype(font=VERDANA_BOLD_FILE, size=26 * zoom)
             chrX = xLeftOffset + plotWidth - 2 - im_drawer.textsize(
                 "Chr %s" % self.ChrList[self.selectedChr][0], font=chrFont)[0]
             im_drawer.text(
@@ -1866,17 +1866,17 @@ class DisplayMappingResults:
                 xy=(chrX, phenogenPaddingTop), font=chrFont, fill=GRAY)
             # end of drawBrowserClickableRegions
         else:
-            #draw the gray text
-            chrFont = ImageFont.truetype(font=VERDANA_FILE, size=26*zoom)
+            # draw the gray text
+            chrFont = ImageFont.truetype(font=VERDANA_FILE, size=26 * zoom)
             chrX = xLeftOffset + (plotWidth - im_drawer.textsize(
-                "Chr %s" % currentChromosome, font=chrFont)[0])/2
+                "Chr %s" % currentChromosome, font=chrFont)[0]) / 2
             im_drawer.text(
                 text="Chr %s" % currentChromosome, xy=(chrX, 32), font=chrFont,
                 fill=GRAY)
             # end of drawBrowserClickableRegions
         pass
 
-    def drawXAxis(self, canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawXAxis(self, canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -1886,33 +1886,33 @@ class DisplayMappingResults:
         if zoom == 2:
             fontZoom = 1.5
 
-        #Parameters
-        NUM_MINOR_TICKS = 5 # Number of minor ticks between major ticks
+        # Parameters
+        NUM_MINOR_TICKS = 5  # Number of minor ticks between major ticks
         X_MAJOR_TICK_THICKNESS = 3
         X_MINOR_TICK_THICKNESS = 1
-        X_AXIS_THICKNESS = 1*zoom
+        X_AXIS_THICKNESS = 1 * zoom
 
         # ======= Alex: Draw the X-axis labels (megabase location)
-        MBLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=15*zoom)
-        xMajorTickHeight = 10 * zoom # How high the tick extends below the axis
-        xMinorTickHeight = 5*zoom
+        MBLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=15 * zoom)
+        xMajorTickHeight = 10 * zoom  # How high the tick extends below the axis
+        xMinorTickHeight = 5 * zoom
         xAxisTickMarkColor = BLACK
         xAxisLabelColor = BLACK
-        fontHeight = 12*fontZoom # How tall the font that we're using is
+        fontHeight = 12 * fontZoom  # How tall the font that we're using is
         spacingFromLabelToAxis = 10
 
         if self.plotScale == 'physic':
-            strYLoc = yZero + MBLabelFont.font.height/2
-            ###Physical single chromosome view
+            strYLoc = yZero + MBLabelFont.font.height / 2
+            # Physical single chromosome view
             if self.selectedChr > -1:
                 XScale = Plot.detScale(startMb, endMb)
                 XStart, XEnd, XStep = XScale
                 if XStep < 8:
                     XStep *= 2
-                spacingAmtX = spacingAmt = (XEnd-XStart)/XStep
+                spacingAmtX = spacingAmt = (XEnd - XStart) / XStep
 
                 j = 0
-                while  abs(spacingAmtX -int(spacingAmtX)) >= spacingAmtX/100.0 and j < 6:
+                while abs(spacingAmtX - int(spacingAmtX)) >= spacingAmtX / 100.0 and j < 6:
                     j += 1
                     spacingAmtX *= 10
 
@@ -1921,13 +1921,13 @@ class DisplayMappingResults:
                 for counter, _Mb in enumerate(Plot.frange(XStart, XEnd, spacingAmt / NUM_MINOR_TICKS)):
                     if _Mb < startMb or _Mb > endMb:
                         continue
-                    Xc = xLeftOffset + plotXScale*(_Mb - startMb)
-                    if counter % NUM_MINOR_TICKS == 0: # Draw a MAJOR mark, not just a minor tick mark
+                    Xc = xLeftOffset + plotXScale * (_Mb - startMb)
+                    if counter % NUM_MINOR_TICKS == 0:  # Draw a MAJOR mark, not just a minor tick mark
                         im_drawer.line(xy=((Xc, yZero),
-                                           (Xc, yZero+xMajorTickHeight)),
+                                           (Xc, yZero + xMajorTickHeight)),
                                        fill=xAxisTickMarkColor,
-                                       width=X_MAJOR_TICK_THICKNESS) # Draw the MAJOR tick mark
-                        labelStr = str(formatStr % _Mb) # What Mbase location to put on the label
+                                       width=X_MAJOR_TICK_THICKNESS)  # Draw the MAJOR tick mark
+                        labelStr = str(formatStr % _Mb)  # What Mbase location to put on the label
                         strWidth, strHeight = im_drawer.textsize(labelStr, font=MBLabelFont)
                         drawStringXc = (Xc - (strWidth / 2.0))
                         im_drawer.text(xy=(drawStringXc, strYLoc),
@@ -1935,16 +1935,16 @@ class DisplayMappingResults:
                                        fill=xAxisLabelColor)
                     else:
                         im_drawer.line(xy=((Xc, yZero),
-                                          (Xc, yZero+xMinorTickHeight)),
+                                          (Xc, yZero + xMinorTickHeight)),
                                        fill=xAxisTickMarkColor,
-                                       width=X_MINOR_TICK_THICKNESS) # Draw the MINOR tick mark
+                                       width=X_MINOR_TICK_THICKNESS)  # Draw the MINOR tick mark
 
-            ###Physical genome wide view
+            # Physical genome wide view
             else:
                 distScale = 0
                 startPosX = xLeftOffset
                 for i, distLen in enumerate(self.ChrLengthDistList):
-                    if distScale == 0: #universal scale in whole genome mapping
+                    if distScale == 0:  # universal scale in whole genome mapping
                         if distLen > 75:
                             distScale = 25
                         elif distLen > 30:
@@ -1953,51 +1953,51 @@ class DisplayMappingResults:
                             distScale = 5
                     for j, tickdists in enumerate(range(distScale, int(ceil(distLen)), distScale)):
                         im_drawer.line(
-                            xy=((startPosX+tickdists*plotXScale, yZero),
-                                (startPosX+tickdists*plotXScale, yZero + 7)),
-                            fill=BLACK, width=1*zoom)
+                            xy=((startPosX + tickdists * plotXScale, yZero),
+                                (startPosX + tickdists * plotXScale, yZero + 7)),
+                            fill=BLACK, width=1 * zoom)
                         if j % 2 == 0:
                             draw_rotated_text(
                                 canvas, text=str(tickdists), font=MBLabelFont,
-                                xy=(startPosX+tickdists*plotXScale,
-                                    yZero+10*zoom), fill=BLACK, angle=270)
-                    startPosX +=  (self.ChrLengthDistList[i]+self.GraphInterval)*plotXScale
+                                xy=(startPosX + tickdists * plotXScale,
+                                    yZero + 10 * zoom), fill=BLACK, angle=270)
+                    startPosX += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
 
-            megabaseLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18*zoom*1.5))
+            megabaseLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
             im_drawer.text(
                 text="Megabases",
                 xy=(
-                    xLeftOffset+(plotWidth-im_drawer.textsize(
-                        "Megabases", font=megabaseLabelFont)[0])/2,
-                    strYLoc+MBLabelFont.font.height+10*(zoom%2)),
+                    xLeftOffset + (plotWidth - im_drawer.textsize(
+                        "Megabases", font=megabaseLabelFont)[0]) / 2,
+                    strYLoc + MBLabelFont.font.height + 10*(zoom%2)),
                 font=megabaseLabelFont, fill=BLACK)
             pass
         else:
-            strYLoc = yZero + spacingFromLabelToAxis + MBLabelFont.font.height/2
+            strYLoc = yZero + spacingFromLabelToAxis + MBLabelFont.font.height / 2
             ChrAInfo = []
             preLpos = -1
             distinctCount = 0.0
 
-            if self.selectedChr == -1: #ZS: If viewing full genome/all chromosomes
+            if self.selectedChr == -1:  # ZS: If viewing full genome/all chromosomes
                 for i, _chr in enumerate(self.genotype):
                     thisChr = []
                     Locus0CM = _chr[0].cM
                     nLoci = len(_chr)
-                    if  nLoci <= 8:
+                    if nLoci <= 8:
                         for _locus in _chr:
                             if _locus.name != ' - ':
                                 if _locus.cM != preLpos:
                                     distinctCount += 1
                                 preLpos = _locus.cM
-                                thisChr.append([_locus.name, _locus.cM-Locus0CM])
+                                thisChr.append([_locus.name, _locus.cM - Locus0CM])
                     else:
-                        for j in (0, nLoci/4, nLoci/2, nLoci*3/4, -1):
+                        for j in (0, nLoci / 4, nLoci / 2, nLoci*3/4, -1):
                             while _chr[j].name == ' - ':
                                 j += 1
                             if _chr[j].cM != preLpos:
                                 distinctCount += 1
                             preLpos = _chr[j].cM
-                            thisChr.append([_chr[j].name, _chr[j].cM-Locus0CM])
+                            thisChr.append([_chr[j].name, _chr[j].cM - Locus0CM])
                     ChrAInfo.append(thisChr)
             else:
                 for i, _chr in enumerate(self.genotype):
@@ -2009,10 +2009,10 @@ class DisplayMappingResults:
                                 if _locus.cM != preLpos:
                                     distinctCount += 1
                                 preLpos = _locus.cM
-                                thisChr.append([_locus.name, _locus.cM-Locus0CM])
+                                thisChr.append([_locus.name, _locus.cM - Locus0CM])
                         ChrAInfo.append(thisChr)
 
-            stepA =  (plotWidth+0.0)/distinctCount
+            stepA = (plotWidth + 0.0) / distinctCount
 
             LRectWidth = 10
             LRectHeight = 3
@@ -2037,28 +2037,28 @@ class DisplayMappingResults:
                         Zorder = 0
                     if differ:
                         im_drawer.line(
-                            xy=((startPosX+Lpos, yZero), (xLeftOffset+offsetA,\
-                        yZero+25)),
+                            xy=((startPosX + Lpos, yZero), (xLeftOffset + offsetA,\
+                        yZero + 25)),
                             fill=lineColor)
                         im_drawer.line(
-                            xy=((xLeftOffset+offsetA, yZero+25), (xLeftOffset+offsetA,\
-                        yZero+40+Zorder*(LRectWidth+3))),
+                            xy=((xLeftOffset + offsetA, yZero + 25), (xLeftOffset+offsetA,\
+                        yZero + 40 + Zorder*(LRectWidth+3))),
                             fill=lineColor)
                         rectColor = ORANGE
                     else:
                         im_drawer.line(
-                            xy=((xLeftOffset+offsetA, yZero+40+Zorder*(LRectWidth+3)-3), (\
-                        xLeftOffset+offsetA, yZero+40+Zorder*(LRectWidth+3))),
+                            xy=((xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3)-3), (\
+                        xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3))),
                             fill=lineColor)
                         rectColor = DEEPPINK
                     im_drawer.rectangle(
-                        xy=((xLeftOffset+offsetA, yZero+40+Zorder*(LRectWidth+3)),
-                            (xLeftOffset+offsetA-LRectHeight,
-                             yZero+40+Zorder*(LRectWidth+3)+LRectWidth)),
-                        outline=rectColor, fill=rectColor, width = 0)
-                    COORDS="%d,%d,%d,%d"%(xLeftOffset+offsetA-LRectHeight, yZero+40+Zorder*(LRectWidth+3),\
-                            xLeftOffset+offsetA,yZero+40+Zorder*(LRectWidth+3)+LRectWidth)
-                    HREF = "/show_trait?trait_id=%s&dataset=%s" % (Lname, self.dataset.group.name+"Geno")
+                        xy=((xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3)),
+                            (xLeftOffset + offsetA - LRectHeight,
+                             yZero + 40 + Zorder*(LRectWidth+3)+LRectWidth)),
+                        outline=rectColor, fill=rectColor, width=0)
+                    COORDS = "%d,%d,%d,%d" % (xLeftOffset+offsetA-LRectHeight, yZero+40+Zorder*(LRectWidth+3),\
+                            xLeftOffset + offsetA, yZero +40+Zorder*(LRectWidth+3)+LRectWidth)
+                    HREF = "/show_trait?trait_id=%s&dataset=%s" % (Lname, self.dataset.group.name + "Geno")
                     #HREF="javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm,fd.RISet+"Geno", Lname)
                     Areas = HtmlGenWrapper.create_area_tag(
                         shape='rect',
@@ -2067,26 +2067,26 @@ class DisplayMappingResults:
                         target="_blank",
                         title="Locus : {}".format(Lname))
                     gifmap.append(Areas)
-                ##piddle bug
+                # piddle bug
                 if j == 0:
                     im_drawer.line(
-                        xy=((startPosX, yZero), (startPosX, yZero+40)),
+                        xy=((startPosX, yZero), (startPosX, yZero + 40)),
                         fill=lineColor)
-                startPosX += (self.ChrLengthDistList[j]+self.GraphInterval)*plotXScale
+                startPosX += (self.ChrLengthDistList[j] + self.GraphInterval) * plotXScale
 
-            centimorganLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18*zoom*1.5))
+            centimorganLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
             im_drawer.text(
                 text="Centimorgans",
-                xy=(xLeftOffset+(plotWidth-im_drawer.textsize(
-                    "Centimorgans", font=centimorganLabelFont)[0])/2,
-                    strYLoc + MBLabelFont.font.height+ 10*(zoom%2)),
+                xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
+                    "Centimorgans", font=centimorganLabelFont)[0]) / 2,
+                    strYLoc + MBLabelFont.font.height + 10 * (zoom %2)),
                 font=centimorganLabelFont, fill=BLACK)
 
-        im_drawer.line(xy=((xLeftOffset, yZero), (xLeftOffset+plotWidth, yZero)),
-                       fill=BLACK, width=X_AXIS_THICKNESS) # Draw the X axis itself
+        im_drawer.line(xy=((xLeftOffset, yZero), (xLeftOffset + plotWidth, yZero)),
+                       fill=BLACK, width=X_AXIS_THICKNESS)  # Draw the X axis itself
 
 
-    def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset= (40, 120, 80, 10), zoom = 1, startMb = None, endMb = None):
+    def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -2095,16 +2095,16 @@ class DisplayMappingResults:
         if zoom == 2:
             fontZoom = 1.5
 
-        INTERCROSS = (self.genotype.type=="intercross")
+        INTERCROSS = (self.genotype.type == "intercross")
 
-        #draw the LRS scale
-        #We first determine whether or not we are using a sliding scale.
-        #If so, we need to compute the maximum LRS value to determine where the max y-value should be, and call this LRS_LOD_Max.
-        #LRSTop is then defined to be above the LRS_LOD_Max by enough to add one additional LRSScale increment.
-        #if we are using a set-scale, then we set LRSTop to be the user's value, and LRS_LOD_Max doesn't matter.
+        # draw the LRS scale
+        # We first determine whether or not we are using a sliding scale.
+        # If so, we need to compute the maximum LRS value to determine where the max y-value should be, and call this LRS_LOD_Max.
+        # LRSTop is then defined to be above the LRS_LOD_Max by enough to add one additional LRSScale increment.
+        # if we are using a set-scale, then we set LRSTop to be the user's value, and LRS_LOD_Max doesn't matter.
 
-        #ZS: This is a mess, but I don't know a better way to account for different mapping methods returning results in different formats + the option to change between LRS and LOD
-        if self.lrsMax <= 0:  #sliding scale
+        # ZS: This is a mess, but I don't know a better way to account for different mapping methods returning results in different formats + the option to change between LRS and LOD
+        if self.lrsMax <= 0:  # sliding scale
             if "lrs_value" in self.qtlresults[0]:
                 LRS_LOD_Max = max([result['lrs_value'] for result in self.qtlresults])
                 if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
@@ -2135,34 +2135,34 @@ class DisplayMappingResults:
             if self.permChecked and self.nperm > 0 and not self.multipleInterval:
                 LRS_LOD_Max = max(self.significant, LRS_LOD_Max)
 
-            #genotype trait will give infinite LRS
+            # genotype trait will give infinite LRS
             LRS_LOD_Max = min(LRS_LOD_Max, webqtlConfig.MAXLRS)
         else:
             LRS_LOD_Max = self.lrsMax
 
-        #ZS: Needed to pass to genome browser
+        # ZS: Needed to pass to genome browser
         js_data = json.loads(self.js_data)
         if self.LRS_LOD == "LRS":
-            js_data['max_score'] = LRS_LOD_Max/4.61
+            js_data['max_score'] = LRS_LOD_Max / 4.61
         else:
             js_data['max_score'] = LRS_LOD_Max
         self.js_data = json.dumps(js_data)
 
-        LRSScaleFont=ImageFont.truetype(font=VERDANA_FILE, size=16*zoom)
-        LRSLODFont=ImageFont.truetype(font=VERDANA_FILE, size=int(18*zoom*1.5))
+        LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
+        LRSLODFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
 
         yZero = yTopOffset + plotHeight
         # LRSHeightThresh = drawAreaHeight
         # AdditiveHeightThresh = drawAreaHeight/2
         # DominanceHeightThresh = drawAreaHeight/2
         if self.selectedChr == 1:
-            LRSHeightThresh = drawAreaHeight - yTopOffset + 30*(zoom - 1)
-            AdditiveHeightThresh = LRSHeightThresh/2
-            DominanceHeightThresh = LRSHeightThresh/2
+            LRSHeightThresh = drawAreaHeight - yTopOffset + 30 * (zoom - 1)
+            AdditiveHeightThresh = LRSHeightThresh / 2
+            DominanceHeightThresh = LRSHeightThresh / 2
         else:
             LRSHeightThresh = drawAreaHeight
-            AdditiveHeightThresh = drawAreaHeight/2
-            DominanceHeightThresh = drawAreaHeight/2
+            AdditiveHeightThresh = drawAreaHeight / 2
+            DominanceHeightThresh = drawAreaHeight / 2
         # LRSHeightThresh = (yZero - yTopOffset + 30*(zoom - 1))
         # AdditiveHeightThresh = LRSHeightThresh/2
         # DominanceHeightThresh = LRSHeightThresh/2
@@ -2178,7 +2178,7 @@ class DisplayMappingResults:
 
         LRSAxisList = Plot.frange(LRSScale, LRS_LOD_Max, LRSScale)
 
-        #ZS: Convert to int if all axis values are whole numbers
+        # ZS: Convert to int if all axis values are whole numbers
         all_int = True
         for item in LRSAxisList:
             if isinstance(item, int):
@@ -2192,9 +2192,9 @@ class DisplayMappingResults:
         # else:
         #     max_lrs_width = canvas.stringWidth("%2.1f" % LRS_LOD_Max, font=LRSScaleFont) + 30
 
-        #draw the "LRS" or "LOD" string to the left of the axis
-        LRSScaleFont=ImageFont.truetype(font=VERDANA_FILE, size=16*zoom)
-        LRSLODFont=ImageFont.truetype(font=VERDANA_FILE, size=int(18*zoom*1.5))
+        # draw the "LRS" or "LOD" string to the left of the axis
+        LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
+        LRSLODFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
         yZero = yTopOffset + plotHeight
 
         # TEXT_X_DISPLACEMENT = -20
@@ -2210,64 +2210,64 @@ class DisplayMappingResults:
         draw_rotated_text(
             canvas, text=self.LRS_LOD, font=LRSLODFont,
             xy=(xLeftOffset - im_drawer.textsize(
-                "999.99", font=LRSScaleFont)[0] - 15*(zoom-1) + TEXT_X_DISPLACEMENT,
-                yZero + TEXT_Y_DISPLACEMENT - 300*(zoom - 1)),
+                "999.99", font=LRSScaleFont)[0] - 15 * (zoom - 1) + TEXT_X_DISPLACEMENT,
+                yZero + TEXT_Y_DISPLACEMENT - 300 * (zoom - 1)),
             fill=BLACK, angle=90)
 
         for item in LRSAxisList:
             if LRS_LOD_Max == 0.0:
                 LRS_LOD_Max = 0.000001
-            yTopOffset + 30*(zoom - 1)
-            yLRS = yZero - (item/LRS_LOD_Max) * LRSHeightThresh
-            im_drawer.line(xy=((xLeftOffset, yLRS), (xLeftOffset-4, yLRS)),
-                           fill=self.LRS_COLOR, width=1*zoom)
+            yTopOffset + 30 * (zoom - 1)
+            yLRS = yZero - (item / LRS_LOD_Max) * LRSHeightThresh
+            im_drawer.line(xy=((xLeftOffset, yLRS), (xLeftOffset - 4, yLRS)),
+                           fill=self.LRS_COLOR, width=1 * zoom)
             if all_int:
                 scaleStr = "%d" % item
             else:
                 scaleStr = "%2.1f" % item
-            #Draw the LRS/LOD Y axis label
+            # Draw the LRS/LOD Y axis label
             TEXT_Y_DISPLACEMENT = -10
             im_drawer.text(
                 text=scaleStr,
-                xy=(xLeftOffset-4-im_drawer.textsize(scaleStr, font=LRSScaleFont)[0]-5,
-                    yLRS+TEXT_Y_DISPLACEMENT),
+                xy=(xLeftOffset - 4 - im_drawer.textsize(scaleStr, font=LRSScaleFont)[0]-5,
+                    yLRS + TEXT_Y_DISPLACEMENT),
                 font=LRSScaleFont, fill=self.LRS_COLOR)
 
         if self.permChecked and self.nperm > 0 and not self.multipleInterval:
-            significantY = yZero - self.significant*LRSHeightThresh/LRS_LOD_Max
-            suggestiveY = yZero - self.suggestive*LRSHeightThresh/LRS_LOD_Max
+            significantY = yZero - self.significant * LRSHeightThresh / LRS_LOD_Max
+            suggestiveY = yZero - self.suggestive * LRSHeightThresh / LRS_LOD_Max
             # significantY = yZero - self.significant*LRSHeightThresh/LRSAxisList[-1]
             # suggestiveY = yZero - self.suggestive*LRSHeightThresh/LRSAxisList[-1]
             startPosX = xLeftOffset
 
-            #"Significant" and "Suggestive" Drawing Routine
+            # "Significant" and "Suggestive" Drawing Routine
             # ======= Draw the thick lines for "Significant" and "Suggestive" =====  (crowell: I tried to make the SNPs draw over these lines, but piddle wouldn't have it...)
 
-            #ZS: I don't know if what I did here with this inner function is clever or overly complicated, but it's the only way I could think of to avoid duplicating the code inside this function
+            # ZS: I don't know if what I did here with this inner function is clever or overly complicated, but it's the only way I could think of to avoid duplicating the code inside this function
             def add_suggestive_significant_lines_and_legend(start_pos_x, chr_length_dist):
-                rightEdge = int(start_pos_x + chr_length_dist*plotXScale - self.SUGGESTIVE_WIDTH/1.5)
+                rightEdge = int(start_pos_x + chr_length_dist * plotXScale - self.SUGGESTIVE_WIDTH / 1.5)
                 im_drawer.line(
-                    xy=((start_pos_x+self.SUGGESTIVE_WIDTH/1.5, suggestiveY),
+                    xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, suggestiveY),
                         (rightEdge, suggestiveY)),
-                    fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH*zoom
-                    #,clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
+                    fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH * zoom
+                    # ,clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
                 )
                 im_drawer.line(
-                    xy=((start_pos_x+self.SUGGESTIVE_WIDTH/1.5, significantY),
+                    xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, significantY),
                        (rightEdge, significantY)),
                     fill=self.SIGNIFICANT_COLOR,
-                    width=self.SIGNIFICANT_WIDTH*zoom
-                    #, clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
+                    width=self.SIGNIFICANT_WIDTH * zoom
+                    # , clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
                 )
-                sugg_coords = "%d, %d, %d, %d" % (start_pos_x, suggestiveY-2, rightEdge + 2*zoom, suggestiveY+2)
-                sig_coords = "%d, %d, %d, %d" % (start_pos_x, significantY-2, rightEdge + 2*zoom, significantY+2)
+                sugg_coords = "%d, %d, %d, %d" % (start_pos_x, suggestiveY - 2, rightEdge + 2 * zoom, suggestiveY + 2)
+                sig_coords = "%d, %d, %d, %d" % (start_pos_x, significantY - 2, rightEdge + 2 * zoom, significantY + 2)
 
                 if self.LRS_LOD == 'LRS':
                     sugg_title = "Suggestive LRS = %0.2f" % self.suggestive
                     sig_title = "Significant LRS = %0.2f" % self.significant
                 else:
-                    sugg_title = "Suggestive LOD = %0.2f" % (self.suggestive/4.61)
-                    sig_title = "Significant LOD = %0.2f" % (self.significant/4.61)
+                    sugg_title = "Suggestive LOD = %0.2f" % (self.suggestive / 4.61)
+                    sig_title = "Significant LOD = %0.2f" % (self.significant / 4.61)
                 Areas1 = HtmlGenWrapper.create_area_tag(
                     shape='rect',
                     coords=sugg_coords,
@@ -2279,7 +2279,7 @@ class DisplayMappingResults:
                 gifmap.append(Areas1)
                 gifmap.append(Areas2)
 
-                start_pos_x +=  (chr_length_dist+self.GraphInterval)*plotXScale
+                start_pos_x += (chr_length_dist + self.GraphInterval) * plotXScale
                 return start_pos_x
 
             for i, _chr in enumerate(self.genotype):
@@ -2306,7 +2306,7 @@ class DisplayMappingResults:
         AdditiveCoordXY = []
         DominanceCoordXY = []
 
-        symbolFont = ImageFont.truetype(font=FNT_BS_FILE, size=5) #ZS: For Manhattan Plot
+        symbolFont = ImageFont.truetype(font=FNT_BS_FILE, size=5)  # ZS: For Manhattan Plot
 
         previous_chr = 1
         previous_chr_as_int = 0
@@ -2332,128 +2332,128 @@ class DisplayMappingResults:
                     minusColor = self.ADDITIVE_COLOR_NEGATIVE
                     for k, aPoint in enumerate(AdditiveCoordXY):
                         if k > 0:
-                            Xc0, Yc0 = AdditiveCoordXY[k-1]
+                            Xc0, Yc0 = AdditiveCoordXY[k - 1]
                             Xc, Yc = aPoint
-                            if (Yc0-yZero)*(Yc-yZero) < 0:
-                                if Xc == Xc0: #genotype , locus distance is 0
+                            if (Yc0 - yZero) * (Yc-yZero) < 0:
+                                if Xc == Xc0:  # genotype , locus distance is 0
                                     Xcm = Xc
                                 else:
-                                    Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
+                                    Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                                 if Yc0 < yZero:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xcm, yZero)),
                                         fill=plusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                     im_drawer.line(
-                                        xy=((Xcm, yZero), (Xc, yZero-(Yc-yZero))),
+                                        xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
                                         fill=minusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                 else:
                                     im_drawer.line(
-                                        xy=((Xc0, yZero-(Yc0-yZero)),
+                                        xy=((Xc0, yZero - (Yc0 - yZero)),
                                             (Xcm, yZero)),
                                         fill=minusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                     im_drawer.line(
                                         xy=((Xcm, yZero), (Xc, Yc)),
                                         fill=plusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
-                            elif (Yc0-yZero)*(Yc-yZero) > 0:
+                            elif (Yc0 - yZero) * (Yc-yZero) > 0:
                                 if Yc < yZero:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xc, Yc)),
                                         fill=plusColor,
                                         width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                 else:
                                     im_drawer.line(
-                                        xy=((Xc0, yZero - (Yc0-yZero)),
-                                            (Xc, yZero - (Yc-yZero))),
+                                        xy=((Xc0, yZero - (Yc0 - yZero)),
+                                            (Xc, yZero - (Yc - yZero))),
                                         fill=minusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                             else:
-                                minYc = min(Yc-yZero, Yc0-yZero)
+                                minYc = min(Yc - yZero, Yc0 - yZero)
                                 if minYc < 0:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xc, Yc)),
                                         fill=plusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                 else:
                                     im_drawer.line(
-                                        xy=((Xc0, yZero - (Yc0-yZero)),
-                                            (Xc, yZero - (Yc-yZero))),
+                                        xy=((Xc0, yZero - (Yc0 - yZero)),
+                                            (Xc, yZero - (Yc - yZero))),
                                         fill=minusColor, width=lineWidth
-                                        #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                        # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
 
                 LRSCoordXY = []
                 AdditiveCoordXY = []
                 previous_chr = qtlresult['chr']
                 previous_chr_as_int += 1
-                newStartPosX = (self.ChrLengthDistList[previous_chr_as_int - 1]+self.GraphInterval)*plotXScale
+                newStartPosX = (self.ChrLengthDistList[previous_chr_as_int - 1] + self.GraphInterval) * plotXScale
                 if newStartPosX != oldStartPosX:
                     startPosX += newStartPosX
                     oldStartPosX = newStartPosX
 
-            #ZS: This is because the chromosome value stored in qtlresult['chr'] can be (for example) either X or 20 depending upon the mapping method/scale used
+            # ZS: This is because the chromosome value stored in qtlresult['chr'] can be (for example) either X or 20 depending upon the mapping method/scale used
             this_chr = str(self.ChrList[self.selectedChr][0])
             if self.plotScale != "physic":
-                this_chr = str(self.ChrList[self.selectedChr][1]+1)
+                this_chr = str(self.ChrList[self.selectedChr][1] + 1)
 
             if self.selectedChr == -1 or str(qtlresult['chr']) == this_chr:
                 if self.plotScale != "physic" and self.mapping_method == "reaper" and not self.manhattan_plot:
-                    Xc = startPosX + (qtlresult['cM']-startMb)*plotXScale
+                    Xc = startPosX + (qtlresult['cM'] - startMb) * plotXScale
                     if hasattr(self.genotype, "filler"):
                         if self.genotype.filler:
                             if self.selectedChr != -1:
                                 start_cm = self.genotype[self.selectedChr - 1][0].cM
-                                Xc = startPosX + (qtlresult['Mb'] - start_cm)*plotXScale
+                                Xc = startPosX + (qtlresult['Mb'] - start_cm) * plotXScale
                             else:
                                 start_cm = self.genotype[previous_chr_as_int][0].cM
-                                Xc = startPosX + ((qtlresult['Mb']-start_cm-startMb)*plotXScale)*(((qtlresult['Mb']-start_cm-startMb)*plotXScale)/((qtlresult['Mb']-start_cm-startMb+self.GraphInterval)*plotXScale))
+                                Xc = startPosX + ((qtlresult['Mb'] - start_cm - startMb) * plotXScale) * (((qtlresult['Mb'] - start_cm - startMb) * plotXScale) / ((qtlresult['Mb'] - start_cm - startMb + self.GraphInterval) * plotXScale))
                 else:
-                    Xc = startPosX + (qtlresult['Mb']-startMb)*plotXScale
+                    Xc = startPosX + (qtlresult['Mb'] - startMb) * plotXScale
 
                 # updated by NL 06-18-2011:
                 # fix the over limit LRS graph issue since genotype trait may give infinite LRS;
                 # for any lrs is over than 460(LRS max in this system), it will be reset to 460
 
-                yLRS = yZero - (item/LRS_LOD_Max) * LRSHeightThresh
+                yLRS = yZero - (item / LRS_LOD_Max) * LRSHeightThresh
 
 
                 if 'lrs_value' in qtlresult:
                     if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
-                        if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value']=='inf':
+                        if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
-                            Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/(LRS_LOD_Max*self.LODFACTOR)
+                            Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / (LRS_LOD_Max * self.LODFACTOR)
                         else:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
-                            Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/(LRS_LOD_Max*self.LODFACTOR)
+                            Yc = yZero - qtlresult['lrs_value'] * LRSHeightThresh / (LRS_LOD_Max * self.LODFACTOR)
                     else:
-                        if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value']=='inf':
+                        if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRS_LOD_Max
+                            Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / LRS_LOD_Max
                         else:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/LRS_LOD_Max
+                            Yc = yZero - qtlresult['lrs_value'] * LRSHeightThresh / LRS_LOD_Max
                 else:
-                    if qtlresult['lod_score'] > 100 or qtlresult['lod_score']=='inf':
+                    if qtlresult['lod_score'] > 100 or qtlresult['lod_score'] == 'inf':
                         #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
-                        Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRS_LOD_Max
+                        Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / LRS_LOD_Max
                     else:
                         if self.LRS_LOD == "LRS":
                             #Yc = yZero - qtlresult['lod_score']*self.LODFACTOR*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lod_score']*self.LODFACTOR*LRSHeightThresh/LRS_LOD_Max
+                            Yc = yZero - qtlresult['lod_score'] * self.LODFACTOR * LRSHeightThresh / LRS_LOD_Max
                         else:
                             #Yc = yZero - qtlresult['lod_score']*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lod_score']*LRSHeightThresh/LRS_LOD_Max
+                            Yc = yZero - qtlresult['lod_score'] * LRSHeightThresh / LRS_LOD_Max
 
                 if self.manhattan_plot == True:
                     if self.color_scheme == "single":
@@ -2469,8 +2469,8 @@ class DisplayMappingResults:
                     im_drawer.text(
                         text="5",
                         xy=(
-                            Xc-im_drawer.textsize("5", font=symbolFont)[0]/2+1,
-                            Yc-4),
+                            Xc - im_drawer.textsize("5", font=symbolFont)[0] / 2 + 1,
+                            Yc - 4),
                         fill=point_color, font=symbolFont)
                 else:
                     LRSCoordXY.append((Xc, Yc))
@@ -2478,7 +2478,7 @@ class DisplayMappingResults:
                 if not self.multipleInterval and self.additiveChecked:
                    if additiveMax == 0.0:
                        additiveMax = 0.000001
-                   Yc = yZero - qtlresult['additive']*AdditiveHeightThresh/additiveMax
+                   Yc = yZero - qtlresult['additive'] * AdditiveHeightThresh / additiveMax
                    AdditiveCoordXY.append((Xc, Yc))
 
                 m += 1
@@ -2497,64 +2497,64 @@ class DisplayMappingResults:
             minusColor = self.ADDITIVE_COLOR_NEGATIVE
             for k, aPoint in enumerate(AdditiveCoordXY):
                 if k > 0:
-                    Xc0, Yc0 = AdditiveCoordXY[k-1]
+                    Xc0, Yc0 = AdditiveCoordXY[k - 1]
                     Xc, Yc = aPoint
-                    if (Yc0-yZero)*(Yc-yZero) < 0:
-                        if Xc == Xc0: #genotype , locus distance is 0
+                    if (Yc0 - yZero) * (Yc-yZero) < 0:
+                        if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
-                            Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
+                            Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                             im_drawer.line(
-                                xy=((Xcm, yZero), (Xc, yZero-(Yc-yZero))),
+                                xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero - (Yc0-yZero)),
+                                xy=((Xc0, yZero - (Yc0 - yZero)),
                                     (Xcm, yZero)),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                             im_drawer.line(
                                 xy=((Xcm, yZero), (Xc, Yc)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
-                    elif (Yc0-yZero)*(Yc-yZero) > 0:
+                    elif (Yc0 - yZero) * (Yc-yZero) > 0:
                         if Yc < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)), fill=plusColor,
                                 width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero-(Yc0-yZero)),
-                                    (Xc, yZero-(Yc-yZero))),
+                                xy=((Xc0, yZero - (Yc0 - yZero)),
+                                    (Xc, yZero - (Yc - yZero))),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                     else:
-                        minYc = min(Yc-yZero, Yc0-yZero)
+                        minYc = min(Yc - yZero, Yc0 - yZero)
                         if minYc < 0:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero - (Yc0-yZero)),
-                                    (Xc, yZero - (Yc-yZero))),
+                                xy=((Xc0, yZero - (Yc0 - yZero)),
+                                    (Xc, yZero - (Yc - yZero))),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
 
         if not self.multipleInterval and INTERCROSS and self.dominanceChecked:
@@ -2562,114 +2562,114 @@ class DisplayMappingResults:
             minusColor = self.DOMINANCE_COLOR_NEGATIVE
             for k, aPoint in enumerate(DominanceCoordXY):
                 if k > 0:
-                    Xc0, Yc0 = DominanceCoordXY[k-1]
+                    Xc0, Yc0 = DominanceCoordXY[k - 1]
                     Xc, Yc = aPoint
-                    if (Yc0-yZero)*(Yc-yZero) < 0:
-                        if Xc == Xc0: #genotype , locus distance is 0
+                    if (Yc0 - yZero) * (Yc-yZero) < 0:
+                        if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
-                            Xcm = (yZero-Yc0)/((Yc-Yc0)/(Xc-Xc0)) +Xc0
+                            Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                             im_drawer.line(
-                                xy=((Xcm, yZero), (Xc, yZero-(Yc-yZero))),
+                                xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero - (Yc0-yZero)), (Xcm, yZero)),
+                                xy=((Xc0, yZero - (Yc0 - yZero)), (Xcm, yZero)),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                             im_drawer.line(
                                 xy=((Xcm, yZero), (Xc, Yc)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
-                    elif (Yc0-yZero)*(Yc-yZero) > 0:
+                    elif (Yc0 - yZero) * (Yc-yZero) > 0:
                         if Yc < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero - (Yc0-yZero)),
-                                    (Xc, yZero - (Yc-yZero))),
+                                xy=((Xc0, yZero - (Yc0 - yZero)),
+                                    (Xc, yZero - (Yc - yZero))),
                                 fill=minusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                     else:
-                        minYc = min(Yc-yZero, Yc0-yZero)
+                        minYc = min(Yc - yZero, Yc0 - yZero)
                         if minYc < 0:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)),
                                 fill=plusColor, width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
                         else:
                             im_drawer.line(
-                                xy=((Xc0, yZero - (Yc0-yZero)),
-                                    (Xc, yZero - (Yc-yZero))), fill=minusColor,
+                                xy=((Xc0, yZero - (Yc0 - yZero)),
+                                    (Xc, yZero - (Yc - yZero))), fill=minusColor,
                                 width=lineWidth
-                                #, clipX=(xLeftOffset, xLeftOffset + plotWidth)
+                                # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
 
 
-        ###draw additive scale
+        # draw additive scale
         if not self.multipleInterval and self.additiveChecked:
-            additiveScaleFont=ImageFont.truetype(font=VERDANA_FILE, size=16*zoom)
+            additiveScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
             additiveScale = Plot.detScaleOld(0, additiveMax)
-            additiveStep = (additiveScale[1]-additiveScale[0])/additiveScale[2]
+            additiveStep = (additiveScale[1] - additiveScale[0]) / additiveScale[2]
             additiveAxisList = Plot.frange(0, additiveScale[1], additiveStep)
-            addPlotScale = AdditiveHeightThresh/additiveMax
+            addPlotScale = AdditiveHeightThresh / additiveMax
             TEXT_Y_DISPLACEMENT = -8
 
             additiveAxisList.append(additiveScale[1])
             for item in additiveAxisList:
-                additiveY = yZero - item*addPlotScale
+                additiveY = yZero - item * addPlotScale
                 im_drawer.line(
                     xy=((xLeftOffset + plotWidth, additiveY),
-                        (xLeftOffset+4+ plotWidth, additiveY)),
-                    fill=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
+                        (xLeftOffset + 4 + plotWidth, additiveY)),
+                    fill=self.ADDITIVE_COLOR_POSITIVE, width=1 * zoom)
                 scaleStr = "%2.3f" % item
                 im_drawer.text(
                     text=scaleStr,
-                    xy=(xLeftOffset + plotWidth +6, additiveY+TEXT_Y_DISPLACEMENT),
+                    xy= (xLeftOffset + plotWidth + 6, additiveY + TEXT_Y_DISPLACEMENT),
                     font=additiveScaleFont, fill=self.ADDITIVE_COLOR_POSITIVE)
 
             im_drawer.line(
-                xy=((xLeftOffset+plotWidth, additiveY),
-                    (xLeftOffset+plotWidth, yZero)),
-                fill=self.ADDITIVE_COLOR_POSITIVE, width=1*zoom)
+                xy=((xLeftOffset + plotWidth, additiveY),
+                    (xLeftOffset + plotWidth, yZero)),
+                fill=self.ADDITIVE_COLOR_POSITIVE, width=1 * zoom)
 
         im_drawer.line(
-            xy=((xLeftOffset, yZero), (xLeftOffset, yTopOffset + 30*(zoom - 1))),
-            fill=self.LRS_COLOR, width=1*zoom)  #the blue line running up the y axis
+            xy=((xLeftOffset, yZero), (xLeftOffset, yTopOffset + 30 * (zoom - 1))),
+            fill=self.LRS_COLOR, width=1 * zoom)  # the blue line running up the y axis
 
 
-    def drawGraphBackground(self, canvas, gifmap, offset= (80, 120, 80, 50), zoom = 1, startMb = None, endMb = None):
-        ##conditions
-        ##multiple Chromosome view
-        ##single Chromosome Physical
-        ##single Chromosome Genetic
+    def drawGraphBackground(self, canvas, gifmap, offset=(80, 120, 80, 50), zoom=1, startMb= None, endMb = None):
+        # conditions
+        # multiple Chromosome view
+        # single Chromosome Physical
+        # single Chromosome Genetic
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
         plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
-        yBottom = yTopOffset+plotHeight
+        yBottom = yTopOffset + plotHeight
         fontZoom = zoom
         if zoom == 2:
             fontZoom = 1.5
             yTopOffset += 30
 
-        #calculate plot scale
+        # calculate plot scale
         if self.plotScale != 'physic':
             self.ChrLengthDistList = self.ChrLengthCMList
             drawRegionDistance = self.ChrLengthCMSum
@@ -2677,10 +2677,10 @@ class DisplayMappingResults:
             self.ChrLengthDistList = self.ChrLengthMbList
             drawRegionDistance = self.ChrLengthMbSum
 
-        if self.selectedChr > -1: #single chromosome view
-            spacingAmt = plotWidth/13.5
+        if self.selectedChr > -1:  # single chromosome view
+            spacingAmt = plotWidth / 13.5
             i = 0
-            for startPix in Plot.frange(xLeftOffset, xLeftOffset+plotWidth, spacingAmt):
+            for startPix in Plot.frange(xLeftOffset, xLeftOffset + plotWidth, spacingAmt):
                 if (i % 2 == 0):
                     theBackColor = self.GRAPH_BACK_DARK_COLOR
                 else:
@@ -2688,25 +2688,25 @@ class DisplayMappingResults:
                 i += 1
                 im_drawer.rectangle(
                     [(startPix, yTopOffset),
-                     (min(startPix+spacingAmt, xLeftOffset+plotWidth), yBottom)],
+                     (min(startPix + spacingAmt, xLeftOffset + plotWidth), yBottom)],
                     outline=theBackColor, fill=theBackColor)
 
             drawRegionDistance = self.ChrLengthDistList[self.ChrList[self.selectedChr][1]]
             self.ChrLengthDistList = [drawRegionDistance]
             if self.plotScale == 'physic':
-                plotXScale = plotWidth / (endMb-startMb)
+                plotXScale = plotWidth / (endMb - startMb)
             else:
                 plotXScale = plotWidth / drawRegionDistance
 
-        else:   #multiple chromosome view
-            plotXScale = plotWidth / ((len(self.genotype)-1)*self.GraphInterval + drawRegionDistance)
+        else:  # multiple chromosome view
+            plotXScale = plotWidth / ((len(self.genotype) - 1) * self.GraphInterval + drawRegionDistance)
 
             startPosX = xLeftOffset
             if fontZoom == 1.5:
                 chrFontZoom = 2
             else:
                 chrFontZoom = 1
-            chrLabelFont=ImageFont.truetype(font=VERDANA_FILE, size=24*chrFontZoom)
+            chrLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=24 * chrFontZoom)
 
             for i, _chr in enumerate(self.genotype):
                 if (i % 2 == 0):
@@ -2714,23 +2714,23 @@ class DisplayMappingResults:
                 else:
                     theBackColor = self.GRAPH_BACK_LIGHT_COLOR
 
-                #draw the shaded boxes and the sig/sug thick lines
+                # draw the shaded boxes and the sig/sug thick lines
                 im_drawer.rectangle(
                     ((startPosX, yTopOffset),
-                     (startPosX + self.ChrLengthDistList[i]*plotXScale, yBottom)),
+                     (startPosX + self.ChrLengthDistList[i] * plotXScale, yBottom)),
                     outline=GAINSBORO,
                     fill=theBackColor)
 
                 chrNameWidth, chrNameHeight = im_drawer.textsize(_chr.name, font=chrLabelFont)
-                chrStartPix = startPosX + (self.ChrLengthDistList[i]*plotXScale -chrNameWidth)/2
-                chrEndPix = startPosX + (self.ChrLengthDistList[i]*plotXScale +chrNameWidth)/2
+                chrStartPix = startPosX + (self.ChrLengthDistList[i] * plotXScale - chrNameWidth) / 2
+                chrEndPix = startPosX + (self.ChrLengthDistList[i] * plotXScale + chrNameWidth) / 2
 
                 TEXT_Y_DISPLACEMENT = 0
                 im_drawer.text(xy=(chrStartPix, yTopOffset + TEXT_Y_DISPLACEMENT),
                                text=_chr.name, font=chrLabelFont, fill=BLACK)
-                COORDS = "%d,%d,%d,%d" %(chrStartPix, yTopOffset, chrEndPix, yTopOffset +20)
+                COORDS = "%d,%d,%d,%d" % (chrStartPix, yTopOffset, chrEndPix, yTopOffset + 20)
 
-                #add by NL 09-03-2010
+                # add by NL 09-03-2010
                 HREF = "javascript:chrView(%d,%s);" % (i, self.ChrLengthMbList)
                 #HREF = "javascript:changeView(%d,%s);" % (i,self.ChrLengthMbList)
                 Areas = HtmlGenWrapper.create_area_tag(
@@ -2738,7 +2738,7 @@ class DisplayMappingResults:
                     coords=COORDS,
                     href=HREF)
                 gifmap.append(Areas)
-                startPosX +=  (self.ChrLengthDistList[i]+self.GraphInterval)*plotXScale
+                startPosX += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
 
         return plotXScale
 
@@ -2748,15 +2748,15 @@ class DisplayMappingResults:
         #########################################
         myCanvas = Image.new("RGBA", size=(500, 300))
         if 'lod_score' in self.qtlresults[0] and self.LRS_LOD == "LRS":
-            perm_output = [value*4.61 for value in self.perm_output]
+            perm_output = [value * 4.61 for value in self.perm_output]
         elif 'lod_score' not in self.qtlresults[0] and self.LRS_LOD == "LOD":
-            perm_output = [value/4.61 for value in self.perm_output]
+            perm_output = [value / 4.61 for value in self.perm_output]
         else:
             perm_output = self.perm_output
 
-        filename= webqtlUtil.genRandStr("Reg_")
+        filename = webqtlUtil.genRandStr("Reg_")
         Plot.plotBar(myCanvas, perm_output, XLabel=self.LRS_LOD, YLabel='Frequency', title=' Histogram of Permutation Test')
-        myCanvas.save("{}.gif".format(GENERATED_IMAGE_DIR+filename),
+        myCanvas.save("{}.gif".format(GENERATED_IMAGE_DIR + filename),
                       format='gif')
 
         return filename
@@ -2821,18 +2821,18 @@ class DisplayMappingResults:
 
                 tableIterationsCnt = tableIterationsCnt + 1
 
-                this_row = [] #container for the cells of each row
+                this_row = []  # container for the cells of each row
                 selectCheck = HtmlGenWrapper.create_input_tag(
                     type_="checkbox",
                     name="selectCheck",
                     value=theGO["GeneSymbol"],
                     Class="checkbox trait_checkbox")  # checkbox for each row
 
-                geneLength = (theGO["TxEnd"] - theGO["TxStart"])*1000.0
-                tenPercentLength = geneLength*0.0001
+                geneLength = (theGO["TxEnd"] - theGO["TxStart"]) * 1000.0
+                tenPercentLength = geneLength * 0.0001
                 txStart = theGO["TxStart"]
                 txEnd = theGO["TxEnd"]
-                theGO["snpDensity"] = theGO["snpCount"]/geneLength
+                theGO["snpDensity"] = theGO["snpCount"] / geneLength
                 if self.ALEX_DEBUG_BOOL_PRINT_GENE_LIST:
                     geneIdString = 'http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids=%s' % theGO["GeneID"]
 
@@ -2844,16 +2844,16 @@ class DisplayMappingResults:
                              f"end={theGO['TxEnd']}&"
                              f"geneName={theGO['GeneSymbol']}&"
                              f"s1={self.diffCol[0]}&s2=%d"),
-                            str(theGO["snpCount"]) # The text to display
+                            str(theGO["snpCount"])  # The text to display
                         )
                         snpString.set_blank_target()
                         snpString.set_attribute("class", "normalsize")
                     else:
                         snpString = 0
 
-                    mouseStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Mouse&db=mm9&position=chr" + theGO["Chromosome"] + "%3A" + str(int(theGO["TxStart"] * 1000000.0))  + "-" + str(int(theGO["TxEnd"]*1000000.0)) +"&pix=620&Submit=submit"
+                    mouseStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Mouse&db=mm9&position=chr" + theGO["Chromosome"] + "%3A" + str(int(theGO["TxStart"] * 1000000.0)) + "-" + str(int(theGO["TxEnd"] * 1000000.0)) + "&pix=620&Submit=submit"
 
-                    #the chromosomes for human 1 are 1qXX.XX
+                    # the chromosomes for human 1 are 1qXX.XX
                     if theGO['humanGene']:
                         if theGO['humanGene']["TxStart"] == '':
                             humanStartDisplay = ""
@@ -2863,20 +2863,20 @@ class DisplayMappingResults:
                         humanChr = theGO['humanGene']["Chromosome"]
                         humanTxStart = theGO['humanGene']["TxStart"]
 
-                        humanStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Human&db=hg17&position=chr%s:%d-%d" %  (humanChr, int(1000000*theGO['humanGene']["TxStart"]), int(1000000*theGO['humanGene']["TxEnd"]))
+                        humanStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Human&db=hg17&position=chr%s:%d-%d" % (humanChr, int(1000000 * theGO['humanGene']["TxStart"]), int(1000000 * theGO['humanGene']["TxEnd"]))
                     else:
                         humanStartString = humanChr = humanStartDisplay = "--"
 
                     geneDescription = theGO["GeneDescription"]
                     if len(geneDescription) > 70:
-                        geneDescription = geneDescription[:70]+"..."
+                        geneDescription = geneDescription[:70] + "..."
 
                     if theGO["snpDensity"] < 0.000001:
                         snpDensityStr = "0"
                     else:
                         snpDensityStr = "%0.6f" % theGO["snpDensity"]
 
-                    avgExpr = [] #theGO["avgExprVal"]
+                    avgExpr = []  # theGO["avgExprVal"]
                     if avgExpr in ([], None):
                         avgExpr = "--"
                     else:
@@ -2905,8 +2905,8 @@ class DisplayMappingResults:
                                     str(HtmlGenWrapper.create_link_tag(
                                         "javascript:rangeView('{}', {:f}, {:f})".format(
                                             str(chr_as_int),
-                                            txStart-tenPercentLength,
-                                            txEnd+tenPercentLength),
+                                            txStart - tenPercentLength,
+                                            txEnd + tenPercentLength),
                                         "{:.3f}".format(geneLength))),
                                     snpString,
                                     snpDensityStr,
@@ -2931,8 +2931,8 @@ class DisplayMappingResults:
                                     str(HtmlGenWrapper.create_link_tag(
                                         "javascript:rangeView('{}', {:f}, {:f})".format(
                                             str(chr_as_int),
-                                            txStart-tenPercentLength,
-                                            txEnd+tenPercentLength),
+                                            txStart - tenPercentLength,
+                                            txEnd + tenPercentLength),
                                         "{:.3f}".format(geneLength))),
                                     snpString,
                                     snpDensityStr,
@@ -2969,7 +2969,7 @@ class DisplayMappingResults:
                     chr_as_int = int(theGO["Chromosome"]) - 1
 
                 geneLength = (float(theGO["TxEnd"]) - float(theGO["TxStart"]))
-                geneLengthURL = "javascript:rangeView('%s', %f, %f)" % (theGO["Chromosome"], float(theGO["TxStart"])-(geneLength*0.1), float(theGO["TxEnd"])+(geneLength*0.1))
+                geneLengthURL = "javascript:rangeView('%s', %f, %f)" % (theGO["Chromosome"], float(theGO["TxStart"]) - (geneLength * 0.1), float(theGO["TxEnd"]) + (geneLength * 0.1))
 
                 avgExprVal = []
                 if avgExprVal != "" and avgExprVal:
@@ -2977,14 +2977,14 @@ class DisplayMappingResults:
                 else:
                     avgExprVal = ""
 
-                #Mouse Gene
+                # Mouse Gene
                 if theGO['mouseGene']:
                     mouseChr = theGO['mouseGene']["Chromosome"]
                     mouseTxStart = "%0.6f" % theGO['mouseGene']["TxStart"]
                 else:
                     mouseChr = mouseTxStart = ""
 
-                #the chromosomes for human 1 are 1qXX.XX
+                # the chromosomes for human 1 are 1qXX.XX
                 if theGO['humanGene']:
                     humanChr = theGO['humanGene']["Chromosome"]
                     humanTxStart = "%0.6f" % theGO['humanGene']["TxStart"]
@@ -2996,12 +2996,12 @@ class DisplayMappingResults:
                     geneDesc = ""
 
                 this_row = [selectCheck.__str__(),
-                            str(gIndex+1),
+                            str(gIndex + 1),
                             geneSymbolNCBI,
                             "%0.6f" % theGO["TxStart"],
                             str(HtmlGenWrapper.create_link_tag(
                                 geneLengthURL,
-                                "{:.3f}".format(geneLength*1000.0))),
+                                "{:.3f}".format(geneLength * 1000.0))),
                             avgExprVal,
                             mouseChr,
                             mouseTxStart,
@@ -3013,7 +3013,7 @@ class DisplayMappingResults:
 
         return gene_table_body
 
-    def getLiteratureCorrelation(cursor,geneId1=None,geneId2=None):
+    def getLiteratureCorrelation(cursor, geneId1=None, geneId2=None):
         if not geneId1 or not geneId2:
             return None
         if geneId1 == geneId2:
@@ -3025,9 +3025,9 @@ class DisplayMappingResults:
             query = 'SELECT Value FROM LCorrRamin3 WHERE GeneId1 = %s and GeneId2 = %s'
             for x, y in [(geneId1, geneId2), (geneId2, geneId1)]:
                 cursor.execute(query, (x, y))
-                lCorr =  cursor.fetchone()
+                lCorr = cursor.fetchone()
                 if lCorr:
                     lCorr = lCorr[0]
                     break
-        except: raise #lCorr = None
+        except: raise  # lCorr = None
         return lCorr
diff --git a/wqflask/wqflask/marker_regression/gemma_mapping.py b/wqflask/wqflask/marker_regression/gemma_mapping.py
index 06c9300a..68689104 100644
--- a/wqflask/wqflask/marker_regression/gemma_mapping.py
+++ b/wqflask/wqflask/marker_regression/gemma_mapping.py
@@ -149,7 +149,7 @@ def gen_covariates_file(this_dataset, covariates, samples):
         dataset_name = covariate.split(":")[1]
         if dataset_name == "Temp":
             temp_group = trait_name.split("_")[2]
-            dataset_ob = create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = temp_group)
+            dataset_ob = create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = temp_group)
         else:
             dataset_ob = create_dataset(covariate.split(":")[1])
         trait_ob = create_trait(dataset=dataset_ob,
diff --git a/wqflask/wqflask/marker_regression/plink_mapping.py b/wqflask/wqflask/marker_regression/plink_mapping.py
index 5d675c38..e6c78536 100644
--- a/wqflask/wqflask/marker_regression/plink_mapping.py
+++ b/wqflask/wqflask/marker_regression/plink_mapping.py
@@ -6,7 +6,7 @@ from utility import webqtlUtil
 from utility.tools import flat_files, PLINK_COMMAND
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 def run_plink(this_trait, dataset, species, vals, maf):
     plink_output_filename = webqtlUtil.genRandStr(f"{dataset.group.name}_{this_trait.name}_")
@@ -34,7 +34,7 @@ def gen_pheno_txt_file(this_dataset, vals):
             split_line = line.split()
             current_file_data.append(split_line)
 
-    with open(f"{flat_files('mapping')}/{this_dataset.group.name}.fam","w") as outfile:
+    with open(f"{flat_files('mapping')}/{this_dataset.group.name}.fam", "w") as outfile:
         for i, line in enumerate(current_file_data):
             if vals[i] == "x":
                 this_val = -9
@@ -42,7 +42,7 @@ def gen_pheno_txt_file(this_dataset, vals):
                 this_val = vals[i]
             outfile.write("0 " + line[1] + " " + line[2] + " " + line[3] + " " + line[4] + " " + str(this_val) + "\n")
 
-def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename = ''):
+def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename=''):
     ped_sample_list = get_samples_from_ped_file(dataset)
     output_file = open(f"{TMPDIR}{pheno_filename}.txt", "wb")
     header = f"FID\tIID\t{this_trait.name}\n"
@@ -50,7 +50,7 @@ def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename = ''):
 
     new_value_list = []
 
-    #if valueDict does not include some strain, value will be set to -9999 as missing value
+    # if valueDict does not include some strain, value will be set to -9999 as missing value
     for i, sample in enumerate(ped_sample_list):
         try:
             value = vals[i]
@@ -63,11 +63,11 @@ def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename = ''):
 
     new_line = ''
     for i, sample in enumerate(ped_sample_list):
-        j = i+1
+        j = i + 1
         value = new_value_list[i]
         new_line += f"{sample}\t{sample}\t{value}\n"
 
-        if j%1000 == 0:
+        if j % 1000 == 0:
             output_file.write(newLine)
             new_line = ''
 
@@ -78,9 +78,9 @@ def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename = ''):
 
 # get strain name from ped file in order
 def get_samples_from_ped_file(dataset):
-    ped_file= open(f"{flat_files('mapping')}{dataset.group.name}.ped","r")
+    ped_file = open(f"{flat_files('mapping')}{dataset.group.name}.ped", "r")
     line = ped_file.readline()
-    sample_list=[]
+    sample_list = []
 
     while line:
         lineList = line.strip().split('\t')
@@ -94,24 +94,24 @@ def get_samples_from_ped_file(dataset):
     return sample_list
 
 def parse_plink_output(output_filename, species):
-    plink_results={}
+    plink_results = {}
 
     threshold_p_value = 1
 
-    result_fp = open(f"{TMPDIR}{output_filename}.qassoc","rb")
+    result_fp = open(f"{TMPDIR}{output_filename}.qassoc", "rb")
 
     line = result_fp.readline()
 
-    value_list = [] # initialize value list, this list will include snp, bp and pvalue info
+    value_list = []  # initialize value list, this list will include snp, bp and pvalue info
     p_value_dict = {}
     count = 0
 
     while line:
-        #convert line from str to list
+        # convert line from str to list
         line_list = build_line_list(line=line)
 
         # only keep the records whose chromosome name is in db
-        if int(line_list[0]) in species.chromosomes.chromosomes and line_list[-1] and line_list[-1].strip()!='NA':
+        if int(line_list[0]) in species.chromosomes.chromosomes and line_list[-1] and line_list[-1].strip() != 'NA':
 
             chr_name = species.chromosomes.chromosomes[int(line_list[0])]
             snp = line_list[1]
@@ -125,7 +125,7 @@ def parse_plink_output(output_filename, species):
                 value_list = plink_results[chr_name]
 
                 # pvalue range is [0,1]
-                if threshold_p_value >=0 and threshold_p_value <= 1:
+                if threshold_p_value >= 0 and threshold_p_value <= 1:
                     if p_value < threshold_p_value:
                         value_list.append((snp, BP, p_value))
                         count += 1
@@ -141,7 +141,7 @@ def parse_plink_output(output_filename, species):
                 if value_list:
                     plink_results[chr_name] = value_list
 
-                value_list=[]
+                value_list = []
 
             line = result_fp.readline()
         else:
@@ -155,8 +155,8 @@ def parse_plink_output(output_filename, species):
 # output: lineList list
 #######################################################
 def build_line_list(line=""):
-    line_list = line.strip().split(' ')# irregular number of whitespaces between columns
-    line_list = [item for item in line_list if item !='']
+    line_list = line.strip().split(' ')  # irregular number of whitespaces between columns
+    line_list = [item for item in line_list if item != '']
     line_list = [item.strip() for item in line_list]
 
     return line_list
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index 8341ee55..dd044cb0 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -6,7 +6,7 @@ from base.data_set import create_dataset
 from utility.tools import flat_files, REAPER_COMMAND, TEMPDIR
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boot_check, num_bootstrap, do_control, control_marker, manhattan_plot, first_run=True, output_files=None):
     """Generates p-values for each marker using qtlreaper"""
@@ -17,10 +17,10 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         else:
             genofile_name = this_dataset.group.name
 
-        trait_filename =f"{str(this_trait.name)}_{str(this_dataset.name)}_pheno"
+        trait_filename = f"{str(this_trait.name)}_{str(this_dataset.name)}_pheno"
         gen_pheno_txt_file(samples, vals, trait_filename)
 
-        output_filename = (f"{this_dataset.group.name}_GWA_"+
+        output_filename = (f"{this_dataset.group.name}_GWA_" +
             ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
             )
         bootstrap_filename = None
@@ -36,7 +36,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             opt_list.append(f"--n_bootstrap {str(num_bootstrap)}")
             opt_list.append(f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
         if num_perm > 0:
-            permu_filename =("{this_dataset.group.name}_PERM_" + 
+            permu_filename = ("{this_dataset.group.name}_PERM_" + 
             ''.join(random.choice(string.ascii_uppercase + 
                 string.digits) for _ in range(6))
             )
@@ -67,8 +67,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
     suggestive = 0
     significant = 0
     if len(permu_vals) > 0:
-        suggestive = permu_vals[int(num_perm*0.37-1)]
-        significant = permu_vals[int(num_perm*0.95-1)]
+        suggestive = permu_vals[int(num_perm * 0.37 - 1)]
+        significant = permu_vals[int(num_perm * 0.95 - 1)]
 
     return (marker_obs, permu_vals, suggestive, significant, bootstrap_vals, 
         [output_filename, permu_filename, bootstrap_filename])
@@ -76,7 +76,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
 def gen_pheno_txt_file(samples, vals, trait_filename):
     """Generates phenotype file for GEMMA"""
 
-    with open(f"{TEMPDIR}/gn2/{trait_filename}.txt","w") as outfile:
+    with open(f"{TEMPDIR}/gn2/{trait_filename}.txt", "w") as outfile:
         outfile.write("Trait\t")
 
         filtered_sample_list = []
@@ -121,7 +121,7 @@ def parse_reaper_output(gwa_filename, permu_filename, bootstrap_filename):
                         marker['cM'] = float(line.split("\t")[3])
                     else:
                         if float(line.split("\t")[3]) > 1000:
-                            marker['Mb'] = float(line.split("\t")[3])/1000000
+                            marker['Mb'] = float(line.split("\t")[3]) / 1000000
                         else:
                             marker['Mb'] = float(line.split("\t")[3])
                     if float(line.split("\t")[6]) != 1:
@@ -132,7 +132,7 @@ def parse_reaper_output(gwa_filename, permu_filename, bootstrap_filename):
                 else:
                     marker['cM'] = float(line.split("\t")[3])
                     if float(line.split("\t")[4]) > 1000:
-                        marker['Mb'] = float(line.split("\t")[4])/1000000
+                        marker['Mb'] = float(line.split("\t")[4]) / 1000000
                     else:
                         marker['Mb'] = float(line.split("\t")[4])
                     if float(line.split("\t")[7]) != 1:
@@ -142,7 +142,7 @@ def parse_reaper_output(gwa_filename, permu_filename, bootstrap_filename):
                     marker['additive'] = float(line.split("\t")[6])
                 marker_obs.append(marker)
 
-    #ZS: Results have to be reordered because the new reaper returns results sorted alphabetically by chr for some reason, resulting in chr 1 being followed by 10, etc
+    # ZS: Results have to be reordered because the new reaper returns results sorted alphabetically by chr for some reason, resulting in chr 1 being followed by 10, etc
     sorted_indices = natural_sort(marker_obs)
 
     permu_vals = []
@@ -185,18 +185,18 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         suggestive = 0
         significant = 0
     else:
-        perm_output = genotype.permutation(strains = trimmed_samples, trait = trimmed_values, nperm=num_perm)
-        suggestive = perm_output[int(num_perm*0.37-1)]
-        significant = perm_output[int(num_perm*0.95-1)]
-        #highly_significant = perm_output[int(num_perm*0.99-1)] #ZS: Currently not used, but leaving it here just in case
+        perm_output = genotype.permutation(strains=trimmed_samples, trait=trimmed_values, nperm=num_perm)
+        suggestive = perm_output[int(num_perm * 0.37 - 1)]
+        significant = perm_output[int(num_perm * 0.95 - 1)]
+        # highly_significant = perm_output[int(num_perm*0.99-1)] #ZS: Currently not used, but leaving it here just in case
 
     json_data['suggestive'] = suggestive
     json_data['significant'] = significant
 
     if control_marker != "" and do_control == "true":
-        reaper_results = genotype.regression(strains = trimmed_samples,
-                                             trait = trimmed_values,
-                                             control = str(control_marker))
+        reaper_results = genotype.regression(strains=trimmed_samples,
+                                             trait=trimmed_values,
+                                             control=str(control_marker))
         if bootCheck:
             control_geno = []
             control_geno2 = []
@@ -215,31 +215,31 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
                     _idx = _prgy.index(_strain)
                     control_geno.append(control_geno2[_idx])
 
-            bootstrap_results = genotype.bootstrap(strains = trimmed_samples,
-                                                        trait = trimmed_values,
-                                                        control = control_geno,
-                                                        nboot = num_bootstrap)
+            bootstrap_results = genotype.bootstrap(strains=trimmed_samples,
+                                                        trait=trimmed_values,
+                                                        control=control_geno,
+                                                        nboot=num_bootstrap)
     else:
-        reaper_results = genotype.regression(strains = trimmed_samples,
-                                             trait = trimmed_values)
+        reaper_results = genotype.regression(strains=trimmed_samples,
+                                             trait=trimmed_values)
 
         if bootCheck:
-            bootstrap_results = genotype.bootstrap(strains = trimmed_samples,
-                                                        trait = trimmed_values,
-                                                        nboot = num_bootstrap)
+            bootstrap_results = genotype.bootstrap(strains=trimmed_samples,
+                                                        trait=trimmed_values,
+                                                        nboot=num_bootstrap)
 
     json_data['chr'] = []
     json_data['pos'] = []
     json_data['lod.hk'] = []
     json_data['markernames'] = []
-    #if self.additive:
+    # if self.additive:
     #    self.json_data['additive'] = []
 
-    #Need to convert the QTL objects that qtl reaper returns into a json serializable dictionary
+    # Need to convert the QTL objects that qtl reaper returns into a json serializable dictionary
     qtl_results = []
     for qtl in reaper_results:
         reaper_locus = qtl.locus
-        #ZS: Convert chr to int
+        # ZS: Convert chr to int
         converted_chr = reaper_locus.chr
         if reaper_locus.chr != "X" and reaper_locus.chr != "X/Y":
             converted_chr = int(reaper_locus.chr)
@@ -247,11 +247,11 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         json_data['pos'].append(reaper_locus.Mb)
         json_data['lod.hk'].append(qtl.lrs)
         json_data['markernames'].append(reaper_locus.name)
-        #if self.additive:
+        # if self.additive:
         #    self.json_data['additive'].append(qtl.additive)
-        locus = {"name":reaper_locus.name, "chr":reaper_locus.chr, "cM":reaper_locus.cM, "Mb":reaper_locus.Mb}
-        qtl = {"lrs_value": qtl.lrs, "chr":converted_chr, "Mb":reaper_locus.Mb,
-               "cM":reaper_locus.cM, "name":reaper_locus.name, "additive":qtl.additive, "dominance":qtl.dominance}
+        locus = {"name": reaper_locus.name, "chr": reaper_locus.chr, "cM": reaper_locus.cM, "Mb": reaper_locus.Mb}
+        qtl = {"lrs_value": qtl.lrs, "chr": converted_chr, "Mb": reaper_locus.Mb,
+               "cM": reaper_locus.cM, "name": reaper_locus.name, "additive": qtl.additive, "dominance": qtl.dominance}
         qtl_results.append(qtl)
     return qtl_results, json_data, perm_output, suggestive, significant, bootstrap_results
 
@@ -261,5 +261,5 @@ def natural_sort(marker_list):
     Changed to return indices instead of values, though, since the same reordering needs to be applied to bootstrap results
     """
     convert = lambda text: int(text) if text.isdigit() else text.lower()
-    alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', str(marker_list[key]['chr'])) ]
-    return sorted(list(range(len(marker_list))), key = alphanum_key)
\ No newline at end of file
+    alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', str(marker_list[key]['chr']))]
+    return sorted(list(range(len(marker_list))), key=alphanum_key)
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index 4117a0e5..2bd94512 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -13,7 +13,7 @@ from utility.tools import locate, TEMPDIR
 from flask import g
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 # Get a trait's type (numeric, categorical, etc) from the DB
 def get_trait_data_type(trait_db_string):
@@ -35,29 +35,29 @@ def get_trait_data_type(trait_db_string):
 # Run qtl mapping using R/qtl
 def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permCheck, num_perm, perm_strata_list, do_control, control_marker, manhattan_plot, pair_scan, cofactors):
     logger.info("Start run_rqtl_geno");
-    ## Get pointers to some common R functions
-    r_library     = ro.r["library"]                 # Map the library function
-    r_c           = ro.r["c"]                       # Map the c function
-    plot          = ro.r["plot"]                    # Map the plot function
-    png           = ro.r["png"]                     # Map the png function
-    dev_off       = ro.r["dev.off"]                 # Map the device off function
+    # Get pointers to some common R functions
+    r_library = ro.r["library"]                 # Map the library function
+    r_c = ro.r["c"]                       # Map the c function
+    plot = ro.r["plot"]                    # Map the plot function
+    png = ro.r["png"]                     # Map the png function
+    dev_off = ro.r["dev.off"]                 # Map the device off function
 
     print((r_library("qtl")))                         # Load R/qtl
 
     logger.info("QTL library loaded");
 
-    ## Get pointers to some R/qtl functions
-    scanone                    = ro.r["scanone"]               # Map the scanone function
-    scantwo                    = ro.r["scantwo"]               # Map the scantwo function
-    calc_genoprob              = ro.r["calc.genoprob"]         # Map the calc.genoprob function
+    # Get pointers to some R/qtl functions
+    scanone = ro.r["scanone"]               # Map the scanone function
+    scantwo = ro.r["scantwo"]               # Map the scantwo function
+    calc_genoprob = ro.r["calc.genoprob"]         # Map the calc.genoprob function
 
     crossname = dataset.group.name
-    #try:
+    # try:
     #    generate_cross_from_rdata(dataset)
     #    read_cross_from_rdata      = ro.r["generate_cross_from_rdata"] # Map the local read_cross_from_rdata function
     #    genofilelocation  = locate(crossname + ".RData", "genotype/rdata")
     #    cross_object = read_cross_from_rdata(genofilelocation)  # Map the local GENOtoCSVR function
-    #except:
+    # except:
 
     if mapping_scale == "morgan":
         scale_units = "cM"
@@ -65,10 +65,10 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
         scale_units = "Mb"
 
     generate_cross_from_geno(dataset, scale_units)
-    GENOtoCSVR                 = ro.r["GENOtoCSVR"]            # Map the local GENOtoCSVR function
+    GENOtoCSVR = ro.r["GENOtoCSVR"]            # Map the local GENOtoCSVR function
     crossfilelocation = TMPDIR + crossname + ".cross"
     if dataset.group.genofile:
-        genofilelocation  = locate(dataset.group.genofile, "genotype")
+        genofilelocation = locate(dataset.group.genofile, "genotype")
     else:
         genofilelocation = locate(dataset.group.name + ".geno", "genotype")
     logger.info("Going to create a cross from geno");
@@ -95,38 +95,38 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
     else:
         ro.r('all_covars <- marker_covars')
     covars = ro.r['all_covars']
-    #DEBUG to save the session object to file
+    # DEBUG to save the session object to file
     if pair_scan:
         if do_control == "true":
-            logger.info("Using covariate"); result_data_frame = scantwo(cross_object, pheno = "the_pheno", addcovar = covars, model=model, method=method, n_cluster = 16)
+            logger.info("Using covariate"); result_data_frame = scantwo(cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method, n_cluster = 16)
         else:
-            logger.info("No covariates"); result_data_frame = scantwo(cross_object, pheno = "the_pheno", model=model, method=method, n_cluster = 16)
+            logger.info("No covariates"); result_data_frame = scantwo(cross_object, pheno="the_pheno", model=model, method=method, n_cluster=16)
 
         pair_scan_filename = webqtlUtil.genRandStr("scantwo_") + ".png"
-        png(file=TEMPDIR+pair_scan_filename)
+        png(file=TEMPDIR + pair_scan_filename)
         plot(result_data_frame)
         dev_off()
 
         return process_pair_scan_results(result_data_frame)
     else:
         if do_control == "true" or cofactors != "":
-            logger.info("Using covariate"); result_data_frame = scanone(cross_object, pheno = "the_pheno", addcovar = covars, model=model, method=method)
+            logger.info("Using covariate"); result_data_frame = scanone(cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method)
             ro.r('save.image(file = "/home/zas1024/gn2-zach/itp_cofactor_test.RData")')
         else:
-            logger.info("No covariates"); result_data_frame = scanone(cross_object, pheno = "the_pheno", model=model, method=method)
+            logger.info("No covariates"); result_data_frame = scanone(cross_object, pheno="the_pheno", model=model, method=method)
 
         if num_perm > 0 and permCheck == "ON":                                                                   # Do permutation (if requested by user)
-            if len(perm_strata_list) > 0: #ZS: The strata list would only be populated if "Stratified" was checked on before mapping
+            if len(perm_strata_list) > 0:  # ZS: The strata list would only be populated if "Stratified" was checked on before mapping
                 cross_object, strata_ob = add_perm_strata(cross_object, perm_strata_list)
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col = "the_pheno", addcovar = covars, n_perm = int(num_perm), perm_strata = strata_ob, model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(num_perm), perm_strata = strata_ob, model=model, method=method)
                 else:
-                    perm_data_frame = scanone(cross_object, pheno_col = "the_pheno", n_perm = num_perm, perm_strata = strata_ob, model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", n_perm=num_perm, perm_strata = strata_ob, model=model, method=method)
             else:
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col = "the_pheno", addcovar = covars, n_perm = int(num_perm), model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(num_perm), model=model, method=method)
                 else:
-                    perm_data_frame = scanone(cross_object, pheno_col = "the_pheno", n_perm = num_perm, model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", n_perm=num_perm, model=model, method=method)
 
             perm_output, suggestive, significant = process_rqtl_perm_results(num_perm, perm_data_frame)          # Functions that sets the thresholds for the webinterface
             return perm_output, suggestive, significant, process_rqtl_results(result_data_frame, dataset.group.species)
@@ -134,7 +134,7 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
             return process_rqtl_results(result_data_frame, dataset.group.species)
 
 def generate_cross_from_rdata(dataset):
-    rdata_location  = locate(dataset.group.name + ".RData", "genotype/rdata")
+    rdata_location = locate(dataset.group.name + ".RData", "genotype/rdata")
     ro.r("""
        generate_cross_from_rdata <- function(filename = '%s') {
            load(file=filename)
@@ -206,7 +206,7 @@ def sanitize_rqtl_phenotype(vals):
     for i, val in enumerate(vals):
         if val == "x":
             if i < (len(vals) - 1):
-                pheno_as_string +=  "NA,"
+                pheno_as_string += "NA,"
             else:
                 pheno_as_string += "NA"
         else:
@@ -223,7 +223,7 @@ def sanitize_rqtl_names(vals):
     for i, val in enumerate(vals):
         if val == "x":
             if i < (len(vals) - 1):
-                pheno_as_string +=  "NA,"
+                pheno_as_string += "NA,"
             else:
                 pheno_as_string += "NA"
         else:
@@ -238,7 +238,7 @@ def sanitize_rqtl_names(vals):
 def add_phenotype(cross, pheno_as_string, col_name):
     ro.globalenv["the_cross"] = cross
     ro.r('pheno <- data.frame(pull.pheno(the_cross))')
-    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = as.numeric('+ pheno_as_string +'))')
+    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = as.numeric(' + pheno_as_string + '))')
     return ro.r["the_cross"]
 
 def add_categorical_covar(cross, covar_as_string, i):
@@ -256,8 +256,8 @@ def add_categorical_covar(cross, covar_as_string, i):
     nCol = int(nCol[0])
     logger.info("nCol python int:" + str(nCol));
     col_names = []
-    #logger.info("loop")
-    for x in range(1, (nCol+1)):
+    # logger.info("loop")
+    for x in range(1, (nCol + 1)):
       #logger.info("loop" + str(x));
       col_name = "covar_" + str(i) + "_" + str(x)
       #logger.info("col_name" + col_name);
@@ -272,12 +272,12 @@ def add_categorical_covar(cross, covar_as_string, i):
 def add_names(cross, names_as_string, col_name):
     ro.globalenv["the_cross"] = cross
     ro.r('pheno <- data.frame(pull.pheno(the_cross))')
-    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = '+ names_as_string +')')
+    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = ' + names_as_string + ')')
     return ro.r["the_cross"]
 
 def pull_var(var_name, cross, var_string):
     ro.globalenv["the_cross"] = cross
-    ro.r(var_name +' <- pull.pheno(the_cross, ' + var_string + ')')
+    ro.r(var_name + ' <- pull.pheno(the_cross, ' + var_string + ')')
 
     return ro.r[var_name]
 
@@ -317,15 +317,15 @@ def add_cofactors(cross, this_dataset, covariates, samples):
 
         datatype = get_trait_data_type(covariate)
         logger.info("Covariate: " + covariate + " is of type: " + datatype);
-        if(datatype == "categorical"): # Cat variable
+        if(datatype == "categorical"):  # Cat variable
             logger.info("call of add_categorical_covar");
-            cross, col_names = add_categorical_covar(cross, covar_as_string, i) # Expand and add it to the cross
+            cross, col_names = add_categorical_covar(cross, covar_as_string, i)  # Expand and add it to the cross
             logger.info("add_categorical_covar returned");
-            for z, col_name in enumerate(col_names): # Go through the additional covar names
+            for z, col_name in enumerate(col_names):  # Go through the additional covar names
                 if i < (len(covariate_list) - 1):
                     covar_name_string += '"' + col_name + '", '
                 else:
-                    if(z < (len(col_names) -1)):
+                    if(z < (len(col_names) - 1)):
                         covar_name_string += '"' + col_name + '", '
                     else:
                         covar_name_string += '"' + col_name + '"'
@@ -376,7 +376,7 @@ def process_pair_scan_results(result):
 
 def process_rqtl_perm_results(num_perm, results):
     perm_vals = []
-    for line in str(results).split("\n")[1:(num_perm+1)]:
+    for line in str(results).split("\n")[1:(num_perm + 1)]:
         #print("R/qtl permutation line:", line.split())
         perm_vals.append(float(line.split()[1]))
 
@@ -393,7 +393,7 @@ def process_rqtl_results(result, species_name):        # TODO: how to make this
     for i, line in enumerate(result.iter_row()):
         marker = {}
         marker['name'] = result.rownames[i]
-        if species_name == "mouse" and output[i][0] == 20: #ZS: This is awkward, but I'm not sure how to change the 20s to Xs in the RData file
+        if species_name == "mouse" and output[i][0] == 20:  # ZS: This is awkward, but I'm not sure how to change the 20s to Xs in the RData file
             marker['chr'] = "X"
         else:
             marker['chr'] = output[i][0]
@@ -402,4 +402,4 @@ def process_rqtl_results(result, species_name):        # TODO: how to make this
         marker['lod_score'] = output[i][2]
         qtl_results.append(marker)
 
-    return qtl_results
\ No newline at end of file
+    return qtl_results
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index 7dd0bcb6..f1665570 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -1,5 +1,5 @@
 from base.trait import GeneralTrait
-from base import data_set  #import create_dataset
+from base import data_set  # import create_dataset
 
 from pprint import pformat as pf
 
@@ -43,16 +43,16 @@ from utility.external import shell
 from base.webqtlConfig import TMPDIR, GENERATED_TEXT_DIR
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 class RunMapping:
 
     def __init__(self, start_vars, temp_uuid):
         helper_functions.get_species_dataset_trait(self, start_vars)
 
-        self.temp_uuid = temp_uuid #needed to pass temp_uuid to gn1 mapping code (marker_regression_gn1.py)
+        self.temp_uuid = temp_uuid  # needed to pass temp_uuid to gn1 mapping code (marker_regression_gn1.py)
 
-        #ZS: Needed to zoom in or remap temp traits like PCA traits
+        # ZS: Needed to zoom in or remap temp traits like PCA traits
         if "temp_trait" in start_vars and start_vars['temp_trait'] != "False":
             self.temp_trait = "True"
             self.group = self.dataset.group.name
@@ -60,7 +60,7 @@ class RunMapping:
         self.json_data = {}
         self.json_data['lodnames'] = ['lod.hk']
 
-        #ZS: Sometimes a group may have a genofile that only includes a subset of samples
+        # ZS: Sometimes a group may have a genofile that only includes a subset of samples
         genofile_samplelist = []
         if 'genofile' in start_vars:
           if start_vars['genofile'] != "":
@@ -93,7 +93,7 @@ class RunMapping:
         else:
             self.n_samples = len([val for val in self.vals if val != "x"])
 
-        #ZS: Check if genotypes exist in the DB in order to create links for markers
+        # ZS: Check if genotypes exist in the DB in order to create links for markers
 
         self.geno_db_exists = geno_db_exists(self.dataset)
 
@@ -114,19 +114,19 @@ class RunMapping:
                         self.manhattan_single_color = start_vars['manhattan_single_color']
                 self.manhattan_plot = True
 
-        self.maf = start_vars['maf'] # Minor allele frequency
+        self.maf = start_vars['maf']  # Minor allele frequency
         if "use_loco" in start_vars:
             self.use_loco = start_vars['use_loco']
         else:
             self.use_loco = None
         self.suggestive = ""
         self.significant = ""
-        self.pair_scan = False # Initializing this since it is checked in views to determine which template to use
+        self.pair_scan = False  # Initializing this since it is checked in views to determine which template to use
         if 'transform' in start_vars:
             self.transform = start_vars['transform']
         else:
             self.transform = ""
-        self.score_type = "LRS" #ZS: LRS or LOD
+        self.score_type = "LRS"  # ZS: LRS or LOD
         self.mapping_scale = "physic"
         if "mapping_scale" in start_vars:
             self.mapping_scale = start_vars['mapping_scale']
@@ -136,10 +136,10 @@ class RunMapping:
         self.covariates = start_vars['covariates'] if "covariates" in start_vars else ""
         self.categorical_vars = []
 
-        #ZS: This is passed to GN1 code for single chr mapping
+        # ZS: This is passed to GN1 code for single chr mapping
         self.selected_chr = -1
         if "selected_chr" in start_vars:
-            if int(start_vars['selected_chr']) != -1: #ZS: Needs to be -1 if showing full map; there's probably a better way to fix this
+            if int(start_vars['selected_chr']) != -1:  # ZS: Needs to be -1 if showing full map; there's probably a better way to fix this
                 self.selected_chr = int(start_vars['selected_chr']) + 1
             else:
                 self.selected_chr = int(start_vars['selected_chr'])
@@ -153,7 +153,7 @@ class RunMapping:
             self.lrsMax = start_vars['lrsMax']
         if "haplotypeAnalystCheck" in start_vars:
             self.haplotypeAnalystCheck = start_vars['haplotypeAnalystCheck']
-        if "startMb" in start_vars: #ZS: This is to ensure showGenes, Legend, etc are checked the first time you open the mapping page, since startMb will only not be set during the first load
+        if "startMb" in start_vars:  # ZS: This is to ensure showGenes, Legend, etc are checked the first time you open the mapping page, since startMb will only not be set during the first load
             if "permCheck" in start_vars:
                 self.permCheck = "ON"
             else:
@@ -191,13 +191,13 @@ class RunMapping:
             self.showGenes = "ON"
             self.viewLegend = "ON"
 
-        #self.dataset.group.get_markers()
+        # self.dataset.group.get_markers()
         if self.mapping_method == "gemma":
             self.first_run = True
             self.output_files = None
             if 'output_files' in start_vars:
                 self.output_files = start_vars['output_files']
-            if 'first_run' in start_vars: #ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+            if 'first_run' in start_vars:  # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
                 self.first_run = False
             self.score_type = "-logP"
             self.manhattan_plot = True
@@ -214,9 +214,9 @@ class RunMapping:
             if "perm_strata" in start_vars and "categorical_vars" in start_vars:
                 self.categorical_vars = start_vars["categorical_vars"].split(",")
                 if len(self.categorical_vars) and start_vars["perm_strata"] == "True":
-                    primary_samples = SampleList(dataset = self.dataset,
-                                                 sample_names = self.samples,
-                                                 this_trait = self.this_trait)
+                    primary_samples = SampleList(dataset=self.dataset,
+                                                 sample_names=self.samples,
+                                                 this_trait=self.this_trait)
 
                     perm_strata = get_perm_strata(self.this_trait, primary_samples, self.categorical_vars, self.samples)
             self.score_type = "LOD"
@@ -227,14 +227,14 @@ class RunMapping:
             else:
                 self.method = "em"
             self.model = start_vars['mapmodel_rqtl_geno']
-            #if start_vars['pair_scan'] == "true":
+            # if start_vars['pair_scan'] == "true":
             #    self.pair_scan = True
             if self.permCheck and self.num_perm > 0:
-                self.perm_output, self.suggestive, self.significant, results= rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
+                self.perm_output, self.suggestive, self.significant, results = rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
             else:
                 results = rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
         elif self.mapping_method == "reaper":
-            if "startMb" in start_vars: #ZS: Check if first time page loaded, so it can default to ON
+            if "startMb" in start_vars:  # ZS: Check if first time page loaded, so it can default to ON
                 if "additiveCheck" in start_vars:
                     self.additiveCheck = start_vars['additiveCheck']
                 else:
@@ -267,7 +267,7 @@ class RunMapping:
             if self.reaper_version == "new":
                 self.first_run = True
                 self.output_files = None
-                if 'first_run' in start_vars: #ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+                if 'first_run' in start_vars:  # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
                     self.first_run = False
                     if 'output_files' in start_vars:
                         self.output_files = start_vars['output_files'].split(",")
@@ -311,7 +311,7 @@ class RunMapping:
         else:
           if self.pair_scan == True:
               self.qtl_results = []
-              highest_chr = 1 #This is needed in order to convert the highest chr to X/Y
+              highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
               for marker in results:
                   if marker['chr1'] > 0 or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
                       if marker['chr1'] > highest_chr or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
@@ -328,51 +328,51 @@ class RunMapping:
                   self.json_data['markernames'].append(qtl['name'])
 
               self.js_data = dict(
-                  json_data = self.json_data,
-                  this_trait = self.this_trait.name,
-                  data_set = self.dataset.name,
-                  maf = self.maf,
-                  manhattan_plot = self.manhattan_plot,
-                  mapping_scale = self.mapping_scale,
-                  qtl_results = self.qtl_results
+                  json_data=self.json_data,
+                  this_trait=self.this_trait.name,
+                  data_set=self.dataset.name,
+                  maf=self.maf,
+                  manhattan_plot=self.manhattan_plot,
+                  mapping_scale=self.mapping_scale,
+                  qtl_results=self.qtl_results
               )
 
           else:
               self.qtl_results = []
               self.results_for_browser = []
               self.annotations_for_browser = []
-              highest_chr = 1 #This is needed in order to convert the highest chr to X/Y
+              highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
               for marker in results:
                   if 'Mb' in marker:
-                      this_ps = marker['Mb']*1000000
+                      this_ps = marker['Mb'] * 1000000
                   else:
-                      this_ps = marker['cM']*1000000
+                      this_ps = marker['cM'] * 1000000
 
                   browser_marker = dict(
-                      chr = str(marker['chr']),
-                      rs  = marker['name'],
-                      ps  = this_ps,
-                      url = "/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
+                      chr=str(marker['chr']),
+                      rs=marker['name'],
+                      ps=this_ps,
+                      url="/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
                   )
 
                   if self.geno_db_exists == "True":
                       annot_marker = dict(
-                          name = str(marker['name']),
-                          chr = str(marker['chr']),
-                          rs  = marker['name'],
-                          pos  = this_ps,
-                          url = "/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
+                          name=str(marker['name']),
+                          chr=str(marker['chr']),
+                          rs=marker['name'],
+                          pos=this_ps,
+                          url="/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
                       )
                   else:
                       annot_marker = dict(
-                          name = str(marker['name']),
-                          chr = str(marker['chr']),
-                          rs  = marker['name'],
-                          pos  = this_ps
+                          name=str(marker['name']),
+                          chr=str(marker['chr']),
+                          rs=marker['name'],
+                          pos=this_ps
                       )
 
                   if 'lrs_value' in marker and marker['lrs_value'] > 0:
-                      browser_marker['p_wald'] = 10**-(marker['lrs_value']/4.61)
+                      browser_marker['p_wald'] = 10**-(marker['lrs_value'] / 4.61)
                   elif 'lod_score' in marker and marker['lod_score'] > 0:
                       browser_marker['p_wald'] = 10**-(marker['lod_score'])
                   else:
@@ -417,7 +417,7 @@ class RunMapping:
 
               chr_lengths = get_chr_lengths(self.mapping_scale, self.mapping_method, self.dataset, self.qtl_results)
 
-              #ZS: For zooming into genome browser, need to pass chromosome name instead of number
+              # ZS: For zooming into genome browser, need to pass chromosome name instead of number
               if self.dataset.group.species == "mouse":
                   if self.selected_chr == 20:
                       this_chr = "X"
@@ -451,29 +451,29 @@ class RunMapping:
                       #mapping_scale = self.mapping_scale,
                       #chromosomes = chromosome_mb_lengths,
                       #qtl_results = self.qtl_results,
-                      categorical_vars = self.categorical_vars,
-                      chr_lengths = chr_lengths,
-                      num_perm = self.num_perm,
-                      perm_results = self.perm_output,
-                      significant = significant_for_browser,
-                      browser_files = browser_files,
-                      selected_chr = this_chr,
-                      total_markers = total_markers
+                      categorical_vars=self.categorical_vars,
+                      chr_lengths=chr_lengths,
+                      num_perm=self.num_perm,
+                      perm_results=self.perm_output,
+                      significant=significant_for_browser,
+                      browser_files=browser_files,
+                      selected_chr=this_chr,
+                      total_markers=total_markers
                   )
               else:
                 self.js_data = dict(
-                    chr_lengths = chr_lengths,
-                    browser_files = browser_files,
-                    selected_chr = this_chr,
-                    total_markers = total_markers
+                    chr_lengths=chr_lengths,
+                    browser_files=browser_files,
+                    selected_chr=this_chr,
+                    total_markers=total_markers
                 )
 
     def run_rqtl_plink(self):
         # os.chdir("") never do this inside a webserver!!
 
-        output_filename = webqtlUtil.genRandStr("%s_%s_"%(self.dataset.group.name, self.this_trait.name))
+        output_filename = webqtlUtil.genRandStr("%s_%s_" % (self.dataset.group.name, self.this_trait.name))
 
-        plink_mapping.gen_pheno_txt_file_plink(self.this_trait, self.dataset, self.vals, pheno_filename = output_filename)
+        plink_mapping.gen_pheno_txt_file_plink(self.this_trait, self.dataset, self.vals, pheno_filename=output_filename)
 
         rqtl_command = './plink --noweb --ped %s.ped --no-fid --no-parents --no-sex --no-pheno --map %s.map --pheno %s/%s.txt --pheno-name %s --maf %s --missing-phenotype -9999 --out %s%s --assoc ' % (self.dataset.group.name, self.dataset.group.name, TMPDIR, plink_output_filename, self.this_trait.name, self.maf, TMPDIR, plink_output_filename)
 
@@ -612,11 +612,11 @@ def trim_markers_for_figure(markers):
                 if low_counter % 20 == 0:
                     filtered_markers.append(marker)
                 low_counter += 1
-            elif 4.61 <= marker[score_type] < (2*4.61):
+            elif 4.61 <= marker[score_type] < (2 * 4.61):
                 if med_counter % 10 == 0:
                     filtered_markers.append(marker)
                 med_counter += 1
-            elif (2*4.61) <= marker[score_type] <= (3*4.61):
+            elif (2 * 4.61) <= marker[score_type] <= (3 * 4.61):
                 if high_counter % 2 == 0:
                     filtered_markers.append(marker)
                 high_counter += 1
@@ -630,7 +630,7 @@ def trim_markers_for_table(markers):
     else:
         sorted_markers = sorted(markers, key=lambda k: k['lrs_value'], reverse=True)
 
-    #ZS: So we end up with a list of just 2000 markers
+    # ZS: So we end up with a list of just 2000 markers
     if len(sorted_markers) >= 2000:
         trimmed_sorted_markers = sorted_markers[:2000]
         return trimmed_sorted_markers
@@ -682,9 +682,9 @@ def get_chr_lengths(mapping_scale, mapping_method, dataset, qtl_results):
                         highest_pos = float(result['cM']) * 1000000
                     else:
                         highest_pos = float(result['Mb']) * 1000000
-                    chr_lengths.append({ "chr": str(this_chr), "size": str(highest_pos)})
+                    chr_lengths.append({"chr": str(this_chr), "size": str(highest_pos)})
                 else:
-                    chr_lengths.append({ "chr": str(this_chr), "size": str(highest_pos)})
+                    chr_lengths.append({"chr": str(this_chr), "size": str(highest_pos)})
                     this_chr = chr_as_num
             else:
                 if mapping_method == "reaper":
@@ -721,7 +721,7 @@ def get_perm_strata(this_trait, sample_list, categorical_vars, used_samples):
 
         perm_strata_strings.append(combined_string)
 
-    d = dict([(y, x+1) for x, y in enumerate(sorted(set(perm_strata_strings)))])
+    d = dict([(y, x + 1) for x, y in enumerate(sorted(set(perm_strata_strings)))])
     list_to_numbers = [d[x] for x in perm_strata_strings]
     perm_strata = list_to_numbers
 
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index 772f74e4..8abd6516 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -29,14 +29,14 @@ class User(Base):
 
     registration_info = Column(Text)   # json detailing when they were registered, etc.
 
-    confirmed = Column(Text) # json detailing when they confirmed, etc.
+    confirmed = Column(Text)  # json detailing when they confirmed, etc.
 
-    superuser = Column(Text) # json detailing when they became a superuser, otherwise empty
+    superuser = Column(Text)  # json detailing when they became a superuser, otherwise empty
                              # if not superuser
 
     logins = relationship("Login",
                           order_by="desc(Login.timestamp)",
-                          lazy='dynamic', # Necessary for filter in login_count
+                          lazy='dynamic',  # Necessary for filter in login_count
                           foreign_keys="Login.user",
                           )
 
@@ -67,7 +67,7 @@ class User(Base):
     def get_collection_by_name(self, collection_name):
         try:
             collect = self.user_collections.filter_by(name=collection_name).first()
-        except  sqlalchemy.orm.exc.NoResultFound:
+        except sqlalchemy.orm.exc.NoResultFound:
             collect = None
         return collect
 
diff --git a/wqflask/wqflask/parser.py b/wqflask/wqflask/parser.py
index dcd328c9..dfd374e2 100644
--- a/wqflask/wqflask/parser.py
+++ b/wqflask/wqflask/parser.py
@@ -22,7 +22,7 @@ import re
 from pprint import pformat as pf
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 def parse(pstring):
     """
@@ -52,7 +52,7 @@ def parse(pstring):
             if '(' in value or '[' in value:
                 assert value.startswith(("(", "[")), "Invalid token"
                 assert value.endswith((")", "]")), "Invalid token"
-                value = value[1:-1] # Get rid of the parenthesis
+                value = value[1:-1]  # Get rid of the parenthesis
                 values = re.split(r"""\s+|,""", value)
                 value = [value.strip() for value in values if value.strip()]
             else:
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index 7d51a83d..a1fe0f8f 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -26,7 +26,7 @@ def manage_resource():
 
         owner_display_name = None
         if owner_id != "none":
-            try: #ZS: User IDs are sometimes stored in Redis as bytes and sometimes as strings, so this is just to avoid any errors for the time being
+            try:  # ZS: User IDs are sometimes stored in Redis as bytes and sometimes as strings, so this is just to avoid any errors for the time being
                 owner_id = str.encode(owner_id)
             except:
                 pass
@@ -38,7 +38,7 @@ def manage_resource():
             elif 'email_address' in owner_info:
                 owner_display_name = owner_info['email_address']
 
-        return render_template("admin/manage_resource.html", owner_name = owner_display_name, resource_id = resource_id, resource_info=resource_info, default_mask=default_mask, group_masks=group_masks_with_names, admin_status=admin_status)
+        return render_template("admin/manage_resource.html", owner_name=owner_display_name, resource_id=resource_id, resource_info=resource_info, default_mask=default_mask, group_masks=group_masks_with_names, admin_status=admin_status)
 
 @app.route("/search_for_users", methods=('POST',))
 def search_for_user():
@@ -79,7 +79,7 @@ def change_owner():
             flash("You lack the permissions to make this change.", "error")
             return redirect(url_for("manage_resource", resource_id=resource_id))
     else:
-        return render_template("admin/change_resource_owner.html", resource_id = resource_id)
+        return render_template("admin/change_resource_owner.html", resource_id=resource_id)
 
 @app.route("/resources/change_default_privileges", methods=('POST',))
 def change_default_privileges():
@@ -108,7 +108,7 @@ def add_group_to_resource():
             group_id = request.form['selected_group']
             resource_info = get_resource_info(resource_id)
             default_privileges = resource_info['default_mask']
-            return render_template("admin/set_group_privileges.html", resource_id = resource_id, group_id = group_id, default_privileges = default_privileges)
+            return render_template("admin/set_group_privileges.html", resource_id=resource_id, group_id=group_id, default_privileges = default_privileges)
         elif all(key in request.form for key in ('data_privilege', 'metadata_privilege', 'admin_privilege')):
             group_id = request.form['group_id']
             group_name = get_group_info(group_id)['name']
@@ -121,7 +121,7 @@ def add_group_to_resource():
             flash("Privileges have been added for group {}.".format(group_name), "alert-info")
             return redirect(url_for("manage_resource", resource_id=resource_id))
         else:
-            return render_template("admin/search_for_groups.html", resource_id = resource_id)
+            return render_template("admin/search_for_groups.html", resource_id=resource_id)
     else:
         return redirect(url_for("no_access_page"))
 
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index fd7c132b..16eb1864 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -22,7 +22,7 @@ from utility.tools import GN2_BASE_URL
 from utility.type_checking import is_str
 
 from utility.logger import getLogger
-logger = getLogger(__name__ )
+logger = getLogger(__name__)
 
 class SearchResultPage:
     #maxReturn = 3000
@@ -39,7 +39,7 @@ class SearchResultPage:
 
         self.uc_id = uuid.uuid4()
         self.go_term = None
-        logger.debug("uc_id:", self.uc_id) # contains a unique id
+        logger.debug("uc_id:", self.uc_id)  # contains a unique id
 
         logger.debug("kw is:", kw)         # dict containing search terms
         if kw['search_terms_or']:
@@ -72,7 +72,7 @@ class SearchResultPage:
         self.dataset = create_dataset(kw['dataset'], dataset_type)
         logger.debug("search_terms:", self.search_terms)
 
-        #ZS: I don't like using try/except, but it seems like the easiest way to account for all possible bad searches here
+        # ZS: I don't like using try/except, but it seems like the easiest way to account for all possible bad searches here
         try:
             self.search()
         except:
@@ -183,7 +183,7 @@ class SearchResultPage:
 
         combined_from_clause = ""
         combined_where_clause = ""
-        previous_from_clauses = [] #The same table can't be referenced twice in the from clause
+        previous_from_clauses = []  # The same table can't be referenced twice in the from clause
 
         logger.debug("len(search_terms)>1")
         symbol_list = []
@@ -231,7 +231,7 @@ class SearchResultPage:
                             combined_from_clause += from_clause
                     where_clause = the_search.get_where_clause()
                     combined_where_clause += "(" + where_clause + ")"
-                    if (i+1) < len(self.search_terms):
+                    if (i + 1) < len(self.search_terms):
                         if self.and_or == "and":
                             combined_where_clause += "AND"
                         else:
@@ -291,7 +291,7 @@ def insert_newlines(string, every=64):
     """ This is because it is seemingly impossible to change the width of the description column, so I'm just manually adding line breaks """
     lines = []
     for i in range(0, len(string), every):
-        lines.append(string[i:i+every])
+        lines.append(string[i:i + every])
     return '\n'.join(lines)
 
 def get_aliases(symbol_list, species):
@@ -322,9 +322,9 @@ def get_aliases(symbol_list, species):
 
     search_terms = []
     for alias in filtered_aliases:
-        the_search_term = {'key':         None,
+        the_search_term = {'key': None,
                            'search_term': [alias],
-                           'separator' :  None}
+                           'separator': None}
         search_terms.append(the_search_term)
 
     return search_terms
diff --git a/wqflask/wqflask/show_trait/SampleList.py b/wqflask/wqflask/show_trait/SampleList.py
index f955f632..388f831f 100644
--- a/wqflask/wqflask/show_trait/SampleList.py
+++ b/wqflask/wqflask/show_trait/SampleList.py
@@ -36,16 +36,16 @@ class SampleList:
             if isinstance(self.this_trait, list):
                 sample = webqtlCaseData.webqtlCaseData(name=sample_name)
                 if counter <= len(self.this_trait):
-                    if isinstance(self.this_trait[counter-1], (bytes, bytearray)):
-                        if (self.this_trait[counter-1].decode("utf-8").lower() != 'x'):
+                    if isinstance(self.this_trait[counter - 1], (bytes, bytearray)):
+                        if (self.this_trait[counter - 1].decode("utf-8").lower() != 'x'):
                             sample = webqtlCaseData.webqtlCaseData(
                                 name=sample_name,
-                                value=float(self.this_trait[counter-1]))
+                                value=float(self.this_trait[counter - 1]))
                     else:
-                        if (self.this_trait[counter-1].lower() != 'x'):
+                        if (self.this_trait[counter - 1].lower() != 'x'):
                             sample = webqtlCaseData.webqtlCaseData(
                                 name=sample_name,
-                                value=float(self.this_trait[counter-1]))
+                                value=float(self.this_trait[counter - 1]))
             else:
                 # ZS - If there's no value for the sample/strain,
                 # create the sample object (so samples with no value
@@ -69,7 +69,7 @@ class SampleList:
                 sample.extra_attributes = self.sample_attribute_values.get(
                     sample_name, {})
 
-                #ZS: Add a url so RRID case attributes can be displayed as links
+                # ZS: Add a url so RRID case attributes can be displayed as links
                 if 'rrid' in sample.extra_attributes:
                     if self.dataset.group.species == "mouse":
                         if len(sample.extra_attributes['rrid'].split(":")) > 1:
@@ -129,7 +129,7 @@ class SampleList:
             self.attributes[key].name = name
             self.attributes[key].distinct_values = [
                 item.Value for item in values]
-            self.attributes[key].distinct_values=natural_sort(self.attributes[key].distinct_values)
+            self.attributes[key].distinct_values = natural_sort(self.attributes[key].distinct_values)
             all_numbers = True
             for value in self.attributes[key].distinct_values:
                 try:
diff --git a/wqflask/wqflask/show_trait/show_trait.py b/wqflask/wqflask/show_trait/show_trait.py
index f9c5fbe6..18cadea4 100644
--- a/wqflask/wqflask/show_trait/show_trait.py
+++ b/wqflask/wqflask/show_trait/show_trait.py
@@ -46,7 +46,7 @@ class ShowTrait:
                 resource_id=self.resource_id)
         elif 'group' in kw:
             self.temp_trait = True
-            self.trait_id = "Temp_"+kw['species'] + "_" + kw['group'] + \
+            self.trait_id = "Temp_" + kw['species'] + "_" + kw['group'] + \
                 "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
             self.temp_species = kw['species']
             self.temp_group = kw['group']
@@ -368,8 +368,8 @@ class ShowTrait:
                         chr = transcript_start = transcript_end = None
 
                     if chr and transcript_start and transcript_end and self.this_trait.refseq_transcriptid:
-                        transcript_start = int(transcript_start*1000000)
-                        transcript_end = int(transcript_end*1000000)
+                        transcript_start = int(transcript_start * 1000000)
+                        transcript_end = int(transcript_end * 1000000)
                         self.ucsc_blat_link = webqtlConfig.UCSC_REFSEQ % (
                             'mm10', self.this_trait.refseq_transcriptid, chr, transcript_start, transcript_end)
 
@@ -393,8 +393,8 @@ class ShowTrait:
 
                 if chr and transcript_start and transcript_end and kgId:
                     # Convert to bases from megabases
-                    transcript_start = int(transcript_start*1000000)
-                    transcript_end = int(transcript_end*1000000)
+                    transcript_start = int(transcript_start * 1000000)
+                    transcript_end = int(transcript_end * 1000000)
                     self.ucsc_blat_link = webqtlConfig.UCSC_REFSEQ % (
                         'rn6', kgId, chr, transcript_start, transcript_end)
 
@@ -515,13 +515,13 @@ def quantile_normalize_vals(sample_groups):
         ranked_vals = ss.rankdata(trait_vals)
         p_list = []
         for i, val in enumerate(trait_vals):
-            p_list.append(((i+1) - 0.5)/len(trait_vals))
+            p_list.append(((i + 1) - 0.5) / len(trait_vals))
 
         z = ss.norm.ppf(p_list)
 
         normed_vals = []
         for rank in ranked_vals:
-            normed_vals.append("%0.3f" % z[int(rank)-1])
+            normed_vals.append("%0.3f" % z[int(rank) - 1])
 
         return normed_vals
 
@@ -585,7 +585,7 @@ def get_nearest_marker(this_trait, this_db):
                      GenoXRef.GenoId = Geno.Id AND
                      GenoFreeze.Id = GenoXRef.GenoFreezeId AND
                      GenoFreeze.Name = '{}'
-               ORDER BY ABS( Geno.Mb - {}) LIMIT 1""".format(this_chr, this_db.group.name+"Geno", this_mb)
+               ORDER BY ABS( Geno.Mb - {}) LIMIT 1""".format(this_chr, this_db.group.name + "Geno", this_mb)
     logger.sql(query)
     result = g.db.execute(query).fetchall()
 
@@ -605,7 +605,7 @@ def get_table_widths(sample_groups, sample_column_width, has_num_cases=False):
         trait_table_width += 80
     if has_num_cases:
         trait_table_width += 80
-    trait_table_width += len(sample_groups[0].attributes)*88
+    trait_table_width += len(sample_groups[0].attributes) * 88
 
     trait_table_width = str(trait_table_width) + "px"
 
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index 8658abf8..7a0df94b 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -26,9 +26,9 @@ class SnpBrowser:
                 self.table_rows = []
 
             if self.limit_strains == "true":
-                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type = self.variant_type, strains = self.chosen_strains, empty_columns = self.empty_columns)
+                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type=self.variant_type, strains=self.chosen_strains, empty_columns = self.empty_columns)
             else:
-                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type = self.variant_type, strains = self.strain_lists, species = self.species_name, empty_columns = self.empty_columns)
+                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type=self.variant_type, strains=self.strain_lists, species = self.species_name, empty_columns = self.empty_columns)
 
     def initialize_parameters(self, start_vars):
         if 'first_run' in start_vars:
@@ -249,7 +249,7 @@ class SnpBrowser:
 
     def filter_results(self, results):
         filtered_results = []
-        strain_index_list = [] #ZS: List of positions of selected strains in strain list
+        strain_index_list = []  # ZS: List of positions of selected strains in strain list
         last_mb = -1
 
         if self.limit_strains == "true" and len(self.chosen_strains) > 0:
@@ -272,9 +272,9 @@ class SnpBrowser:
                 if self.limit_strains == "true" and len(self.chosen_strains) > 0:
                     for index in strain_index_list:
                         if self.species_id == 1:
-                            display_strains.append(result[29+index])
+                            display_strains.append(result[29 + index])
                         elif self.species_id == 2:
-                            display_strains.append(result[31+index])
+                            display_strains.append(result[31 + index])
                     self.allele_list = display_strains
 
                 effect_info_dict = get_effect_info(effect_list)
@@ -300,7 +300,7 @@ class SnpBrowser:
                         else:
                             gene = check_if_in_gene(species_id, chr, mb)
                         transcript = exon = function = function_details = ''
-                        if self.redundant == "false" or last_mb != mb: # filter redundant
+                        if self.redundant == "false" or last_mb != mb:  # filter redundant
                             if self.include_record(domain, function, snp_source, conservation_score):
                                 info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain, function, function_details, snp_source, conservation_score, snp_id]
                                 info_list.extend(self.allele_list)
@@ -366,7 +366,7 @@ class SnpBrowser:
             if len(gene_name_list) > 0:
                 gene_id_name_dict = get_gene_id_name_dict(self.species_id, gene_name_list)
 
-        #ZS: list of booleans representing which columns are entirely empty, so they aren't displayed on the page; only including ones that are sometimes empty (since there's always a location, etc)
+        # ZS: list of booleans representing which columns are entirely empty, so they aren't displayed on the page; only including ones that are sometimes empty (since there's always a location, etc)
         self.empty_columns = {
             "snp_source": "false",
             "conservation_score": "false",
@@ -389,8 +389,8 @@ class SnpBrowser:
                     snp_name = rs
                 else:
                     rs = ""
-                    start_bp = int(mb*1000000 - 100)
-                    end_bp = int(mb*1000000 + 100)
+                    start_bp = int(mb * 1000000 - 100)
+                    end_bp = int(mb * 1000000 + 100)
                     position_info = "chr%s:%d-%d" % (chr, start_bp, end_bp)
                     if self.species_id == 2:
                         snp_url = webqtlConfig.GENOMEBROWSER_URL % ("rn6", position_info)
@@ -434,7 +434,7 @@ class SnpBrowser:
                     transcript_link = ""
 
                 if exon:
-                    exon = exon[1] # exon[0] is exon_id, exon[1] is exon_rank
+                    exon = exon[1]  # exon[0] is exon_id, exon[1] is exon_rank
                     self.empty_columns['exon'] = "true"
                 else:
                     exon = ""
@@ -575,7 +575,7 @@ class SnpBrowser:
         if conservation_score:
             score_as_float = float(conservation_score)
             try:
-                input_score_float = float(self.score) # the user-input score
+                input_score_float = float(self.score)  # the user-input score
             except:
                 input_score_float = 0.0
 
@@ -628,17 +628,17 @@ class SnpBrowser:
         left_offset, right_offset, top_offset, bottom_offset = (30, 30, 40, 50)
         plot_width = canvas_width - left_offset - right_offset
         plot_height = canvas_height - top_offset - bottom_offset
-        y_zero = top_offset + plot_height/2
+        y_zero = top_offset + plot_height / 2
 
-        x_scale = plot_width/(self.end_mb - self.start_mb)
+        x_scale = plot_width / (self.end_mb - self.start_mb)
 
-        #draw clickable image map at some point
+        # draw clickable image map at some point
 
         n_click = 80.0
-        click_step = plot_width/n_click
-        click_mb_step = (self.end_mb - self.start_mb)/n_click
+        click_step = plot_width / n_click
+        click_mb_step = (self.end_mb - self.start_mb) / n_click
 
-        #for i in range(n_click):
+        # for i in range(n_click):
         #    href = url_for('snp_browser', first_run="false", chosen_strains_mouse=self.chosen_strains_mouse, chosen_strains_rat=self.chosen_strains_rat, variant=self.variant_type, species=self.species_name, gene_name=self.gene_name, chr=self.chr, start_mb=self.start_mb, end_mb=self.end_mb, limit_strains=self.limit_strains, domain=self.domain, function=self.function, criteria=self.criteria, score=self.score, diff_alleles=self.diff_alleles)
 
 def get_browser_sample_lists(species_id=1):
@@ -660,7 +660,7 @@ def get_browser_sample_lists(species_id=1):
 
     return strain_lists
 
-def get_header_list(variant_type, strains, species = None, empty_columns = None):
+def get_header_list(variant_type, strains, species=None, empty_columns=None):
     if species == "Mouse":
         strain_list = strains['mouse']
     elif species == "Rat":
@@ -668,7 +668,7 @@ def get_header_list(variant_type, strains, species = None, empty_columns = None)
     else:
         strain_list = strains
 
-    empty_field_count = 0 #ZS: This is an awkward way of letting the javascript know the index where the allele value columns start; there's probably a better way of doing this
+    empty_field_count = 0  # ZS: This is an awkward way of letting the javascript know the index where the allele value columns start; there's probably a better way of doing this
 
     header_fields = []
     header_data_names = []
@@ -715,7 +715,7 @@ def get_header_list(variant_type, strains, species = None, empty_columns = None)
 
     return header_fields, empty_field_count, header_data_names
 
-def get_effect_details_by_category(effect_name = None, effect_value = None):
+def get_effect_details_by_category(effect_name=None, effect_value=None):
     gene_list = []
     transcript_list = []
     exon_list = []
@@ -878,7 +878,7 @@ def get_gene_id_name_dict(species_id, gene_name_list):
     return gene_id_name_dict
 
 def check_if_in_gene(species_id, chr, mb):
-    if species_id != 0: #ZS: Check if this is necessary
+    if species_id != 0:  # ZS: Check if this is necessary
         query = """SELECT geneId, geneSymbol
                    FROM GeneList
                    WHERE SpeciesId = {0} AND chromosome = '{1}' AND
diff --git a/wqflask/wqflask/submit_bnw.py b/wqflask/wqflask/submit_bnw.py
index a0e84c8c..4ad6f9e3 100644
--- a/wqflask/wqflask/submit_bnw.py
+++ b/wqflask/wqflask/submit_bnw.py
@@ -3,7 +3,7 @@ from base import data_set
 from utility import helper_functions
 
 import utility.logger
-logger = utility.logger.getLogger(__name__ )
+logger = utility.logger.getLogger(__name__)
 
 def get_bnw_input(start_vars):
     logger.debug("BNW VARS:", start_vars)
diff --git a/wqflask/wqflask/update_search_results.py b/wqflask/wqflask/update_search_results.py
index 22a46ef2..08b4f9f5 100644
--- a/wqflask/wqflask/update_search_results.py
+++ b/wqflask/wqflask/update_search_results.py
@@ -53,7 +53,7 @@ class GSearch:
                 for line in re:
                     dataset = create_dataset(line[3], "ProbeSet", get_samplelist=False)
                     trait_id = line[4]
-                    #with Bench("Building trait object"):
+                    # with Bench("Building trait object"):
                     this_trait = GeneralTrait(dataset=dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
                     self.trait_list.append(this_trait)
 
@@ -108,8 +108,8 @@ class GSearch:
         json_dict['data'] = []
 
         for i, trait in enumerate(self.trait_list):
-            trait_row = { "checkbox": "<INPUT TYPE=\"checkbox\" NAME=\"searchResult\" class=\"checkbox trait_checkbox\" style=\"transform: scale(1.5);\" VALUE=\"{}:{}\">".format(trait.name, trait.dataset.name),
-                         "index": i+1,
+            trait_row = {"checkbox": "<INPUT TYPE=\"checkbox\" NAME=\"searchResult\" class=\"checkbox trait_checkbox\" style=\"transform: scale(1.5);\" VALUE=\"{}:{}\">".format(trait.name, trait.dataset.name),
+                         "index": i + 1,
                          "species": trait.dataset.group.species,
                          "group": trait.dataset.group.name,
                          "tissue": trait.dataset.tissue,
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index b6e7973f..3f5b43ee 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -33,9 +33,9 @@ def timestamp():
     return datetime.datetime.utcnow().isoformat()
 
 def basic_info():
-    return dict(timestamp = timestamp(),
-                ip_address = request.remote_addr,
-                user_agent = request.headers.get('User-Agent'))
+    return dict(timestamp=timestamp(),
+                ip_address=request.remote_addr,
+                user_agent=request.headers.get('User-Agent'))
 
 
 def encode_password(pass_gen_fields, unencrypted_password):
@@ -77,31 +77,31 @@ def get_signed_session_id(user):
     session_id_signature = hmac.hmac_creation(session_id)
     session_id_signed = session_id + ":" + session_id_signature
 
-    #ZS: Need to check if this is ever actually used or exists
+    # ZS: Need to check if this is ever actually used or exists
     if 'user_id' not in user:
         user['user_id'] = str(uuid.uuid4())
         save_user(user, user['user_id'])
 
     if 'github_id' in user:
-        session = dict(login_time = time.time(),
-                    user_type = "github",
-                    user_id = user['user_id'],
-                    github_id = user['github_id'],
-                    user_name = user['name'],
-                    user_url = user['user_url'])
+        session = dict(login_time=time.time(),
+                    user_type="github",
+                    user_id=user['user_id'],
+                    github_id=user['github_id'],
+                    user_name=user['name'],
+                    user_url=user['user_url'])
     elif 'orcid' in user:
-        session = dict(login_time = time.time(),
-                    user_type = "orcid",
-                    user_id = user['user_id'],
-                    github_id = user['orcid'],
-                    user_name = user['name'],
-                    user_url = user['user_url'])
+        session = dict(login_time=time.time(),
+                    user_type="orcid",
+                    user_id=user['user_id'],
+                    github_id=user['orcid'],
+                    user_name=user['name'],
+                    user_url=user['user_url'])
     else:
-        session = dict(login_time = time.time(),
-                       user_type = "gn2",
-                       user_id = user['user_id'],
-                       user_name = user['full_name'],
-                       user_email_address = user['email_address'])
+        session = dict(login_time=time.time(),
+                       user_type="gn2",
+                       user_id=user['user_id'],
+                       user_name=user['full_name'],
+                       user_email_address=user['email_address'])
 
     key = UserSession.user_cookie_name + ":" + session_id
     Redis.hmset(key, session)
@@ -123,23 +123,23 @@ def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
         server.login(SMTP_USERNAME, SMTP_PASSWORD)
         server.sendmail(fromaddr, toaddr, msg)
         server.quit()
-    logger.info("Successfully sent email to "+toaddr)
+    logger.info("Successfully sent email to " + toaddr)
 
-def send_verification_email(user_details, template_name = "email/user_verification.txt", key_prefix = "verification_code", subject = "GeneNetwork e-mail verification"):
+def send_verification_email(user_details, template_name="email/user_verification.txt", key_prefix="verification_code", subject = "GeneNetwork e-mail verification"):
     verification_code = str(uuid.uuid4())
     key = key_prefix + ":" + verification_code
 
-    data = json.dumps(dict(id=user_details['user_id'], timestamp = timestamp()))
+    data = json.dumps(dict(id=user_details['user_id'], timestamp=timestamp()))
 
     Redis.set(key, data)
     Redis.expire(key, THREE_DAYS)
 
     recipient = user_details['email_address']
-    body = render_template(template_name, verification_code = verification_code)
+    body = render_template(template_name, verification_code=verification_code)
     send_email(recipient, subject, body)
     return {"recipient": recipient, "subject": subject, "body": body}
 
-def send_invitation_email(user_email, temp_password, template_name = "email/user_invitation.txt",  subject = "You've been added to a GeneNetwork user group"):
+def send_invitation_email(user_email, temp_password, template_name="email/user_invitation.txt", subject= "You've been added to a GeneNetwork user group"):
     recipient = user_email
     body = render_template(template_name, temp_password)
     send_email(recipient, subject, body)
@@ -154,7 +154,7 @@ def verify_email():
             # We might as well log them in
             session_id_signed = get_signed_session_id(user_details)
             flash("Thank you for logging in {}.".format(user_details['full_name']), "alert-success")
-            response = make_response(redirect(url_for('index_page', import_collections = import_col, anon_id = anon_id)))
+            response = make_response(redirect(url_for('index_page', import_collections=import_col, anon_id=anon_id)))
             response.set_cookie(UserSession.user_cookie_name, session_id_signed, max_age=None)
             return response
         else:
@@ -165,15 +165,15 @@ def login():
     params = request.form if request.form else request.args
     logger.debug("in login params are:", params)
 
-    if not params: #ZS: If coming to page for first time
+    if not params:  # ZS: If coming to page for first time
         from utility.tools import GITHUB_AUTH_URL, GITHUB_CLIENT_ID, ORCID_AUTH_URL, ORCID_CLIENT_ID
         external_login = {}
         if GITHUB_AUTH_URL and GITHUB_CLIENT_ID != 'UNKNOWN':
             external_login["github"] = GITHUB_AUTH_URL
         if ORCID_AUTH_URL and ORCID_CLIENT_ID != 'UNKNOWN':
             external_login["orcid"] = ORCID_AUTH_URL
-        return render_template("new_security/login_user.html", external_login = external_login, redis_is_available=is_redis_available())
-    else: #ZS: After clicking sign-in
+        return render_template("new_security/login_user.html", external_login=external_login, redis_is_available=is_redis_available())
+    else:  # ZS: After clicking sign-in
         if 'type' in params and 'uid' in params:
             user_details = get_user_by_unique_column("user_id", params['uid'])
             if user_details:
@@ -204,13 +204,13 @@ def login():
                 encrypted_pass_fields = encode_password(pwfields, submitted_password)
                 password_match = pbkdf2.safe_str_cmp(encrypted_pass_fields['password'], pwfields['password'])
 
-            else: # Invalid e-mail
+            else:  # Invalid e-mail
                 flash("Invalid e-mail address. Please try again.", "alert-danger")
                 response = make_response(redirect(url_for('login')))
 
                 return response
-            if password_match: # If password correct
-                if user_details['confirmed']: # If account confirmed
+            if password_match:  # If password correct
+                if user_details['confirmed']:  # If account confirmed
                     import_col = "false"
                     anon_id = ""
                     if 'import_collections' in params:
@@ -219,14 +219,14 @@ def login():
 
                     session_id_signed = get_signed_session_id(user_details)
                     flash("Thank you for logging in {}.".format(user_details['full_name']), "alert-success")
-                    response = make_response(redirect(url_for('index_page', import_collections = import_col, anon_id = anon_id)))
+                    response = make_response(redirect(url_for('index_page', import_collections=import_col, anon_id=anon_id)))
                     response.set_cookie(UserSession.user_cookie_name, session_id_signed, max_age=None)
                     return response
                 else:
-                    email_ob = send_verification_email(user_details, template_name = "email/user_verification.txt")
+                    email_ob = send_verification_email(user_details, template_name="email/user_verification.txt")
                     return render_template("newsecurity/verification_still_needed.html", subject=email_ob['subject'])
-            else: # Incorrect password
-                #ZS: It previously seemed to store that there was an incorrect log-in attempt here, but it did so in the MySQL DB so this might need to be reproduced with Redis
+            else:  # Incorrect password
+                # ZS: It previously seemed to store that there was an incorrect log-in attempt here, but it did so in the MySQL DB so this might need to be reproduced with Redis
                 flash("Invalid password. Please try again.", "alert-danger")
                 response = make_response(redirect(url_for('login')))
 
@@ -243,7 +243,7 @@ def github_oauth2():
     }
 
     result = requests.post("https://github.com/login/oauth/access_token", json=data)
-    result_dict = {arr[0]:arr[1] for arr in [tok.split("=") for tok in result.text.split("&")]}
+    result_dict = {arr[0]: arr[1] for arr in [tok.split("=") for tok in result.text.split("&")]}
 
     github_user = get_github_user_details(result_dict["access_token"])
 
@@ -261,12 +261,12 @@ def github_oauth2():
         }
         save_user(user_details, user_details["user_id"])
 
-    url = "/n/login?type=github&uid="+user_details["user_id"]
+    url = "/n/login?type=github&uid=" + user_details["user_id"]
     return redirect(url)
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, headers = {'Authorization':'token ' + access_token }).content
+    result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
 
     return json.loads(result)
 
@@ -303,14 +303,14 @@ def orcid_oauth2():
             }
             save_user(user_details, user_details["user_id"])
 
-        url = "/n/login?type=orcid&uid="+user_details["user_id"]
+        url = "/n/login?type=orcid&uid=" + user_details["user_id"]
     else:
         flash("There was an error getting code from ORCID")
     return redirect(url)
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, headers = {'Authorization':'token ' + access_token }).content
+    result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
 
     return json.loads(result)
 
@@ -337,7 +337,7 @@ def send_forgot_password_email(verification_email):
     from email.mime.multipart import MIMEMultipart
     from email.mime.text import MIMEText
 
-    template_name  = "email/forgot_password.txt"
+    template_name = "email/forgot_password.txt"
     key_prefix = "forgot_password_code"
     subject = "GeneNetwork password reset"
     fromaddr = "no-reply@genenetwork.org"
@@ -353,7 +353,7 @@ def send_forgot_password_email(verification_email):
 
     save_verification_code(verification_email, verification_code)
 
-    body = render_template(template_name, verification_code = verification_code)
+    body = render_template(template_name, verification_code=verification_code)
 
     msg = MIMEMultipart()
     msg["To"] = verification_email
diff --git a/wqflask/wqflask/user_manager.py b/wqflask/wqflask/user_manager.py
index fcec3b67..013920f9 100644
--- a/wqflask/wqflask/user_manager.py
+++ b/wqflask/wqflask/user_manager.py
@@ -74,11 +74,11 @@ class AnonUser:
         self.key = "anon_collection:v1:{}".format(self.anon_id)
 
     def add_collection(self, new_collection):
-        collection_dict = dict(name = new_collection.name,
-                               created_timestamp = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
-                               changed_timestamp = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
-                               num_members = new_collection.num_members,
-                               members = new_collection.get_members())
+        collection_dict = dict(name=new_collection.name,
+                               created_timestamp=datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
+                               changed_timestamp=datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
+                               num_members=new_collection.num_members,
+                               members=new_collection.get_members())
 
         Redis.set(self.key, json.dumps(collection_dict))
         Redis.expire(self.key, 60 * 60 * 24 * 365)
@@ -111,7 +111,7 @@ class AnonUser:
                 collection['created_timestamp'] = datetime.datetime.strptime(collection['created_timestamp'], '%b %d %Y %I:%M%p')
                 collection['changed_timestamp'] = datetime.datetime.strptime(collection['changed_timestamp'], '%b %d %Y %I:%M%p')
 
-            collections = sorted(collections, key = lambda i: i['changed_timestamp'], reverse = True)
+            collections = sorted(collections, key=lambda i: i['changed_timestamp'], reverse=True)
             return collections
 
     def import_traits_to_user(self):
@@ -182,13 +182,13 @@ class UserSession:
                 # weekend and the site hasn't been visited by the user
                 self.logged_in = False
 
-                ########### Grrr...this won't work because of the way flask handles cookies
+                # Grrr...this won't work because of the way flask handles cookies
                 # Delete the cookie
                 #response = make_response(redirect(url_for('login')))
                 #response.set_cookie(self.cookie_name, '', expires=0)
-                #flash(
+                # flash(
                 #   "Due to inactivity your session has expired. If you'd like please login again.")
-                #return response
+                # return response
                 return
 
             if Redis.ttl(self.redis_key) < THREE_DAYS:
@@ -213,7 +213,7 @@ class UserSession:
 
         user_email = self.record['user_email_address']
 
-        #ZS: Get user's collections if they exist
+        # ZS: Get user's collections if they exist
         user_id = None
         user_id = get_user_id("email_address", user_email)
         return user_id
@@ -230,7 +230,7 @@ class UserSession:
     def user_collections(self):
         """List of user's collections"""
 
-        #ZS: Get user's collections if they exist
+        # ZS: Get user's collections if they exist
         collections = get_user_collections(self.redis_user_id)
         return collections
 
@@ -248,7 +248,7 @@ class UserSession:
                            'created_timestamp': datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
                            'changed_timestamp': datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
                            'num_members': len(traits),
-                           'members': list(traits) }
+                           'members': list(traits)}
 
         current_collections = self.user_collections
         current_collections.append(collection_dict)
@@ -347,7 +347,7 @@ def get_cookie():
     g.user_session = UserSession()
     g.cookie_session = AnonUser()
 
-#@app.after_request
+# @app.after_request
 def set_cookie(response):
     if not request.cookies.get(g.cookie_session.cookie_name):
         response.set_cookie(g.cookie_session.cookie_name, g.cookie_session.cookie)
@@ -455,7 +455,7 @@ def set_password(password, user):
 
 
 class VerificationEmail:
-    template_name =  "email/verification.txt"
+    template_name = "email/verification.txt"
     key_prefix = "verification_code"
     subject = "GeneNetwork email verification"
 
@@ -473,7 +473,7 @@ class VerificationEmail:
         to = user.email_address
         subject = self.subject
         body = render_template(self.template_name,
-                               verification_code = verification_code)
+                               verification_code=verification_code)
         send_email(to, subject, body)
 
 class ForgotPasswordEmail(VerificationEmail):
@@ -500,7 +500,7 @@ class ForgotPasswordEmail(VerificationEmail):
         subject = self.subject
         body = render_template(
             self.template_name,
-            verification_code = verification_code)
+            verification_code=verification_code)
 
         msg = MIMEMultipart()
         msg["To"] = toaddr
@@ -525,11 +525,11 @@ class Password:
 
 
 def basic_info():
-    return dict(timestamp = timestamp(),
-                ip_address = request.remote_addr,
-                user_agent = request.headers.get('User-Agent'))
+    return dict(timestamp=timestamp(),
+                ip_address=request.remote_addr,
+                user_agent=request.headers.get('User-Agent'))
 
-#@app.route("/manage/verify_email")
+# @app.route("/manage/verify_email")
 def verify_email():
     user = DecodeUser(VerificationEmail.key_prefix).user
     user.confirmed = json.dumps(basic_info(), sort_keys=True)
@@ -543,7 +543,7 @@ def verify_email():
     response.set_cookie(UserSession.cookie_name, session_id_signed)
     return response
 
-#@app.route("/n/password_reset", methods=['GET'])
+# @app.route("/n/password_reset", methods=['GET'])
 def password_reset():
     """Entry point after user clicks link in E-mail"""
     logger.debug("in password_reset request.url is:", request.url)
@@ -567,7 +567,7 @@ def password_reset():
     else:
         return redirect(url_for("login"))
 
-#@app.route("/n/password_reset_step2", methods=('POST',))
+# @app.route("/n/password_reset_step2", methods=('POST',))
 def password_reset_step2():
     """Handle confirmation E-mail for password reset"""
     logger.debug("in password_reset request.url is:", request.url)
@@ -611,7 +611,7 @@ class DecodeUser:
         logger.debug("data is:", data)
         return model.User.query.get(data['id'])
 
-#@app.route("/n/login", methods=('GET', 'POST'))
+# @app.route("/n/login", methods=('GET', 'POST'))
 def login():
     lu = LoginUser()
     login_type = request.args.get("type")
@@ -621,7 +621,7 @@ def login():
     else:
         return lu.standard_login()
 
-#@app.route("/n/login/github_oauth2", methods=('GET', 'POST'))
+# @app.route("/n/login/github_oauth2", methods=('GET', 'POST'))
 def github_oauth2():
     from utility.tools import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET
     code = request.args.get("code")
@@ -631,28 +631,21 @@ def github_oauth2():
         "code": code
     }
     result = requests.post("https://github.com/login/oauth/access_token", json=data)
-    result_dict = {arr[0]:arr[1] for arr in [tok.split("=") for tok in [token.encode("utf-8") for token in result.text.split("&")]]}
+    result_dict = {arr[0]: arr[1] for arr in [tok.split("=") for tok in [token.encode("utf-8") for token in result.text.split("&")]]}
 
     github_user = get_github_user_details(result_dict["access_token"])
 
     user_details = get_user_by_unique_column("github_id", github_user["id"])
     if user_details == None:
         user_details = {
-            "user_id": str(uuid.uuid4())
-            , "name": github_user["name"].encode("utf-8")
-            , "github_id": github_user["id"]
-            , "user_url": github_user["html_url"].encode("utf-8")
-            , "login_type": "github"
-            , "organization": ""
-            , "active": 1
-            , "confirmed": 1
+            "user_id": str(uuid.uuid4()), "name": github_user["name"].encode("utf-8"), "github_id": github_user["id"], "user_url": github_user["html_url"].encode("utf-8")            , "login_type": "github"            , "organization": ""            , "active": 1            , "confirmed": 1
         }
         save_user(user_details, user_details["user_id"])
 
-    url = "/n/login?type=github&uid="+user_details["user_id"]
+    url = "/n/login?type=github&uid=" + user_details["user_id"]
     return redirect(url)
 
-#@app.route("/n/login/orcid_oauth2", methods=('GET', 'POST'))
+# @app.route("/n/login/orcid_oauth2", methods=('GET', 'POST'))
 def orcid_oauth2():
     from uuid import uuid4
     from utility.tools import ORCID_CLIENT_ID, ORCID_CLIENT_SECRET, ORCID_TOKEN_URL, ORCID_AUTH_URL
@@ -661,10 +654,7 @@ def orcid_oauth2():
     url = "/n/login"
     if code:
         data = {
-            "client_id": ORCID_CLIENT_ID
-            , "client_secret": ORCID_CLIENT_SECRET
-            , "grant_type": "authorization_code"
-            , "code": code
+            "client_id": ORCID_CLIENT_ID, "client_secret": ORCID_CLIENT_SECRET, "grant_type": "authorization_code", "code": code
         }
         result = requests.post(ORCID_TOKEN_URL, data=data)
         result_dict = json.loads(result.text.encode("utf-8"))
@@ -672,31 +662,24 @@ def orcid_oauth2():
         user_details = get_user_by_unique_column("orcid", result_dict["orcid"])
         if user_details == None:
             user_details = {
-                "user_id": str(uuid4())
-                , "name": result_dict["name"]
-                , "orcid": result_dict["orcid"]
-                , "user_url": "%s/%s" % (
+                "user_id": str(uuid4()), "name": result_dict["name"], "orcid": result_dict["orcid"], "user_url": "%s/%s" % (
                     "/".join(ORCID_AUTH_URL.split("/")[:-2]),
-                    result_dict["orcid"])
-                , "login_type": "orcid"
-                , "organization": ""
-                , "active": 1
-                , "confirmed": 1
+                    result_dict["orcid"]), "login_type": "orcid", "organization": "", "active": 1                , "confirmed": 1
             }
             save_user(user_details, user_details["user_id"])
 
-        url = "/n/login?type=orcid&uid="+user_details["user_id"]
+        url = "/n/login?type=orcid&uid=" + user_details["user_id"]
     else:
         flash("There was an error getting code from ORCID")
     return redirect(url)
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, params={"access_token":access_token})
+    result = requests.get(GITHUB_API_URL, params={"access_token": access_token})
     return result.json()
 
 class LoginUser:
-    remember_time = 60 * 60 * 24 * 30 # One month in seconds
+    remember_time = 60 * 60 * 24 * 30  # One month in seconds
 
     def __init__(self):
         self.remember_me = False
@@ -730,9 +713,7 @@ class LoginUser:
                 external_login["orcid"] = ORCID_AUTH_URL
 
             return render_template(
-                "new_security/login_user.html"
-                , external_login=external_login
-                , redis_is_available = is_redis_available())
+                "new_security/login_user.html", external_login=external_login, redis_is_available=is_redis_available())
         else:
             user_details = get_user_by_unique_column("email_address", params["email_address"])
             #user_details = get_user_by_unique_column(es, "email_address", params["email_address"])
@@ -770,7 +751,7 @@ class LoginUser:
             else:
                 import_col = "false"
 
-            #g.cookie_session.import_traits_to_user()
+            # g.cookie_session.import_traits_to_user()
 
             self.logged_in = True
 
@@ -810,10 +791,10 @@ class LoginUser:
         if not user.id:
             user.id = ''
 
-        session = dict(login_time = time.time(),
-                       user_id = user.id,
-                       user_name = user.full_name,
-                       user_email_address = user.email_address)
+        session = dict(login_time=time.time(),
+                       user_id=user.id,
+                       user_name=user.full_name,
+                       user_email_address=user.email_address)
 
         key = UserSession.cookie_name + ":" + login_rec.session_id
         logger.debug("Key when signing:", key)
@@ -832,7 +813,7 @@ class LoginUser:
         db_session.add(login_rec)
         db_session.commit()
 
-#@app.route("/n/logout")
+# @app.route("/n/logout")
 def logout():
     logger.debug("Logging out...")
     UserSession().delete_session()
@@ -843,7 +824,7 @@ def logout():
     return response
 
 
-#@app.route("/n/forgot_password", methods=['GET'])
+# @app.route("/n/forgot_password", methods=['GET'])
 def forgot_password():
     """Entry point for forgotten password"""
     print("ARGS: ", request.args)
@@ -851,7 +832,7 @@ def forgot_password():
     print("ERRORS: ", errors)
     return render_template("new_security/forgot_password.html", errors=errors)
 
-#@app.route("/n/forgot_password_submit", methods=('POST',))
+# @app.route("/n/forgot_password_submit", methods=('POST',))
 def forgot_password_submit():
     """When a forgotten password form is submitted we get here"""
     params = request.form
@@ -886,7 +867,7 @@ def is_redis_available():
 ###
 # ZS: The following 6 functions require the old MySQL User accounts; I'm leaving them commented out just in case we decide to reimplement them using ElasticSearch
 ###
-#def super_only():
+# def super_only():
 #    try:
 #        superuser = g.user_session.user_ob.superuser
 #    except AttributeError:
@@ -895,26 +876,26 @@ def is_redis_available():
 #        flash("You must be a superuser to access that page.", "alert-error")
 #        abort(401)
 
-#@app.route("/manage/users")
-#def manage_users():
+# @app.route("/manage/users")
+# def manage_users():
 #    super_only()
 #    template_vars = UsersManager()
 #    return render_template("admin/user_manager.html", **template_vars.__dict__)
 
-#@app.route("/manage/user")
-#def manage_user():
+# @app.route("/manage/user")
+# def manage_user():
 #    super_only()
 #    template_vars = UserManager(request.args)
 #    return render_template("admin/ind_user_manager.html", **template_vars.__dict__)
 
-#@app.route("/manage/groups")
-#def manage_groups():
+# @app.route("/manage/groups")
+# def manage_groups():
 #    super_only()
 #    template_vars = GroupsManager(request.args)
 #    return render_template("admin/group_manager.html", **template_vars.__dict__)
 
-#@app.route("/manage/make_superuser")
-#def make_superuser():
+# @app.route("/manage/make_superuser")
+# def make_superuser():
 #    super_only()
 #    params = request.args
 #    user_id = params['user_id']
@@ -926,8 +907,8 @@ def is_redis_available():
 #    flash("We've made {} a superuser!".format(user.name_and_org))
 #    return redirect(url_for("manage_users"))
 
-#@app.route("/manage/assume_identity")
-#def assume_identity():
+# @app.route("/manage/assume_identity")
+# def assume_identity():
 #    super_only()
 #    params = request.args
 #    user_id = params['user_id']
@@ -936,7 +917,7 @@ def is_redis_available():
 #    return LoginUser().actual_login(user, assumed_by=assumed_by)
 
 
-#@app.route("/n/register", methods=('GET', 'POST'))
+# @app.route("/n/register", methods=('GET', 'POST'))
 def register():
     params = None
     errors = None
@@ -1023,21 +1004,21 @@ def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
 
     """
     if SMTP_USERNAME == 'UNKNOWN':
-        logger.debug("SMTP: connecting with host "+SMTP_CONNECT)
+        logger.debug("SMTP: connecting with host " + SMTP_CONNECT)
         server = SMTP(SMTP_CONNECT)
         server.sendmail(fromaddr, toaddr, msg)
     else:
-        logger.debug("SMTP: connecting TLS with host "+SMTP_CONNECT)
+        logger.debug("SMTP: connecting TLS with host " + SMTP_CONNECT)
         server = SMTP(SMTP_CONNECT)
         server.starttls()
-        logger.debug("SMTP: login with user "+SMTP_USERNAME)
+        logger.debug("SMTP: login with user " + SMTP_USERNAME)
         server.login(SMTP_USERNAME, SMTP_PASSWORD)
-        logger.debug("SMTP: "+fromaddr)
-        logger.debug("SMTP: "+toaddr)
-        logger.debug("SMTP: "+msg)
+        logger.debug("SMTP: " + fromaddr)
+        logger.debug("SMTP: " + toaddr)
+        logger.debug("SMTP: " + msg)
         server.sendmail(fromaddr, toaddr, msg)
         server.quit()
-    logger.info("Successfully sent email to "+toaddr)
+    logger.info("Successfully sent email to " + toaddr)
 
 class GroupsManager:
     def __init__(self, kw):
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index cc0ac744..78db7bd2 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -24,7 +24,7 @@ THIRTY_DAYS = 60 * 60 * 24 * 30
 def get_user_session():
     logger.info("@app.before_request get_session")
     g.user_session = UserSession()
-    #ZS: I think this should solve the issue of deleting the cookie and redirecting to the home page when a user's session has expired
+    # ZS: I think this should solve the issue of deleting the cookie and redirecting to the home page when a user's session has expired
     if not g.user_session:
         response = make_response(redirect(url_for('login')))
         response.set_cookie('session_id_v2', '', expires=0)
@@ -51,7 +51,7 @@ def create_signed_cookie():
     logger.debug("uuid_signed:", uuid_signed)
     return the_uuid, uuid_signed
 
-@app.route("/user/manage", methods=('GET','POST'))
+@app.route("/user/manage", methods=('GET', 'POST'))
 def manage_user():
     params = request.form if request.form else request.args
     if 'new_full_name' in params:
@@ -61,7 +61,7 @@ def manage_user():
 
     user_details = get_user_by_unique_column("user_id", g.user_session.user_id)
 
-    return render_template("admin/manage_user.html", user_details = user_details)
+    return render_template("admin/manage_user.html", user_details=user_details)
 
 class UserSession:
     """Logged in user handling"""
@@ -89,25 +89,25 @@ class UserSession:
         self.session_id = session_id
         self.record = Redis.hgetall(self.redis_key)
 
-        #ZS: If user correctled logged in but their session expired
-        #ZS: Need to test this by setting the time-out to be really short or something
+        # ZS: If user correctled logged in but their session expired
+        # ZS: Need to test this by setting the time-out to be really short or something
         if not self.record or self.record == []:
             if user_cookie:
                 self.logged_in = False
-                self.record = dict(login_time = time.time(),
-                                    user_type = "anon",
-                                    user_id = str(uuid.uuid4()))
+                self.record = dict(login_time=time.time(),
+                                    user_type="anon",
+                                    user_id=str(uuid.uuid4()))
                 Redis.hmset(self.redis_key, self.record)
                 Redis.expire(self.redis_key, THIRTY_DAYS)
 
-                ########### Grrr...this won't work because of the way flask handles cookies
+                # Grrr...this won't work because of the way flask handles cookies
                 # Delete the cookie
                 flash("Due to inactivity your session has expired. If you'd like please login again.")
                 return None
             else:
-                self.record = dict(login_time = time.time(),
-                                    user_type = "anon",
-                                    user_id = str(uuid.uuid4()))
+                self.record = dict(login_time=time.time(),
+                                    user_type="anon",
+                                    user_id=str(uuid.uuid4()))
                 Redis.hmset(self.redis_key, self.record)
                 Redis.expire(self.redis_key, THIRTY_DAYS)
         else:
@@ -138,13 +138,13 @@ class UserSession:
     def redis_user_id(self):
         """User id from Redis (need to check if this is the same as the id stored in self.records)"""
 
-        #ZS: This part is a bit weird. Some accounts used to not have saved user ids, and in the process of testing I think I created some duplicate accounts for myself.
-        #ZS: Accounts should automatically generate user_ids if they don't already have one now, so this might not be necessary for anything other than my account's collections
+        # ZS: This part is a bit weird. Some accounts used to not have saved user ids, and in the process of testing I think I created some duplicate accounts for myself.
+        # ZS: Accounts should automatically generate user_ids if they don't already have one now, so this might not be necessary for anything other than my account's collections
 
         if 'user_email_address' in self.record:
             user_email = self.record['user_email_address']
 
-            #ZS: Get user's collections if they exist
+            # ZS: Get user's collections if they exist
             user_id = None
             user_id = get_user_id("email_address", user_email)
         elif 'user_id' in self.record:
@@ -153,7 +153,7 @@ class UserSession:
             user_github_id = self.record['github_id']
             user_id = None
             user_id = get_user_id("github_id", user_github_id)
-        else: #ZS: Anonymous user
+        else:  # ZS: Anonymous user
             return None
 
         return user_id
@@ -170,9 +170,9 @@ class UserSession:
     def user_collections(self):
         """List of user's collections"""
 
-        #ZS: Get user's collections if they exist
+        # ZS: Get user's collections if they exist
         collections = get_user_collections(self.user_id)
-        collections = [item for item in collections if item['name'] != "Your Default Collection"] + [item for item in collections if item['name'] == "Your Default Collection"] #ZS: Ensure Default Collection is last in list
+        collections = [item for item in collections if item['name'] != "Your Default Collection"] + [item for item in collections if item['name'] == "Your Default Collection"]  # ZS: Ensure Default Collection is last in list
         return collections
 
     @property
@@ -189,7 +189,7 @@ class UserSession:
                            'created_timestamp': datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
                            'changed_timestamp': datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
                            'num_members': len(traits),
-                           'members': list(traits) }
+                           'members': list(traits)}
 
         current_collections = self.user_collections
         current_collections.append(collection_dict)
diff --git a/wqflask/wqflask/views.py b/wqflask/wqflask/views.py
index 37f2094f..2c53012a 100644
--- a/wqflask/wqflask/views.py
+++ b/wqflask/wqflask/views.py
@@ -141,7 +141,7 @@ def handle_bad_request(e):
     now = datetime.datetime.utcnow()
     time_str = now.strftime('%l:%M%p UTC %b %d, %Y')
     formatted_lines = [request.url +
-                       " ("+time_str+")"]+traceback.format_exc().splitlines()
+                       " (" + time_str + ")"]+traceback.format_exc().splitlines()
 
     # Handle random animations
     # Use a cookie to have one animation on refresh
@@ -240,7 +240,7 @@ def search_page():
 
     if USE_REDIS and valid_search:
         Redis.set(key, pickle.dumps(result, pickle.HIGHEST_PROTOCOL))
-        Redis.expire(key, 60*60)
+        Redis.expire(key, 60 * 60)
 
     if valid_search:
         return render_template("search_result_page.html", **result)
@@ -601,7 +601,7 @@ def heatmap_page():
             pickled_result = pickle.dumps(result, pickle.HIGHEST_PROTOCOL)
             logger.info("pickled result length:", len(pickled_result))
             Redis.set(key, pickled_result)
-            Redis.expire(key, 60*60)
+            Redis.expire(key, 60 * 60)
 
         with Bench("Rendering template"):
             rendered_template = render_template("heatmap.html", **result)
diff --git a/wqflask/wsgi.py b/wqflask/wsgi.py
index be9c7b37..755da333 100644
--- a/wqflask/wsgi.py
+++ b/wqflask/wsgi.py
@@ -1,4 +1,4 @@
-from run_gunicorn import app as application # expect application as a name
+from run_gunicorn import app as application  # expect application as a name
 
 if __name__ == "__main__":
     application.run()
-- 
cgit v1.2.3


From 406eb27859cca232a562c722cbbd37aca2e3be84 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 12:26:19 +0300
Subject: autopep8: Fix E301,E302,E303,E304,E305,E306

---
 etc/default_settings.py                            | 21 +++----
 wqflask/base/data_set.py                           |  1 -
 wqflask/base/mrna_assay_tissue_data.py             |  1 +
 wqflask/base/species.py                            |  3 +
 wqflask/base/webqtlCaseData.py                     |  3 +-
 wqflask/db/call.py                                 |  4 ++
 wqflask/db/gn_server.py                            |  1 +
 wqflask/db/webqtlDatabaseFunction.py               |  1 +
 wqflask/maintenance/convert_dryad_to_bimbam.py     |  3 +
 wqflask/maintenance/convert_geno_to_bimbam.py      |  4 ++
 wqflask/maintenance/gen_select_dataset.py          |  5 ++
 .../maintenance/generate_kinship_from_bimbam.py    |  1 +
 .../maintenance/generate_probesetfreeze_file.py    |  7 +++
 wqflask/maintenance/geno_to_json.py                |  6 +-
 wqflask/maintenance/get_group_samplelists.py       |  3 +
 wqflask/maintenance/print_benchmark.py             |  4 ++
 wqflask/maintenance/quantile_normalize.py          |  6 ++
 wqflask/maintenance/set_resource_defaults.py       |  7 +++
 wqflask/run_gunicorn.py                            |  2 +
 wqflask/tests/unit/base/test_webqtl_case_data.py   |  1 +
 .../unit/utility/test_authentication_tools.py      |  1 +
 wqflask/tests/unit/utility/test_chunks.py          |  1 +
 .../test_display_mapping_results.py                |  2 +
 .../marker_regression/test_plink_mapping.py        |  3 +-
 .../marker_regression/test_qtlreaper_mapping.py    |  2 +
 .../wqflask/marker_regression/test_rqtl_mapping.py |  2 +-
 wqflask/tests/unit/wqflask/test_collect.py         |  2 +
 .../tests/wqflask/show_trait/test_show_trait.py    |  1 -
 wqflask/utility/Plot.py                            | 13 +++++
 wqflask/utility/__init__.py                        |  2 +
 wqflask/utility/after.py                           |  1 +
 wqflask/utility/authentication_tools.py            |  1 +
 wqflask/utility/benchmark.py                       |  1 +
 wqflask/utility/corestats.py                       |  2 +
 wqflask/utility/elasticsearch_tools.py             |  7 +++
 wqflask/utility/external.py                        |  1 +
 wqflask/utility/gen_geno_ob.py                     |  3 +
 wqflask/utility/genofile_parser.py                 |  1 +
 wqflask/utility/logger.py                          |  3 +
 wqflask/utility/pillow_utils.py                    |  4 ++
 wqflask/utility/startup_config.py                  |  1 +
 wqflask/utility/svg.py                             | 67 +++++++++++++++++++++-
 wqflask/utility/temp_data.py                       |  1 +
 wqflask/utility/tools.py                           | 25 ++++++++
 wqflask/utility/type_checking.py                   |  5 ++
 wqflask/utility/webqtlUtil.py                      |  5 ++
 wqflask/wqflask/__init__.py                        |  1 +
 wqflask/wqflask/api/correlation.py                 |  7 +++
 wqflask/wqflask/api/mapping.py                     |  2 +-
 wqflask/wqflask/api/router.py                      | 20 +++++++
 wqflask/wqflask/collect.py                         |  8 +++
 wqflask/wqflask/correlation/corr_scatter_plot.py   |  1 +
 wqflask/wqflask/correlation/show_corr_results.py   |  4 +-
 .../wqflask/correlation_matrix/show_corr_matrix.py |  3 +
 wqflask/wqflask/ctl/ctl_analysis.py                |  1 +
 wqflask/wqflask/database.py                        |  2 +
 wqflask/wqflask/db_info.py                         |  1 +
 wqflask/wqflask/do_search.py                       | 21 ++++++-
 wqflask/wqflask/docs.py                            |  2 +-
 wqflask/wqflask/export_traits.py                   |  2 +
 wqflask/wqflask/external_tools/send_to_bnw.py      |  1 +
 .../wqflask/external_tools/send_to_geneweaver.py   |  3 +
 .../wqflask/external_tools/send_to_webgestalt.py   |  3 +
 wqflask/wqflask/group_manager.py                   |  9 +++
 wqflask/wqflask/gsearch.py                         |  1 +
 wqflask/wqflask/heatmap/heatmap.py                 |  3 +
 wqflask/wqflask/interval_analyst/GeneUtil.py       |  2 +
 .../marker_regression/display_mapping_results.py   |  9 ---
 wqflask/wqflask/marker_regression/plink_mapping.py |  9 ++-
 .../wqflask/marker_regression/qtlreaper_mapping.py |  5 ++
 wqflask/wqflask/marker_regression/rqtl_mapping.py  | 15 +++++
 wqflask/wqflask/marker_regression/run_mapping.py   |  9 +++
 wqflask/wqflask/model.py                           |  7 ++-
 wqflask/wqflask/network_graph/network_graph.py     |  1 +
 wqflask/wqflask/news.py                            |  1 +
 wqflask/wqflask/parser.py                          |  1 +
 wqflask/wqflask/pbkdf2.py                          |  2 +
 wqflask/wqflask/resource_manager.py                |  7 +++
 wqflask/wqflask/search_results.py                  |  4 ++
 wqflask/wqflask/send_mail.py                       |  3 +-
 wqflask/wqflask/server_side.py                     |  1 -
 wqflask/wqflask/show_trait/SampleList.py           |  1 +
 wqflask/wqflask/show_trait/export_trait_data.py    |  3 +
 wqflask/wqflask/snp_browser/snp_browser.py         |  9 ++-
 wqflask/wqflask/submit_bnw.py                      |  1 +
 wqflask/wqflask/update_search_results.py           |  1 +
 wqflask/wqflask/user_login.py                      | 21 +++++++
 wqflask/wqflask/user_manager.py                    | 38 +++++++++++-
 wqflask/wqflask/user_session.py                    |  6 ++
 89 files changed, 446 insertions(+), 46 deletions(-)

(limited to 'wqflask/tests')

diff --git a/etc/default_settings.py b/etc/default_settings.py
index 27522187..a194b10e 100644
--- a/etc/default_settings.py
+++ b/etc/default_settings.py
@@ -73,23 +73,24 @@ SMTP_PASSWORD = "UNKNOWN"
 
 # ---- Behavioural settings (defaults) note that logger and log levels can
 #      be overridden at the module level and with enviroment settings
-WEBSERVER_MODE  = 'DEV'     # Python webserver mode (DEBUG|DEV|PROD)
+WEBSERVER_MODE = 'DEV'     # Python webserver mode (DEBUG|DEV|PROD)
 WEBSERVER_BRANDING = None   # Set the branding (nyi)
 WEBSERVER_DEPLOY = None     # Deployment specifics (nyi)
-WEBSERVER_URL    = "http://localhost:"+str(SERVER_PORT)+"/" # external URL
+WEBSERVER_URL = "http://localhost:" + str(SERVER_PORT) + "/" # external URL
 
-LOG_LEVEL       = 'WARNING' # Logger mode (DEBUG|INFO|WARNING|ERROR|CRITICAL)
+LOG_LEVEL = 'WARNING' # Logger mode (DEBUG|INFO|WARNING|ERROR|CRITICAL)
 LOG_LEVEL_DEBUG = '0'       # logger.debugf log level (0-5, 5 = show all)
-LOG_SQL         = 'False'   # Log SQL/backend and GN_SERVER calls
+LOG_SQL = 'False'   # Log SQL/backend and GN_SERVER calls
 LOG_SQL_ALCHEMY = 'False'
-LOG_BENCH       = True      # Log bench marks
+LOG_BENCH = True      # Log bench marks
 
-USE_REDIS       = True      # REDIS caching (note that redis will be phased out)
-USE_GN_SERVER   = 'False'   # Use GN_SERVER SQL calls
-HOME            = os.environ['HOME']
+USE_REDIS = True      # REDIS caching (note that redis will be phased out)
+USE_GN_SERVER = 'False'   # Use GN_SERVER SQL calls
+HOME = os.environ['HOME']
 
 # ---- Default locations
-GENENETWORK_FILES   = HOME+"/genotype_files"  # base dir for all static data files
+# base dir for all static data files
+GENENETWORK_FILES = HOME + "/genotype_files"
 
 # ---- Path overrides for Genenetwork - the defaults are normally
 #      picked up from Guix or in the HOME directory
@@ -98,7 +99,7 @@ GENENETWORK_FILES   = HOME+"/genotype_files"  # base dir for all static data fil
 # PRIVATE_FILES = HOME+"/gn2_private_data" # private static data files (unused)
 
 # ---- Local path to JS libraries - for development modules (only)
-JS_GN_PATH = os.environ['HOME']+"/genenetwork/javascript"
+JS_GN_PATH = os.environ['HOME'] + "/genenetwork/javascript"
 
 # ---- GN2 Executables (overwrite for testing only)
 # PLINK_COMMAND = str.strip(os.popen("which plink2").read())
diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 55ab45f5..c14808d6 100644
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -311,7 +311,6 @@ class HumanMarkers(Markers):
                 marker['Mb'] = float(splat[3]) / 1000000
             self.markers.append(marker)
 
-
     def add_pvalues(self, p_values):
         super(HumanMarkers, self).add_pvalues(p_values)
 
diff --git a/wqflask/base/mrna_assay_tissue_data.py b/wqflask/base/mrna_assay_tissue_data.py
index f3264b3d..cbc05738 100644
--- a/wqflask/base/mrna_assay_tissue_data.py
+++ b/wqflask/base/mrna_assay_tissue_data.py
@@ -11,6 +11,7 @@ from utility.db_tools import escape
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class MrnaAssayTissueData:
 
     def __init__(self, gene_symbols=None):
diff --git a/wqflask/base/species.py b/wqflask/base/species.py
index cf764d72..44f133b5 100644
--- a/wqflask/base/species.py
+++ b/wqflask/base/species.py
@@ -6,6 +6,7 @@ from flask import Flask, g
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class TheSpecies:
     def __init__(self, dataset=None, species_name=None):
         if species_name != None:
@@ -15,6 +16,7 @@ class TheSpecies:
             self.dataset = dataset
             self.chromosomes = Chromosomes(dataset=self.dataset)
 
+
 class IndChromosome:
     def __init__(self, name, length):
         self.name = name
@@ -25,6 +27,7 @@ class IndChromosome:
         """Chromosome length in megabases"""
         return self.length / 1000000
 
+
 class Chromosomes:
     def __init__(self, dataset=None, species=None):
         self.chromosomes = collections.OrderedDict()
diff --git a/wqflask/base/webqtlCaseData.py b/wqflask/base/webqtlCaseData.py
index aa55470f..2d07ab9d 100644
--- a/wqflask/base/webqtlCaseData.py
+++ b/wqflask/base/webqtlCaseData.py
@@ -28,6 +28,7 @@ import utility.tools
 
 utility.tools.show_settings()
 
+
 class webqtlCaseData:
     """one case data in one trait"""
 
@@ -78,4 +79,4 @@ class webqtlCaseData:
     def display_num_cases(self):
         if self.num_cases is not None:
             return "%s" % self.num_cases
-        return "x"
\ No newline at end of file
+        return "x"
diff --git a/wqflask/db/call.py b/wqflask/db/call.py
index 555878ad..9412b376 100644
--- a/wqflask/db/call.py
+++ b/wqflask/db/call.py
@@ -16,6 +16,7 @@ logger = getLogger(__name__)
 
 # from inspect import stack
 
+
 def fetch1(query, path=None, func=None):
     """Fetch one result as a Tuple using either a SQL query or the URI
 path to GN_SERVER (when USE_GN_SERVER is True). Apply func to
@@ -35,6 +36,7 @@ GN_SERVER result when set (which should return a Tuple)
     else:
         return fetchone(query)
 
+
 def fetchone(query):
     """Return tuple containing one row by calling SQL directly (the
 original fetchone, but with logging)
@@ -46,6 +48,7 @@ original fetchone, but with logging)
             return res.fetchone()
         return logger.sql(query, helper)
 
+
 def fetchall(query):
     """Return row iterator by calling SQL directly (the
 original fetchall, but with logging)
@@ -57,6 +60,7 @@ original fetchall, but with logging)
             return res.fetchall()
         return logger.sql(query, helper)
 
+
 def gn_server(path):
     """Return JSON record by calling GN_SERVER
 
diff --git a/wqflask/db/gn_server.py b/wqflask/db/gn_server.py
index 6c7383d0..f9b01658 100644
--- a/wqflask/db/gn_server.py
+++ b/wqflask/db/gn_server.py
@@ -5,5 +5,6 @@ from db.call import gn_server
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 def menu_main():
     return gn_server("/int/menu/main.json")
diff --git a/wqflask/db/webqtlDatabaseFunction.py b/wqflask/db/webqtlDatabaseFunction.py
index 18ade405..50ac06fd 100644
--- a/wqflask/db/webqtlDatabaseFunction.py
+++ b/wqflask/db/webqtlDatabaseFunction.py
@@ -31,6 +31,7 @@ logger = getLogger(__name__)
 # function: connect to database and return cursor instance
 ###########################################################################
 
+
 def retrieve_species(group):
     """Get the species of a group (e.g. returns string "mouse" on "BXD"
 
diff --git a/wqflask/maintenance/convert_dryad_to_bimbam.py b/wqflask/maintenance/convert_dryad_to_bimbam.py
index 8eab66e8..e417c280 100644
--- a/wqflask/maintenance/convert_dryad_to_bimbam.py
+++ b/wqflask/maintenance/convert_dryad_to_bimbam.py
@@ -55,15 +55,18 @@ def read_dryad_file(filename):
     #            
     # return geno_rows
 
+
 def write_bimbam_files(geno_rows):
     with open('/home/zas1024/cfw_data/CFW_geno.txt', 'w') as geno_fh:
         for row in geno_rows:
             geno_fh.write(", ".join(row) + "\n")
 
+
 def convert_dryad_to_bimbam(filename):
     geno_file_rows = read_dryad_file(filename)
     write_bimbam_files(geno_file_rows)
 
+
 if __name__ == "__main__":
     input_filename = "/home/zas1024/cfw_data/" + sys.argv[1] + ".txt"
     convert_dryad_to_bimbam(input_filename)
diff --git a/wqflask/maintenance/convert_geno_to_bimbam.py b/wqflask/maintenance/convert_geno_to_bimbam.py
index dc01cbb3..5b2369c9 100644
--- a/wqflask/maintenance/convert_geno_to_bimbam.py
+++ b/wqflask/maintenance/convert_geno_to_bimbam.py
@@ -20,8 +20,10 @@ import simplejson as json
 
 from pprint import pformat as pf
 
+
 class EmptyConfigurations(Exception): pass
 
+
 class Marker:
     def __init__(self):
         self.name = None
@@ -30,6 +32,7 @@ class Marker:
         self.Mb = None
         self.genotypes = []
 
+
 class ConvertGenoFile:
 
     def __init__(self, input_file, output_files):
@@ -178,6 +181,7 @@ class ConvertGenoFile:
                 print("    Row is:", convertob.latest_row_value)
                 break
 
+
 if __name__ == "__main__":
     Old_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype"""
     New_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype/bimbam"""
diff --git a/wqflask/maintenance/gen_select_dataset.py b/wqflask/maintenance/gen_select_dataset.py
index f480d63f..583a06e1 100644
--- a/wqflask/maintenance/gen_select_dataset.py
+++ b/wqflask/maintenance/gen_select_dataset.py
@@ -55,6 +55,7 @@ from pprint import pformat as pf
 
 #conn = Engine.connect()
 
+
 def parse_db_uri():
     """Converts a database URI to the db name, host name, user name, and password"""
 
@@ -143,6 +144,7 @@ def phenotypes_exist(group_name):
     else:
         return False
 
+
 def genotypes_exist(group_name):
     #print("group_name:", group_name)
     Cursor.execute("""select Name from GenoFreeze
@@ -156,6 +158,7 @@ def genotypes_exist(group_name):
     else:
         return False
 
+
 def build_types(species, group):
     """Fetches tissues
 
@@ -184,6 +187,7 @@ def build_types(species, group):
 
     return results
 
+
 def get_datasets(types):
     """Build datasets list"""
     datasets = {}
@@ -308,6 +312,7 @@ def _test_it():
     datasets = build_datasets("Mouse", "BXD", "Hippocampus")
     #print("build_datasets:", pf(datasets))
 
+
 if __name__ == '__main__':
     Conn = MySQLdb.Connect(**parse_db_uri())
     Cursor = Conn.cursor()
diff --git a/wqflask/maintenance/generate_kinship_from_bimbam.py b/wqflask/maintenance/generate_kinship_from_bimbam.py
index 664e9e48..7cc60c9e 100644
--- a/wqflask/maintenance/generate_kinship_from_bimbam.py
+++ b/wqflask/maintenance/generate_kinship_from_bimbam.py
@@ -13,6 +13,7 @@ sys.path.append("..")
 import os
 import glob
 
+
 class GenerateKinshipMatrices:
     def __init__(self, group_name, geno_file, pheno_file):
         self.group_name = group_name
diff --git a/wqflask/maintenance/generate_probesetfreeze_file.py b/wqflask/maintenance/generate_probesetfreeze_file.py
index b1e41e9a..bd9c2ab4 100644
--- a/wqflask/maintenance/generate_probesetfreeze_file.py
+++ b/wqflask/maintenance/generate_probesetfreeze_file.py
@@ -23,10 +23,12 @@ def get_cursor():
     cursor = con.cursor()
     return cursor
 
+
 def show_progress(process, counter):
     if counter % 1000 == 0:
         print("{}: {}".format(process, counter))
 
+
 def get_strains(cursor):
     cursor.execute("""select Strain.Name
                       from Strain, StrainXRef, InbredSet
@@ -42,6 +44,7 @@ def get_strains(cursor):
 
     return strains
 
+
 def get_probeset_vals(cursor, dataset_name):
     cursor.execute(""" select ProbeSet.Id, ProbeSet.Name
                 from ProbeSetXRef,
@@ -77,6 +80,7 @@ def get_probeset_vals(cursor, dataset_name):
 
     return probeset_vals
 
+
 def trim_strains(strains, probeset_vals):
     trimmed_strains = []
     #print("probeset_vals is:", pf(probeset_vals))
@@ -89,6 +93,7 @@ def trim_strains(strains, probeset_vals):
     print("trimmed_strains:", pf(trimmed_strains))
     return trimmed_strains
 
+
 def write_data_matrix_file(strains, probeset_vals, filename):
     with open(filename, "wb") as fh:
         csv_writer = csv.writer(fh, delimiter=",", quoting=csv.QUOTE_ALL)
@@ -103,6 +108,7 @@ def write_data_matrix_file(strains, probeset_vals, filename):
             csv_writer.writerow(row_data)
             show_progress("Writing", counter)
 
+
 def main():
     filename = os.path.expanduser("~/gene/wqflask/maintenance/" +
                 "ProbeSetFreezeId_210_FullName_Eye_AXBXA_Illumina_V6.2" +
@@ -117,5 +123,6 @@ def main():
     trimmed_strains = trim_strains(strains, probeset_vals)
     write_data_matrix_file(trimmed_strains, probeset_vals, filename)
 
+
 if __name__ == '__main__':
     main()
diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index fa0dcebd..ad3f2b72 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -25,10 +25,10 @@ from pprint import pformat as pf
 
 #from utility.tools import flat_files
 
+
 class EmptyConfigurations(Exception): pass
 
         
-
 class Marker:
     def __init__(self):
         self.name = None
@@ -37,6 +37,7 @@ class Marker:
         self.Mb = None
         self.genotypes = []
 
+
 class ConvertGenoFile:
 
     def __init__(self, input_file, output_file):
@@ -78,7 +79,6 @@ class ConvertGenoFile:
             # elif self.file_type == "snps":
             #    self.process_snps_file()
 
-
     def process_csv(self):
         for row_count, row in enumerate(self.process_rows()):
             row_items = row.split("\t")
@@ -121,7 +121,6 @@ class ConvertGenoFile:
                     
             # self.output_fh.write("\n")
 
-
     def process_rows(self):
         for self.latest_row_pos, row in enumerate(self.input_fh):
             # if self.input_file.endswith(".geno.gz"):
@@ -182,7 +181,6 @@ class ConvertGenoFile:
     #    convertob = ConvertGenoFile(input_file, output_file)
         
 
-
 if __name__ == "__main__":
     Old_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype"""
     New_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype/json"""
diff --git a/wqflask/maintenance/get_group_samplelists.py b/wqflask/maintenance/get_group_samplelists.py
index 3f9d0278..0a450d3f 100644
--- a/wqflask/maintenance/get_group_samplelists.py
+++ b/wqflask/maintenance/get_group_samplelists.py
@@ -4,12 +4,14 @@ import gzip
 
 from base import webqtlConfig
 
+
 def get_samplelist(file_type, geno_file):
     if file_type == "geno":
         return get_samplelist_from_geno(geno_file)
     elif file_type == "plink":
         return get_samplelist_from_plink(geno_file)
 
+
 def get_samplelist_from_geno(genofilename):
     if os.path.isfile(genofilename + '.gz'):
         genofilename += '.gz'
@@ -33,6 +35,7 @@ def get_samplelist_from_geno(genofilename):
         samplelist = headers[3:]
     return samplelist
 
+
 def get_samplelist_from_plink(genofilename):
     genofile = open(genofilename)
 
diff --git a/wqflask/maintenance/print_benchmark.py b/wqflask/maintenance/print_benchmark.py
index a1046c86..9d12da8a 100644
--- a/wqflask/maintenance/print_benchmark.py
+++ b/wqflask/maintenance/print_benchmark.py
@@ -15,15 +15,18 @@ class TheCounter:
         self.time_took = time.time() - start_time
         TheCounter.Counters[self.__class__.__name__] = self.time_took
 
+
 class PrintAll(TheCounter):
     def print_it(self, counter):
         print(counter)
 
+
 class PrintSome(TheCounter):
     def print_it(self, counter):
         if counter % 1000 == 0:
             print(counter)
 
+
 class PrintNone(TheCounter):
     def print_it(self, counter):
         pass
@@ -37,5 +40,6 @@ def new_main():
 
     print(pf(TheCounter.Counters))
 
+
 if __name__ == '__main__':
     new_main()
diff --git a/wqflask/maintenance/quantile_normalize.py b/wqflask/maintenance/quantile_normalize.py
index 6751a8e5..1896bc52 100644
--- a/wqflask/maintenance/quantile_normalize.py
+++ b/wqflask/maintenance/quantile_normalize.py
@@ -14,6 +14,7 @@ from wqflask import app
 from utility.elasticsearch_tools import get_elasticsearch_connection
 from utility.tools import ELASTICSEARCH_HOST, ELASTICSEARCH_PORT, SQL_URI
 
+
 def parse_db_uri():
     """Converts a database URI to the db name, host name, user name, and password"""
 
@@ -28,6 +29,7 @@ def parse_db_uri():
     print(db_conn_info)
     return db_conn_info
 
+
 def create_dataframe(input_file):
     with open(input_file) as f:
         ncols = len(f.readline().split("\t"))
@@ -36,6 +38,8 @@ def create_dataframe(input_file):
     return pd.DataFrame(input_array)
 
 # This function taken from https://github.com/ShawnLYU/Quantile_Normalize
+
+
 def quantileNormalize(df_input):
     df = df_input.copy()
     # compute rank
@@ -50,6 +54,7 @@ def quantileNormalize(df_input):
         df[col] = [rank[i] for i in t]
     return df
 
+
 def set_data(dataset_name):
     orig_file = "/home/zas1024/cfw_data/" + dataset_name + ".txt"
 
@@ -95,6 +100,7 @@ def set_data(dataset_name):
                     }
                 }
 
+
 if __name__ == '__main__':
     Conn = MySQLdb.Connect(**parse_db_uri())
     Cursor = Conn.cursor()
diff --git a/wqflask/maintenance/set_resource_defaults.py b/wqflask/maintenance/set_resource_defaults.py
index 286094dd..c6c4f44c 100644
--- a/wqflask/maintenance/set_resource_defaults.py
+++ b/wqflask/maintenance/set_resource_defaults.py
@@ -37,6 +37,7 @@ import urllib.parse
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 def parse_db_uri():
     """Converts a database URI to the db name, host name, user name, and password"""
 
@@ -51,6 +52,7 @@ def parse_db_uri():
     print(db_conn_info)
     return db_conn_info
 
+
 def insert_probeset_resources(default_owner_id):
     current_resources = Redis.hgetall("resources")
     Cursor.execute("""  SELECT
@@ -77,6 +79,7 @@ def insert_probeset_resources(default_owner_id):
 
         add_resource(resource_ob, update=False)
 
+
 def insert_publish_resources(default_owner_id):
     current_resources = Redis.hgetall("resources")
     Cursor.execute("""  SELECT 
@@ -110,6 +113,7 @@ def insert_publish_resources(default_owner_id):
         else:
             continue
 
+
 def insert_geno_resources(default_owner_id):
     current_resources = Redis.hgetall("resources")
     Cursor.execute("""  SELECT
@@ -139,6 +143,7 @@ def insert_geno_resources(default_owner_id):
 
         add_resource(resource_ob, update=False)
 
+
 def insert_resources(default_owner_id):
     current_resources = get_resources()
     print("START")
@@ -149,6 +154,7 @@ def insert_resources(default_owner_id):
     insert_probeset_resources(default_owner_id)
     print("AFTER PROBESET")
 
+
 def main():
     """Generates and outputs (as json file) the data for the main dropdown menus on the home page"""
 
@@ -158,6 +164,7 @@ def main():
 
     insert_resources(owner_id)
 
+
 if __name__ == '__main__':
     Conn = MySQLdb.Connect(**parse_db_uri())
     Cursor = Conn.cursor()
diff --git a/wqflask/run_gunicorn.py b/wqflask/run_gunicorn.py
index 58108e03..03f310eb 100644
--- a/wqflask/run_gunicorn.py
+++ b/wqflask/run_gunicorn.py
@@ -14,9 +14,11 @@ from utility.startup_config import app_config
 
 app_config()
 
+
 @app.route("/gunicorn")
 def hello():
     return "<h1 style='color:blue'>Hello There!</h1>"
 
+
 if __name__ == "__main__":
     app.run(host='0.0.0.0')
diff --git a/wqflask/tests/unit/base/test_webqtl_case_data.py b/wqflask/tests/unit/base/test_webqtl_case_data.py
index 8e8ba482..cebd41ce 100644
--- a/wqflask/tests/unit/base/test_webqtl_case_data.py
+++ b/wqflask/tests/unit/base/test_webqtl_case_data.py
@@ -4,6 +4,7 @@ import unittest
 from wqflask import app  # Required because of utility.tools in webqtlCaseData.py
 from base.webqtlCaseData import webqtlCaseData
 
+
 class TestWebqtlCaseData(unittest.TestCase):
     """Tests for WebqtlCaseData class"""
 
diff --git a/wqflask/tests/unit/utility/test_authentication_tools.py b/wqflask/tests/unit/utility/test_authentication_tools.py
index 42dcae88..024ab43f 100644
--- a/wqflask/tests/unit/utility/test_authentication_tools.py
+++ b/wqflask/tests/unit/utility/test_authentication_tools.py
@@ -5,6 +5,7 @@ from unittest import mock
 from utility.authentication_tools import check_resource_availability
 from utility.authentication_tools import add_new_resource
 
+
 class TestResponse:
     """Mock Test Response after a request"""
     @property
diff --git a/wqflask/tests/unit/utility/test_chunks.py b/wqflask/tests/unit/utility/test_chunks.py
index 8d90a1ec..1d349193 100644
--- a/wqflask/tests/unit/utility/test_chunks.py
+++ b/wqflask/tests/unit/utility/test_chunks.py
@@ -7,6 +7,7 @@ from utility.chunks import divide_into_chunks
 
 class TestChunks(unittest.TestCase):
     "Test Utility method for chunking"
+
     def test_divide_into_chunks(self):
         "Check that a list is chunked correctly"
         self.assertEqual(divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3),
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
index 8ae0f09f..219a6a29 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -9,6 +9,7 @@ from wqflask.marker_regression.display_mapping_results import (
 
 class TestDisplayMappingResults(unittest.TestCase):
     """Basic Methods to test Mapping Results"""
+
     def test_pil_colors(self):
         """Test that colors use PILLOW color format"""
         self.assertEqual(DisplayMappingResults.CLICKABLE_WEBQTL_REGION_COLOR,
@@ -17,6 +18,7 @@ class TestDisplayMappingResults(unittest.TestCase):
 
 class TestHtmlGenWrapper(unittest.TestCase):
     """Test Wrapper around HTMLGen"""
+
     def test_create_image(self):
         """Test HT.Image method"""
         self.assertEqual(
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
index 5eec93f1..fd21a825 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_plink_mapping.py
@@ -12,9 +12,10 @@ class AttributeSetter:
     def __init__(self, obj):
         for key, val in obj.items():
             setattr(self, key, val)
-class TestPlinkMapping(unittest.TestCase):
 
 
+class TestPlinkMapping(unittest.TestCase):
+
     def test_build_line_list(self):
         """test for building line list"""
         line_1 = "this is line one test"
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index bbb79f98..5cc8fd0f 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -4,6 +4,8 @@ from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file
 
 # issues some methods in genofile object are not defined
 # modify samples should equal to vals
+
+
 class TestQtlReaperMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
 	def test_gen_pheno_txt_file(self):                   
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 0e617e93..6267ce9a 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -5,6 +5,7 @@ from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
 from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
 from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
 
+
 class TestRqtlMapping(unittest.TestCase):
 
 	def setUp(self):
@@ -14,7 +15,6 @@ class TestRqtlMapping(unittest.TestCase):
 	def tearDown(self):
 		self.app_context.pop()
 
-
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
 	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
 	def test_get_trait_data(self, mock_logger, mock_db):
diff --git a/wqflask/tests/unit/wqflask/test_collect.py b/wqflask/tests/unit/wqflask/test_collect.py
index 9a36132d..2a914fb2 100644
--- a/wqflask/tests/unit/wqflask/test_collect.py
+++ b/wqflask/tests/unit/wqflask/test_collect.py
@@ -11,6 +11,7 @@ app = Flask(__name__)
 
 class MockSession:
     """Helper class for mocking wqflask.collect.g.user_session.logged_in"""
+
     def __init__(self, is_logged_in=False):
         self.is_logged_in = is_logged_in
 
@@ -21,6 +22,7 @@ class MockSession:
 
 class MockFlaskG:
     """Helper class for mocking wqflask.collect.g.user_session"""
+
     def __init__(self, is_logged_in=False):
         self.is_logged_in = is_logged_in
 
diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 8c866874..24c3923e 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -242,7 +242,6 @@ class TestTraits(unittest.TestCase):
         self.assertEqual(get_genotype_scales(file_location), expected_results)
         mock_get_scales.assert_called_once_with(file_location)
 
-
     @mock.patch("wqflask.show_trait.show_trait.locate_ignore_error")
     def test_get_scales_from_genofile_found(self, mock_ignore_location):
         """"add test for get scales from genofile where file is found"""
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index 68c2cb72..d35b2089 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -47,6 +47,7 @@ COUR_FILE = "./wqflask/static/fonts/courbd.ttf"
 TAHOMA_FILE = "./wqflask/static/fonts/tahoma.ttf"
 # ---- END: FONT FILES ---- #
 
+
 def cformat(d, rank=0):
     'custom string format'
     strD = "%2.6f" % d
@@ -68,6 +69,7 @@ def cformat(d, rank=0):
         strD = '0.0'
     return strD
 
+
 def frange(start, end=None, inc=1.0):
     "A faster range-like function that does accept float increments..."
     if end == None:
@@ -84,6 +86,7 @@ def frange(start, end=None, inc=1.0):
         L[i] = start + i * inc
     return L
 
+
 def find_outliers(vals):
     """Calculates the upper and lower bounds of a set of sample/case values
 
@@ -119,6 +122,8 @@ def find_outliers(vals):
 
 # parameter: data is either object returned by reaper permutation function (called by MarkerRegressionPage.py)
 # or the first object returned by direct (pair-scan) permu function (called by DirectPlotPage.py)
+
+
 def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLabel=None, YLabel=None, title=None, offset=(60, 20, 40, 40), zoom=1):
     im_drawer = ImageDraw.Draw(canvas)
     xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
@@ -230,6 +235,8 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
            font=labelFont, fill=labelColor)
 
 # This function determines the scale of the plot
+
+
 def detScaleOld(min, max):
     if min >= max:
         return None
@@ -246,6 +253,7 @@ def detScaleOld(min, max):
         high = c * ceil(max / c)
         return [low, high, round((high - low) / c)]
 
+
 def detScale(min=0, max=0):
 
     if min >= max:
@@ -283,15 +291,19 @@ def detScale(min=0, max=0):
 
         return [low, high, n]
 
+
 def bluefunc(x):
     return 1.0 / (1.0 + exp(-10 * (x - 0.6)))
 
+
 def redfunc(x):
     return 1.0 / (1.0 + exp(10 * (x - 0.5)))
 
+
 def greenfunc(x):
     return 1 - pow(redfunc(x + 0.2), 2) - bluefunc(x - 0.3)
 
+
 def colorSpectrum(n=100):
     multiple = 10
     if n == 1:
@@ -319,6 +331,7 @@ def colorSpectrum(n=100):
     out2.append(out[-1])
     return out2
 
+
 def _test():
     import doctest
     doctest.testmod()
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index ec7e72d0..d540c96e 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -2,8 +2,10 @@ from pprint import pformat as pf
 
 # Todo: Move these out of __init__
 
+
 class Bunch:
     """Like a dictionary but using object notation"""
+
     def __init__(self, **kw):
             self.__dict__ = kw
 
diff --git a/wqflask/utility/after.py b/wqflask/utility/after.py
index 06091ecb..2b560e48 100644
--- a/wqflask/utility/after.py
+++ b/wqflask/utility/after.py
@@ -7,6 +7,7 @@ from flask import g
 
 from wqflask import app
 
+
 def after_this_request(f):
     if not hasattr(g, 'after_request_callbacks'):
         g.after_request_callbacks = []
diff --git a/wqflask/utility/authentication_tools.py b/wqflask/utility/authentication_tools.py
index 672b36d5..57dbf8ba 100644
--- a/wqflask/utility/authentication_tools.py
+++ b/wqflask/utility/authentication_tools.py
@@ -11,6 +11,7 @@ from utility.redis_tools import (get_redis_conn,
                                  add_resource)
 Redis = get_redis_conn()
 
+
 def check_resource_availability(dataset, trait_id=None):
     # At least for now assume temporary entered traits are accessible
     if type(dataset) == str or dataset.type == "Temp":
diff --git a/wqflask/utility/benchmark.py b/wqflask/utility/benchmark.py
index 3d40a3b8..48ab1dc0 100644
--- a/wqflask/utility/benchmark.py
+++ b/wqflask/utility/benchmark.py
@@ -6,6 +6,7 @@ from utility.tools import LOG_BENCH
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class Bench:
     entries = collections.OrderedDict()
 
diff --git a/wqflask/utility/corestats.py b/wqflask/utility/corestats.py
index 15d1cb8d..523280a1 100644
--- a/wqflask/utility/corestats.py
+++ b/wqflask/utility/corestats.py
@@ -16,6 +16,8 @@
 import sys
 
 # ZS: Should switch to using some third party library for this; maybe scipy has an equivalent
+
+
 class Stats:
 
     def __init__(self, sequence):
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index ae1181e4..9415cef0 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -47,11 +47,13 @@ logger = getLogger(__name__)
 
 from utility.tools import ELASTICSEARCH_HOST, ELASTICSEARCH_PORT
 
+
 def test_elasticsearch_connection():
     es = Elasticsearch(['http://' + ELASTICSEARCH_HOST + ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
     if not es.ping():
         logger.warning("Elasticsearch is DOWN")
 
+
 def get_elasticsearch_connection(for_user=True):
     """Return a connection to ES. Returns None on failure"""
     logger.info("get_elasticsearch_connection")
@@ -77,6 +79,7 @@ def get_elasticsearch_connection(for_user=True):
 
     return es
 
+
 def setup_users_index(es_connection):
     if es_connection:
         index_settings = {
@@ -87,12 +90,15 @@ def setup_users_index(es_connection):
         es_connection.indices.create(index='users', ignore=400)
         es_connection.indices.put_mapping(body=index_settings, index="users", doc_type="local")
 
+
 def get_user_by_unique_column(es, column_name, column_value, index="users", doc_type="local"):
     return get_item_by_unique_column(es, column_name, column_value, index=index, doc_type=doc_type)
 
+
 def save_user(es, user, user_id):
     es_save_data(es, "users", "local", user, user_id)
 
+
 def get_item_by_unique_column(es, column_name, column_value, index, doc_type):
     item_details = None
     try:
@@ -106,6 +112,7 @@ def get_item_by_unique_column(es, column_name, column_value, index, doc_type):
         pass
     return item_details
 
+
 def es_save_data(es, index, doc_type, data_item, data_id,):
     from time import sleep
     es.create(index, doc_type, body=data_item, id=data_id)
diff --git a/wqflask/utility/external.py b/wqflask/utility/external.py
index c1bf4043..805d2ffe 100644
--- a/wqflask/utility/external.py
+++ b/wqflask/utility/external.py
@@ -4,6 +4,7 @@ import os
 import sys
 import subprocess
 
+
 def shell(command):
     if subprocess.call(command, shell=True) != 0:
         raise Exception("ERROR: failed on " + command)
diff --git a/wqflask/utility/gen_geno_ob.py b/wqflask/utility/gen_geno_ob.py
index 9cfa39f9..24604e58 100644
--- a/wqflask/utility/gen_geno_ob.py
+++ b/wqflask/utility/gen_geno_ob.py
@@ -1,6 +1,7 @@
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class genotype:
     """
     Replacement for reaper.Dataset so we can remove qtlreaper use while still generating mapping output figure
@@ -119,6 +120,7 @@ class genotype:
 
             self.chromosomes.append(chr_ob)
 
+
 class Chr:
     def __init__(self, name, geno_ob):
         self.name = name
@@ -140,6 +142,7 @@ class Chr:
     def add_marker(self, marker_row):
         self.loci.append(Locus(self.geno_ob, marker_row))
 
+
 class Locus:
     def __init__(self, geno_ob, marker_row=None):
         self.chr = None
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index f8e96d19..94a08c17 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -12,6 +12,7 @@ import simplejson as json
 
 from pprint import pformat as pf
 
+
 class Marker:
   def __init__(self):
     self.name = None
diff --git a/wqflask/utility/logger.py b/wqflask/utility/logger.py
index 16912e58..47079818 100644
--- a/wqflask/utility/logger.py
+++ b/wqflask/utility/logger.py
@@ -35,6 +35,7 @@ import datetime
 
 from utility.tools import LOG_LEVEL, LOG_LEVEL_DEBUG, LOG_SQL
 
+
 class GNLogger:
     """A logger class with some additional functionality, such as
     multiple parameter logging, SQL logging, timing, colors, and lazy
@@ -139,6 +140,8 @@ LOG_LEVEL_DEBUG (NYI).
 
 # Get the module logger. You can override log levels at the
 # module level
+
+
 def getLogger(name, level=None):
     gnlogger = GNLogger(name)
     logger = gnlogger.logger
diff --git a/wqflask/utility/pillow_utils.py b/wqflask/utility/pillow_utils.py
index 6e95beb0..5713e155 100644
--- a/wqflask/utility/pillow_utils.py
+++ b/wqflask/utility/pillow_utils.py
@@ -9,6 +9,8 @@ BLACK = ImageColor.getrgb("black")
 WHITE = ImageColor.getrgb("white")
 
 # def draw_rotated_text(canvas: Image, text: str, font: ImageFont, xy: tuple, fill: ImageColor=BLACK, angle: int=-90):
+
+
 def draw_rotated_text(canvas, text, font, xy, fill=BLACK, angle=-90):
     # type: (Image, str, ImageFont, tuple, ImageColor, int)
     """Utility function draw rotated text"""
@@ -20,6 +22,8 @@ def draw_rotated_text(canvas, text, font, xy, fill=BLACK, angle=-90):
     canvas.paste(im=tmp_img2, box=tuple([int(i) for i in xy]))
 
 # def draw_open_polygon(canvas: Image, xy: tuple, fill: ImageColor=WHITE, outline: ImageColor=BLACK):
+
+
 def draw_open_polygon(canvas, xy, fill=None, outline=BLACK, width=0):
     # type: (Image, tuple, ImageColor, ImageColor)
     draw_ctx = ImageDraw.Draw(canvas)
diff --git a/wqflask/utility/startup_config.py b/wqflask/utility/startup_config.py
index f22f4b14..92f944bc 100644
--- a/wqflask/utility/startup_config.py
+++ b/wqflask/utility/startup_config.py
@@ -10,6 +10,7 @@ GREEN = '\033[92m'
 BOLD = '\033[1m'
 ENDC = '\033[0m'
 
+
 def app_config():
     app.config['SESSION_TYPE'] = 'filesystem'
     if not app.config.get('SECRET_KEY'):
diff --git a/wqflask/utility/svg.py b/wqflask/utility/svg.py
index 4c478c36..f5ef81e1 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -459,11 +459,13 @@ class rect(SVGelement):
         if stroke_width != None:
             self.attributes['stroke-width'] = stroke_width
 
+
 class ellipse(SVGelement):
     """e=ellipse(rx,ry,x,y,fill,stroke,stroke_width,**args)
 
     an ellipse is defined as a center and a x and y radius.
     """
+
     def __init__(self, cx=None, cy=None, rx=None, ry=None,fill=None,stroke=None,stroke_width=None,**args):
         if rx == None or ry == None:
             raise ValueError('both rx and ry are required')
@@ -486,6 +488,7 @@ class circle(SVGelement):
 
     The circle creates an element using a x, y and radius values eg
     """
+
     def __init__(self, cx=None, cy=None, r=None, fill=None,stroke=None,stroke_width=None,**args):
         if r == None:
             raise ValueError('r is required')
@@ -501,20 +504,24 @@ class circle(SVGelement):
         if stroke_width != None:
             self.attributes['stroke-width'] = stroke_width
 
+
 class point(circle):
     """p=point(x,y,color)
 
     A point is defined as a circle with a size 1 radius. It may be more efficient to use a
     very small rectangle if you use many points because a circle is difficult to render.
     """
+
     def __init__(self, x, y, fill='black', **args):
         circle.__init__(self, x, y, 1, fill, **args)
 
+
 class line(SVGelement):
     """l=line(x1,y1,x2,y2,stroke,stroke_width,**args)
 
     A line is defined by a begin x,y pair and an end x,y pair
     """
+
     def __init__(self, x1=None, y1=None, x2=None, y2=None,stroke=None,stroke_width=None,**args):
         SVGelement.__init__(self, 'line', **args)
         if x1 != None:
@@ -530,11 +537,13 @@ class line(SVGelement):
         if stroke != None:
             self.attributes['stroke'] = stroke
 
+
 class polyline(SVGelement):
     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 
     a polyline is defined by a list of xy pairs
     """
+
     def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
         SVGelement.__init__(self, 'polyline', {'points': _xypointlist(points)}, **args)
         if fill != None:
@@ -544,11 +553,13 @@ class polyline(SVGelement):
         if stroke != None:
             self.attributes['stroke'] = stroke
 
+
 class polygon(SVGelement):
     """pl=polyline([[x1,y1],[x2,y2],...],fill,stroke,stroke_width,**args)
 
     a polygon is defined by a list of xy pairs
     """
+
     def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
         SVGelement.__init__(self, 'polygon', {'points': _xypointlist(points)}, **args)
         if fill != None:
@@ -558,11 +569,13 @@ class polygon(SVGelement):
         if stroke != None:
             self.attributes['stroke'] = stroke
 
+
 class path(SVGelement):
     """p=path(path,fill,stroke,stroke_width,**args)
 
     a path is defined by a path object and optional width, stroke and fillcolor
     """
+
     def __init__(self, pathdata, fill=None, stroke=None, stroke_width=None,id=None,**args):
         SVGelement.__init__(self, 'path', {'d': str(pathdata)}, **args)
         if stroke != None:
@@ -580,6 +593,7 @@ class text(SVGelement):
 
     a text element can bge used for displaying text on the screen
     """
+
     def __init__(self, x=None, y=None, text=None, font_size=None,font_family=None,text_anchor=None,**args):
         SVGelement.__init__(self, 'text', **args)
         if x != None:
@@ -601,11 +615,13 @@ class textpath(SVGelement):
 
     a textpath places a text on a path which is referenced by a link.
     """
+
     def __init__(self, link, text=None, **args):
         SVGelement.__init__(self, 'textPath', {'xlink:href': link}, **args)
         if text != None:
             self.text = text
 
+
 class pattern(SVGelement):
     """p=pattern(x,y,width,height,patternUnits,**args)
 
@@ -613,6 +629,7 @@ class pattern(SVGelement):
     graphic object which can be replicated ("tiled") at fixed intervals
     in x and y to cover the areas to be painted.
     """
+
     def __init__(self, x=None, y=None, width=None, height=None,patternUnits=None,**args):
         SVGelement.__init__(self, 'pattern', **args)
         if x != None:
@@ -626,34 +643,40 @@ class pattern(SVGelement):
         if patternUnits != None:
             self.attributes['patternUnits'] = patternUnits
 
+
 class title(SVGelement):
     """t=title(text,**args)
 
     a title is a text element. The text is displayed in the title bar
     add at least one to the root svg element
     """
+
     def __init__(self, text=None, **args):
         SVGelement.__init__(self, 'title', **args)
         if text != None:
             self.text = text
 
+
 class description(SVGelement):
     """d=description(text,**args)
 
     a description can be added to any element and is used for a tooltip
     Add this element before adding other elements.
     """
+
     def __init__(self, text=None, **args):
         SVGelement.__init__(self, 'desc', **args)
         if text != None:
             self.text = text
 
+
 class lineargradient(SVGelement):
     """lg=lineargradient(x1,y1,x2,y2,id,**args)
 
     defines a lineargradient using two xy pairs.
     stop elements van be added to define the gradient colors.
     """
+
     def __init__(self, x1=None, y1=None, x2=None, y2=None,id=None,**args):
         SVGelement.__init__(self, 'linearGradient', **args)
         if x1 != None:
@@ -667,12 +690,14 @@ class lineargradient(SVGelement):
         if id != None:
             self.attributes['id'] = id
 
+
 class radialgradient(SVGelement):
     """rg=radialgradient(cx,cy,r,fx,fy,id,**args)
 
     defines a radial gradient using a outer circle which are defined by a cx,cy and r and by using a focalpoint.
     stop elements van be added to define the gradient colors.
     """
+
     def __init__(self, cx=None, cy=None, r=None, fx=None,fy=None,id=None,**args):
         SVGelement.__init__(self, 'radialGradient', **args)
         if cx != None:
@@ -688,21 +713,25 @@ class radialgradient(SVGelement):
         if id != None:
             self.attributes['id'] = id
 
+
 class stop(SVGelement):
     """st=stop(offset,stop_color,**args)
 
     Puts a stop color at the specified radius
     """
+
     def __init__(self, offset, stop_color=None, **args):
         SVGelement.__init__(self, 'stop', {'offset': offset}, **args)
         if stop_color != None:
             self.attributes['stop-color'] = stop_color
 
+
 class style(SVGelement):
     """st=style(type,cdata=None,**args)
 
     Add a CDATA element to this element for defing in line stylesheets etc..
     """
+
     def __init__(self, type, cdata=None, **args):
         SVGelement.__init__(self, 'style', {'type': type}, cdata=cdata, **args)
 
@@ -712,6 +741,7 @@ class image(SVGelement):
 
     adds an image to the drawing. Supported formats are .png, .jpg and .svg.
     """
+
     def __init__(self, url, x=None, y=None, width=None,height=None,**args):
         if width == None or height == None:
             raise ValueError('both height and width are required')
@@ -721,11 +751,13 @@ class image(SVGelement):
         if y != None:
             self.attributes['y'] = y
 
+
 class cursor(SVGelement):
     """c=cursor(url,**args)
 
     defines a custom cursor for a element or a drawing
     """
+
     def __init__(self, url, **args):
         SVGelement.__init__(self, 'cursor', {'xlink:href': url}, **args)
 
@@ -736,6 +768,7 @@ class marker(SVGelement):
     defines a marker which can be used as an endpoint for a line or other pathtypes
     add an element to it which should be used as a marker.
     """
+
     def __init__(self, id=None, viewBox=None, refx=None, refy=None,markerWidth=None,markerHeight=None,**args):
         SVGelement.__init__(self, 'marker', **args)
         if id != None:
@@ -751,17 +784,20 @@ class marker(SVGelement):
         if markerHeight != None:
             self.attributes['markerHeight'] = markerHeight
 
+
 class group(SVGelement):
     """g=group(id,**args)
 
     a group is defined by an id and is used to contain elements
     g.addElement(SVGelement)
     """
+
     def __init__(self, id=None, **args):
         SVGelement.__init__(self, 'g', **args)
         if id != None:
             self.attributes['id'] = id
 
+
 class symbol(SVGelement):
     """sy=symbol(id,viewbox,**args)
 
@@ -778,14 +814,17 @@ class symbol(SVGelement):
         if viewBox != None:
             self.attributes['viewBox'] = _viewboxlist(viewBox)
 
+
 class defs(SVGelement):
     """d=defs(**args)
 
     container for defining elements
     """
+
     def __init__(self, **args):
         SVGelement.__init__(self, 'defs', **args)
 
+
 class switch(SVGelement):
     """sw=switch(**args)
 
@@ -793,6 +832,7 @@ class switch(SVGelement):
     requiredFeatures, requiredExtensions and systemLanguage.
     Refer to the SVG specification for details.
     """
+
     def __init__(self, **args):
         SVGelement.__init__(self, 'switch', **args)
 
@@ -802,6 +842,7 @@ class use(SVGelement):
 
     references a symbol by linking to its id and its position, height and width
     """
+
     def __init__(self, link, x=None, y=None, width=None,height=None,**args):
         SVGelement.__init__(self, 'use', {'xlink:href': link}, **args)
         if x != None:
@@ -821,32 +862,39 @@ class link(SVGelement):
     a link  is defined by a hyperlink. add elements which have to be linked
     a.addElement(SVGelement)
     """
+
     def __init__(self, link='', **args):
         SVGelement.__init__(self, 'a', {'xlink:href': link}, **args)
 
+
 class view(SVGelement):
     """v=view(id,**args)
 
     a view can be used to create a view with different attributes"""
+
     def __init__(self, id=None, **args):
         SVGelement.__init__(self, 'view', **args)
         if id != None:
             self.attributes['id'] = id
 
+
 class script(SVGelement):
     """sc=script(type,type,cdata,**args)
 
     adds a script element which contains CDATA to the SVG drawing
 
     """
+
     def __init__(self, type, cdata=None, **args):
         SVGelement.__init__(self, 'script', {'type': type}, cdata=cdata, **args)
 
+
 class animate(SVGelement):
     """an=animate(attribute,from,to,during,**args)
 
     animates an attribute.
     """
+
     def __init__(self, attribute, fr=None, to=None, dur=None,**args):
         SVGelement.__init__(self, 'animate', {'attributeName': attribute}, **args)
         if fr != None:
@@ -856,11 +904,13 @@ class animate(SVGelement):
         if dur != None:
             self.attributes['dur'] = dur
 
+
 class animateMotion(SVGelement):
     """an=animateMotion(pathdata,dur,**args)
 
     animates a SVGelement over the given path in dur seconds
     """
+
     def __init__(self, pathdata, dur, **args):
         SVGelement.__init__(self, 'animateMotion', **args)
         if pathdata != None:
@@ -868,11 +918,13 @@ class animateMotion(SVGelement):
         if dur != None:
             self.attributes['dur'] = dur
 
+
 class animateTransform(SVGelement):
     """antr=animateTransform(type,from,to,dur,**args)
 
     transform an element from and to a value.
     """
+
     def __init__(self, type=None, fr=None, to=None, dur=None,**args):
         SVGelement.__init__(self, 'animateTransform', {'attributeName': 'transform'}, **args)
         # As far as I know the attributeName is always transform
@@ -884,11 +936,14 @@ class animateTransform(SVGelement):
             self.attributes['to'] = to
         if dur != None:
             self.attributes['dur'] = dur
+
+
 class animateColor(SVGelement):
     """ac=animateColor(attribute,type,from,to,dur,**args)
 
     Animates the color of a element
     """
+
     def __init__(self, attribute, type=None, fr=None, to=None,dur=None,**args):
         SVGelement.__init__(self, 'animateColor', {'attributeName': attribute}, **args)
         if type != None:
@@ -899,11 +954,14 @@ class animateColor(SVGelement):
             self.attributes['to'] = to
         if dur != None:
             self.attributes['dur'] = dur
+
+
 class set(SVGelement):
     """st=set(attribute,to,during,**args)
 
     sets an attribute to a value for a
     """
+
     def __init__(self, attribute, to=None, dur=None, **args):
         SVGelement.__init__(self, 'set', {'attributeName': attribute}, **args)
         if to != None:
@@ -912,7 +970,6 @@ class set(SVGelement):
             self.attributes['dur'] = dur
 
 
-
 class svg(SVGelement):
     """s=svg(viewbox,width,height,**args)
 
@@ -928,6 +985,7 @@ class svg(SVGelement):
     d.setSVG(s)
     d.toXml()
     """
+
     def __init__(self, viewBox=None, width=None, height=None, **args):
         SVGelement.__init__(self, 'svg', **args)
         if viewBox != None:
@@ -938,6 +996,7 @@ class svg(SVGelement):
             self.attributes['height'] = height
         self.namespace = "http://www.w3.org/2000/svg"
 
+
 class drawing:
     """d=drawing()
 
@@ -952,6 +1011,7 @@ class drawing:
     def __init__(self, entity={}):
         self.svg = None
         self.entity = entity
+
     def setSVG(self, svg):
         self.svg = svg
         # Voeg een element toe aan de grafiek toe.
@@ -1005,6 +1065,7 @@ class drawing:
             root = implementation.createDocument(None, None, doctype)
             # Create the xml document.
             global appender
+
             def appender(element, elementroot):
                 """This recursive function appends elements to an element and sets the attributes
                 and type. It stops when alle elements have been appended"""
@@ -1053,6 +1114,7 @@ class drawing:
                         f.close()
                 except:
                     print(("Cannot write SVG file: " + filename))
+
     def validate(self):
         try:
             import xml.parsers.xmlproc.xmlval
@@ -1066,9 +1128,10 @@ class drawing:
             raise Exception("SVG is not well formed, see messages above")
         else:
             print("SVG well formed")
-if __name__ == '__main__':
 
 
+if __name__ == '__main__':
+
     d = drawing()
     s = svg((0, 0, 100, 100))
     r = rect(-100, -100, 300, 300, 'cyan')
diff --git a/wqflask/utility/temp_data.py b/wqflask/utility/temp_data.py
index 2088ba9a..07c5a318 100644
--- a/wqflask/utility/temp_data.py
+++ b/wqflask/utility/temp_data.py
@@ -2,6 +2,7 @@ from redis import Redis
 
 import simplejson as json
 
+
 class TempData:
 
     def __init__(self, temp_uuid):
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index 9b751344..4fe4db08 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -13,11 +13,13 @@ logger = logging.getLogger(__name__)
 
 OVERRIDES = {}
 
+
 def app_set(command_id, value):
     """Set application wide value"""
     app.config.setdefault(command_id, value)
     return value
 
+
 def get_setting(command_id, guess=None):
     """Resolve a setting from the environment or the global settings in
     app.config, with valid_path is a function checking whether the
@@ -66,12 +68,14 @@ def get_setting(command_id, guess=None):
     # print("Set "+command_id+"="+str(command))
     return command
 
+
 def get_setting_bool(id):
     v = get_setting(id)
     if v not in [0, False, 'False', 'FALSE', None]:
       return True
     return False
 
+
 def get_setting_int(id):
     v = get_setting(id)
     if isinstance(v, str):
@@ -80,21 +84,25 @@ def get_setting_int(id):
         return 0
     return v
 
+
 def valid_bin(bin):
     if os.path.islink(bin) or valid_file(bin):
         return bin
     return None
 
+
 def valid_file(fn):
     if os.path.isfile(fn):
         return fn
     return None
 
+
 def valid_path(dir):
     if os.path.isdir(dir):
         return dir
     return None
 
+
 def js_path(module=None):
     """
     Find the JS module in the two paths
@@ -107,38 +115,47 @@ def js_path(module=None):
         return try_guix
     raise "No JS path found for " + module + " (if not in Guix check JS_GN_PATH)"
 
+
 def reaper_command(guess=None):
     return get_setting("REAPER_COMMAND", guess)
 
+
 def gemma_command(guess=None):
     return assert_bin(get_setting("GEMMA_COMMAND", guess))
 
+
 def gemma_wrapper_command(guess=None):
     return assert_bin(get_setting("GEMMA_WRAPPER_COMMAND", guess))
 
+
 def plink_command(guess=None):
     return assert_bin(get_setting("PLINK_COMMAND", guess))
 
+
 def flat_file_exists(subdir):
     base = get_setting("GENENETWORK_FILES")
     return valid_path(base + "/" + subdir)
 
+
 def flat_files(subdir=None):
     base = get_setting("GENENETWORK_FILES")
     if subdir:
         return assert_dir(base + "/" + subdir)
     return assert_dir(base)
 
+
 def assert_bin(fn):
     if not valid_bin(fn):
         raise Exception("ERROR: can not find binary " + fn)
     return fn
 
+
 def assert_dir(dir):
     if not valid_path(dir):
         raise Exception("ERROR: can not find directory " + dir)
     return dir
 
+
 def assert_writable_dir(dir):
     try:
         fn = dir + "/test.txt"
@@ -150,16 +167,19 @@ def assert_writable_dir(dir):
         raise Exception('Unable to write test.txt to directory ' + dir)
     return dir
 
+
 def assert_file(fn):
     if not valid_file(fn):
         raise Exception('Unable to find file ' + fn)
     return fn
 
+
 def mk_dir(dir):
     if not valid_path(dir):
         os.makedirs(dir)
     return assert_dir(dir)
 
+
 def locate(name, subdir=None):
     """
     Locate a static flat file in the GENENETWORK_FILES environment.
@@ -179,9 +199,11 @@ def locate(name, subdir=None):
     if subdir: sys.stderr.write(subdir)
     raise Exception("Can not locate " + name + " in " + base)
 
+
 def locate_phewas(name, subdir=None):
     return locate(name, '/phewas/' + subdir)
 
+
 def locate_ignore_error(name, subdir=None):
     """
     Locate a static flat file in the GENENETWORK_FILES environment.
@@ -200,17 +222,20 @@ def locate_ignore_error(name, subdir=None):
     logger.info("WARNING: file " + name + " not found\n")
     return None
 
+
 def tempdir():
     """
     Get UNIX TMPDIR by default
     """
     return valid_path(get_setting("TMPDIR", "/tmp"))
 
+
 BLUE = '\033[94m'
 GREEN = '\033[92m'
 BOLD = '\033[1m'
 ENDC = '\033[0m'
 
+
 def show_settings():
     from utility.tools import LOG_LEVEL
 
diff --git a/wqflask/utility/type_checking.py b/wqflask/utility/type_checking.py
index 662bf794..00f14ba9 100644
--- a/wqflask/utility/type_checking.py
+++ b/wqflask/utility/type_checking.py
@@ -7,6 +7,7 @@ def is_float(value):
     except:
         return False
 
+
 def is_int(value):
     try:
         int(value)
@@ -14,6 +15,7 @@ def is_int(value):
     except:
         return False
 
+
 def is_str(value):
     if value is None:
         return False
@@ -23,18 +25,21 @@ def is_str(value):
     except:
         return False
 
+
 def get_float(vars_obj, name, default=None):
     if name in vars_obj:
         if is_float(vars_obj[name]):
             return float(vars_obj[name])
     return default
 
+
 def get_int(vars_obj, name, default=None):
     if name in vars_obj:
         if is_int(vars_obj[name]):
             return float(vars_obj[name])
     return default
 
+
 def get_string(vars_obj, name, default=None):
     if name in vars_obj:
         if not vars_obj[name] is None:
diff --git a/wqflask/utility/webqtlUtil.py b/wqflask/utility/webqtlUtil.py
index ed59b0eb..f355a865 100644
--- a/wqflask/utility/webqtlUtil.py
+++ b/wqflask/utility/webqtlUtil.py
@@ -64,6 +64,7 @@ ParInfo = {
 #      Accessory Functions
 #########################################
 
+
 def genRandStr(prefix="", length=8, chars=string.ascii_letters + string.digits):
     from random import choice
     _str = prefix[:]
@@ -71,6 +72,7 @@ def genRandStr(prefix="", length=8, chars=string.ascii_letters + string.digits):
         _str += choice(chars)
     return _str
 
+
 def ListNotNull(lst):
     '''Obsolete - Use built in function any (or all or whatever)
 
@@ -83,6 +85,7 @@ def ListNotNull(lst):
             return 1
     return None
 
+
 def readLineCSV(line):  # dcrowell July 2008
     """Parses a CSV string of text and returns a list containing each element as a string.
     Used by correlationPage"""
@@ -91,6 +94,7 @@ def readLineCSV(line):  # dcrowell July 2008
     returnList[0] = returnList[0][1:]
     return returnList
 
+
 def cmpEigenValue(A, B):
     try:
         if A[0] > B[0]:
@@ -102,6 +106,7 @@ def cmpEigenValue(A, B):
     except:
         return 0
 
+
 def hasAccessToConfidentialPhenotypeTrait(privilege, userName, authorized_users):
     access_to_confidential_phenotype_trait = 0
     if webqtlConfig.USERDICT[privilege] > webqtlConfig.USERDICT['user']:
diff --git a/wqflask/wqflask/__init__.py b/wqflask/wqflask/__init__.py
index bab87115..712517a3 100644
--- a/wqflask/wqflask/__init__.py
+++ b/wqflask/wqflask/__init__.py
@@ -30,6 +30,7 @@ app.register_blueprint(policies_blueprint, url_prefix="/policies")
 app.register_blueprint(environments_blueprint, url_prefix="/environments")
 app.register_blueprint(facilities_blueprint, url_prefix="/facilities")
 
+
 @app.before_request
 def before_request():
     g.request_start_time = time.time()
diff --git a/wqflask/wqflask/api/correlation.py b/wqflask/wqflask/api/correlation.py
index e0b7fea0..f1dd148f 100644
--- a/wqflask/wqflask/api/correlation.py
+++ b/wqflask/wqflask/api/correlation.py
@@ -18,6 +18,7 @@ from utility.benchmark import Bench
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 def do_correlation(start_vars):
     assert('db' in start_vars)
     assert('target_db' in start_vars)
@@ -66,6 +67,7 @@ def do_correlation(start_vars):
 
     return final_results
 
+
 def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
     corr_results = {}
 
@@ -91,6 +93,7 @@ def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
 
     return sorted_results
 
+
 def do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_params, tissue_dataset_id=1):
     # Gets tissue expression values for the primary trait
     primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(symbol_list=[this_trait.symbol])
@@ -113,6 +116,7 @@ def do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_par
 
         return tissue_corr_data
 
+
 def do_literature_correlation_for_all_traits(this_trait, target_dataset, trait_geneid_dict, corr_params):
     input_trait_mouse_gene_id = convert_to_mouse_gene_id(target_dataset.group.species.lower(), this_trait.geneid)
 
@@ -145,6 +149,7 @@ def do_literature_correlation_for_all_traits(this_trait, target_dataset, trait_g
 
     return lit_corr_data
 
+
 def get_sample_r_and_p_values(this_trait, this_dataset, target_vals, target_dataset, type):
     """
     Calculates the sample r (or rho) and p-value
@@ -176,6 +181,7 @@ def get_sample_r_and_p_values(this_trait, this_dataset, target_vals, target_data
         else:
             return [sample_r, sample_p, num_overlap]
 
+
 def convert_to_mouse_gene_id(species=None, gene_id=None):
     """If the species is rat or human, translate the gene_id to the mouse geneid
 
@@ -212,6 +218,7 @@ def convert_to_mouse_gene_id(species=None, gene_id=None):
 
     return mouse_gene_id
 
+
 def init_corr_params(start_vars):
     method = "pearson"
     if 'method' in start_vars:
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index fbfbc879..662090d5 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -10,6 +10,7 @@ from wqflask.marker_regression import gemma_mapping, rqtl_mapping, qtlreaper_map
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 def do_mapping_for_api(start_vars):
     assert('db' in start_vars)
     assert('trait_id' in start_vars)
@@ -74,7 +75,6 @@ def do_mapping_for_api(start_vars):
         return result_markers, None
 
 
-
 def initialize_parameters(start_vars, dataset, this_trait):
     mapping_params = {}
 
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index b0559a07..4f9cc6e5 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -27,10 +27,12 @@ logger = utility.logger.getLogger(__name__)
 
 version = "pre1"
 
+
 @app.route("/api/v_{}/".format(version))
 def hello_world():
     return flask.jsonify({"hello": "world"})
 
+
 @app.route("/api/v_{}/species".format(version))
 def get_species_list():
     results = g.db.execute("SELECT SpeciesId, Name, FullName, TaxonomyId FROM Species;")
@@ -47,6 +49,7 @@ def get_species_list():
 
     return flask.jsonify(species_list)
 
+
 @app.route("/api/v_{}/species/<path:species_name>".format(version))
 @app.route("/api/v_{}/species/<path:species_name>.<path:file_format>".format(version))
 def get_species_info(species_name, file_format="json"):
@@ -64,6 +67,7 @@ def get_species_info(species_name, file_format="json"):
     
     return flask.jsonify(species_dict)
 
+
 @app.route("/api/v_{}/groups".format(version))
 @app.route("/api/v_{}/groups/<path:species_name>".format(version))
 def get_groups_list(species_name=None):
@@ -102,6 +106,7 @@ def get_groups_list(species_name=None):
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/group/<path:group_name>".format(version))
 @app.route("/api/v_{}/group/<path:group_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/group/<path:species_name>/<path:group_name>".format(version))
@@ -145,6 +150,7 @@ def get_group_info(group_name, species_name=None, file_format="json"):
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/datasets/<path:group_name>".format(version))
 @app.route("/api/v_{}/datasets/<path:species_name>/<path:group_name>".format(version))
 def get_datasets_for_group(group_name, species_name=None):
@@ -197,6 +203,7 @@ def get_datasets_for_group(group_name, species_name=None):
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/dataset/<path:dataset_name>".format(version))
 @app.route("/api/v_{}/dataset/<path:dataset_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/dataset/<path:group_name>/<path:dataset_name>".format(version))
@@ -302,6 +309,7 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/traits/<path:dataset_name>".format(version), methods=("GET",))
 @app.route("/api/v_{}/traits/<path:dataset_name>.<path:file_format>".format(version), methods=("GET",))
 def fetch_traits(dataset_name, file_format="json"):
@@ -430,6 +438,7 @@ def fetch_traits(dataset_name, file_format="json"):
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/sample_data/<path:dataset_name>".format(version))
 @app.route("/api/v_{}/sample_data/<path:dataset_name>.<path:file_format>".format(version))
 def all_sample_data(dataset_name, file_format="csv"):
@@ -536,6 +545,7 @@ def all_sample_data(dataset_name, file_format="csv"):
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/sample_data/<path:dataset_name>/<path:trait_name>".format(version))
 @app.route("/api/v_{}/sample_data/<path:dataset_name>/<path:trait_name>.<path:file_format>".format(version))
 def trait_sample_data(dataset_name, trait_name, file_format="json"):
@@ -625,6 +635,7 @@ def trait_sample_data(dataset_name, trait_name, file_format="json"):
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="") 
 
+
 @app.route("/api/v_{}/trait/<path:dataset_name>/<path:trait_name>".format(version))
 @app.route("/api/v_{}/trait/<path:dataset_name>/<path:trait_name>.<path:file_format>".format(version))
 @app.route("/api/v_{}/trait_info/<path:dataset_name>/<path:trait_name>".format(version))
@@ -694,6 +705,7 @@ def get_trait_info(dataset_name, trait_name, file_format="json"):
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/correlation".format(version), methods=("GET",))
 def get_corr_results():
     results = correlation.do_correlation(request.args)
@@ -703,6 +715,7 @@ def get_corr_results():
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/mapping".format(version), methods=("GET",))
 def get_mapping_results():
     results, format = mapping.do_mapping_for_api(request.args)
@@ -726,6 +739,7 @@ def get_mapping_results():
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
+
 @app.route("/api/v_{}/genotypes/<string:file_format>/<string:group_name>/<string:dataset_name>.zip".format(version))
 @app.route("/api/v_{}/genotypes/<string:file_format>/<string:group_name>/<string:dataset_name>".format(version))
 @app.route("/api/v_{}/genotypes/<string:file_format>/<string:group_name>.zip".format(version))
@@ -813,6 +827,7 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
 
     return output
 
+
 @app.route("/api/v_{}/gen_dropdown".format(version), methods=("GET",))
 def gen_dropdown_menu():
     results = gen_menu.gen_dropdown_json()
@@ -822,6 +837,7 @@ def gen_dropdown_menu():
     else:
         return return_error(code=500, source=request.url_rule.rule, title="Some error occurred", details="")
 
+
 def return_error(code, source, title, details):
     json_ob = {"errors": [
         {
@@ -834,6 +850,7 @@ def return_error(code, source, title, details):
 
     return flask.jsonify(json_ob)
 
+
 def get_dataset_trait_ids(dataset_name, start_vars):
 
     if 'limit_to' in start_vars:
@@ -906,6 +923,7 @@ def get_dataset_trait_ids(dataset_name, start_vars):
         dataset_id = results[0][2]
         return trait_ids, trait_names, data_type, dataset_id
 
+
 def get_samplelist(dataset_name):
     group_id = get_group_id_from_dataset(dataset_name)
 
@@ -922,6 +940,7 @@ def get_samplelist(dataset_name):
 
     return samplelist
 
+
 def get_group_id_from_dataset(dataset_name):
     if "Publish" in dataset_name:
         query = """
@@ -962,6 +981,7 @@ def get_group_id_from_dataset(dataset_name):
     else:
         return None
 
+
 def get_group_id(group_name):
     query = """
                SELECT InbredSet.Id
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 6a1b88ca..61f73106 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -40,6 +40,7 @@ def process_traits(unprocessed_traits):
 
     return traits
 
+
 def report_change(len_before, len_now):
     new_length = len_now - len_before
     if new_length:
@@ -48,6 +49,7 @@ def report_change(len_before, len_now):
     else:
         logger.debug("No new traits were added.")
 
+
 @app.route("/collections/store_trait_list", methods=('POST',))
 def store_traits_list():
    params = request.form
@@ -59,6 +61,7 @@ def store_traits_list():
 
    return hash
 
+
 @app.route("/collections/add")
 def collections_add():
 
@@ -82,6 +85,7 @@ def collections_add():
                                 collections=collections,
                               )
 
+
 @app.route("/collections/new")
 def collections_new():
     params = request.args
@@ -118,6 +122,7 @@ def collections_new():
         # CauseAnError
         pass
 
+
 def create_new(collection_name):
     params = request.args
 
@@ -133,6 +138,7 @@ def create_new(collection_name):
 
     return redirect(url_for('view_collection', uc_id=uc_id))
 
+
 @app.route("/collections/list")
 def list_collections():
     params = request.args
@@ -143,6 +149,7 @@ def list_collections():
                             collections=user_collections,
                             )
 
+
 @app.route("/collections/remove", methods=('POST',))
 def remove_traits():
     params = request.form
@@ -216,6 +223,7 @@ def view_collection():
                            **collection_info
                            )
 
+
 @app.route("/collections/change_name", methods=('POST',))
 def change_collection_name():
     params = request.form
diff --git a/wqflask/wqflask/correlation/corr_scatter_plot.py b/wqflask/wqflask/correlation/corr_scatter_plot.py
index 22941ad5..6afea715 100644
--- a/wqflask/wqflask/correlation/corr_scatter_plot.py
+++ b/wqflask/wqflask/correlation/corr_scatter_plot.py
@@ -11,6 +11,7 @@ import numpy as np
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class CorrScatterPlot:
     """Page that displays a correlation scatterplot with a line fitted to it"""
 
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index 051ac1cb..e2fe1ff4 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -172,7 +172,6 @@ class CorrelationResults:
             self.correlation_data = collections.OrderedDict(sorted(list(self.correlation_data.items()),
                                                                    key=lambda t: -abs(t[1][0])))
 
-
             # ZS: Convert min/max chromosome to an int for the location range option
             range_chr_as_int = None
             for order_id, chr_info in list(self.dataset.species.chromosomes.chromosomes.items()):
@@ -348,7 +347,6 @@ class CorrelationResults:
             else:
                 trait.lit_corr = 0
 
-
     def do_lit_correlation_for_all_traits(self):
         input_trait_mouse_gene_id = self.convert_to_mouse_gene_id(self.dataset.group.species.lower(), self.this_trait.geneid)
 
@@ -484,6 +482,7 @@ def do_bicor(this_trait_vals, target_trait_vals):
 
     return the_r, the_p
 
+
 def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_api=False):
     results_list = []
     for i, trait in enumerate(corr_results):
@@ -574,6 +573,7 @@ def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_ap
 
     return json.dumps(results_list)
 
+
 def get_header_fields(data_type, corr_method):
     if data_type == "ProbeSet":
         if corr_method == "spearman":
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index 94c8931f..331cb1dc 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -233,6 +233,7 @@ class CorrelationMatrix:
             loadings_array.append(loadings_row)
         return loadings_array
 
+
 def export_corr_matrix(corr_results):
     corr_matrix_filename = "corr_matrix_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
     matrix_export_path = "{}{}.csv".format(GENERATED_TEXT_DIR, corr_matrix_filename)
@@ -263,6 +264,7 @@ def export_corr_matrix(corr_results):
 
     return corr_matrix_filename, matrix_export_path
 
+
 def zScore(trait_data_array):
     NN = len(trait_data_array[0])
     if NN < 10:
@@ -283,6 +285,7 @@ def zScore(trait_data_array):
             i += 1
         return trait_data_array
 
+
 def sortEigenVectors(vector):
     try:
         eigenValues = vector[0].tolist()
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index 2fa90a93..ec66e59f 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -39,6 +39,7 @@ r_write_table = ro.r["write.table"]         # Map the write.table function
 r_data_frame = ro.r["data.frame"]         # Map the write.table function
 r_as_numeric = ro.r["as.numeric"]         # Map the write.table function
 
+
 class CTL:
     def __init__(self):
         logger.info("Initialization of CTL")
diff --git a/wqflask/wqflask/database.py b/wqflask/wqflask/database.py
index b6e85494..e743c4b3 100644
--- a/wqflask/wqflask/database.py
+++ b/wqflask/wqflask/database.py
@@ -17,6 +17,7 @@ db_session = scoped_session(sessionmaker(autocommit=False,
 Base = declarative_base()
 Base.query = db_session.query_property()
 
+
 def init_db():
     # import all modules here that might define models so that
     # they will be registered properly on the metadata.  Otherwise
@@ -27,4 +28,5 @@ def init_db():
     Base.metadata.create_all(bind=engine)
     logger.info("Done creating all model metadata")
 
+
 init_db()
diff --git a/wqflask/wqflask/db_info.py b/wqflask/wqflask/db_info.py
index 25e624ef..c7558ed8 100644
--- a/wqflask/wqflask/db_info.py
+++ b/wqflask/wqflask/db_info.py
@@ -90,6 +90,7 @@ class InfoPage:
         except Exception as e:
             pass
 
+
 def process_query_results(results):
     info_ob = {
         'info_page_name': results[0],
diff --git a/wqflask/wqflask/do_search.py b/wqflask/wqflask/do_search.py
index 115182e4..7442dc72 100644
--- a/wqflask/wqflask/do_search.py
+++ b/wqflask/wqflask/do_search.py
@@ -73,6 +73,7 @@ class DoSearch:
         else:
             return None
 
+
 class MrnaAssaySearch(DoSearch):
     """A search within an expression dataset, including mRNA, protein, SNP, but not phenotype or metabolites"""
 
@@ -296,6 +297,7 @@ class PhenotypeSearch(DoSearch):
 
         return self.execute(query)
 
+
 class GenotypeSearch(DoSearch):
     """A search within a genotype dataset"""
 
@@ -339,7 +341,6 @@ class GenotypeSearch(DoSearch):
 
         from_clause = self.normalize_spaces(from_clause)
 
-
         if self.search_term[0] == "*":
             query = (self.base_query +
                     """WHERE Geno.Id = GenoXRef.GenoId
@@ -367,6 +368,7 @@ class GenotypeSearch(DoSearch):
 
         return self.execute(self.query)
 
+
 class RifSearch(MrnaAssaySearch):
     """Searches for traits with a Gene RIF entry including the search term."""
 
@@ -390,6 +392,7 @@ class RifSearch(MrnaAssaySearch):
 
         return self.execute(query)
 
+
 class WikiSearch(MrnaAssaySearch):
     """Searches GeneWiki for traits other people have annotated"""
 
@@ -415,6 +418,7 @@ class WikiSearch(MrnaAssaySearch):
 
         return self.execute(query)
 
+
 class GoSearch(MrnaAssaySearch):
     """Searches for synapse-associated genes listed in the Gene Ontology."""
 
@@ -449,6 +453,8 @@ class GoSearch(MrnaAssaySearch):
         return self.execute(query)
 
 # ZS: Not sure what the best way to deal with LRS searches is
+
+
 class LrsSearch(DoSearch):
     """Searches for genes with a QTL within the given LRS values
 
@@ -526,7 +532,6 @@ class LrsSearch(DoSearch):
 
         return where_clause
 
-
     def run(self):
 
         self.from_clause = self.get_from_clause()
@@ -550,6 +555,7 @@ class MrnaLrsSearch(LrsSearch, MrnaAssaySearch):
 
         return self.execute(self.query)
 
+
 class PhenotypeLrsSearch(LrsSearch, PhenotypeSearch):
 
     for search_key in ('LRS', 'LOD'):
@@ -649,6 +655,7 @@ class CisTransLrsSearch(DoSearch):
 
         return where_clause
 
+
 class CisLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
     """
     Searches for genes on a particular chromosome with a cis-eQTL within the given LRS values
@@ -680,6 +687,7 @@ class CisLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
 
         return self.execute(self.query)
 
+
 class TransLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
     """Searches for genes on a particular chromosome with a cis-eQTL within the given LRS values
 
@@ -744,6 +752,7 @@ class MeanSearch(MrnaAssaySearch):
 
         return self.execute(self.query)
 
+
 class RangeSearch(MrnaAssaySearch):
     """Searches for genes with a range of expression varying between two values"""
 
@@ -779,6 +788,7 @@ class RangeSearch(MrnaAssaySearch):
 
         return self.execute(self.query)
 
+
 class PositionSearch(DoSearch):
     """Searches for genes/markers located within a specified range on a specified chromosome"""
 
@@ -800,7 +810,6 @@ class PositionSearch(DoSearch):
                                                               self.dataset.type,
                                                               max(self.mb_min, self.mb_max))
 
-
         return where_clause
 
     def get_chr(self):
@@ -819,6 +828,7 @@ class PositionSearch(DoSearch):
 
         return self.execute(self.query)
 
+
 class MrnaPositionSearch(PositionSearch, MrnaAssaySearch):
     """Searches for genes located within a specified range on a specified chromosome"""
 
@@ -832,6 +842,7 @@ class MrnaPositionSearch(PositionSearch, MrnaAssaySearch):
 
         return self.execute(self.query)
 
+
 class GenotypePositionSearch(PositionSearch, GenotypeSearch):
     """Searches for genes located within a specified range on a specified chromosome"""
 
@@ -845,6 +856,7 @@ class GenotypePositionSearch(PositionSearch, GenotypeSearch):
 
         return self.execute(self.query)
 
+
 class PvalueSearch(MrnaAssaySearch):
     """Searches for traits with a permutationed p-value between low and high"""
 
@@ -878,6 +890,7 @@ class PvalueSearch(MrnaAssaySearch):
         logger.sql(self.query)
         return self.execute(self.query)
 
+
 class AuthorSearch(PhenotypeSearch):
     """Searches for phenotype traits with specified author(s)"""
 
@@ -900,6 +913,7 @@ def is_number(s):
     except ValueError:
         return False
 
+
 def get_aliases(symbol, species):
     if species == "mouse":
         symbol_string = symbol.capitalize()
@@ -923,6 +937,7 @@ def get_aliases(symbol, species):
 
     return filtered_aliases
 
+
 if __name__ == "__main__":
     # Usually this will be used as a library, but call it from the command line for testing
     # And it runs the code below
diff --git a/wqflask/wqflask/docs.py b/wqflask/wqflask/docs.py
index 207767c4..81424b9c 100644
--- a/wqflask/wqflask/docs.py
+++ b/wqflask/wqflask/docs.py
@@ -5,6 +5,7 @@ from flask import g
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class Docs:
 
     def __init__(self, entry, start_vars={}):
@@ -23,7 +24,6 @@ class Docs:
             self.title = result[0]
             self.content = result[1].decode("utf-8")
 
-
         self.editable = "false"
         # ZS: Removing option to edit to see if text still gets vandalized
         try:
diff --git a/wqflask/wqflask/export_traits.py b/wqflask/wqflask/export_traits.py
index 95c20673..d0745ef7 100644
--- a/wqflask/wqflask/export_traits.py
+++ b/wqflask/wqflask/export_traits.py
@@ -15,6 +15,7 @@ from pprint import pformat as pf
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 def export_search_results_csv(targs):
 
     table_data = json.loads(targs['export_data'])
@@ -132,6 +133,7 @@ def export_search_results_csv(targs):
 
     return file_list
 
+
 def sort_traits_by_group(trait_list=[]):
     traits_by_group = {}
     for trait in trait_list:
diff --git a/wqflask/wqflask/external_tools/send_to_bnw.py b/wqflask/wqflask/external_tools/send_to_bnw.py
index 9836eb9c..1556c6a0 100644
--- a/wqflask/wqflask/external_tools/send_to_bnw.py
+++ b/wqflask/wqflask/external_tools/send_to_bnw.py
@@ -24,6 +24,7 @@ from utility import helper_functions, corr_result_helpers
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class SendToBNW:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
diff --git a/wqflask/wqflask/external_tools/send_to_geneweaver.py b/wqflask/wqflask/external_tools/send_to_geneweaver.py
index 36f1b8e5..c55c43e6 100644
--- a/wqflask/wqflask/external_tools/send_to_geneweaver.py
+++ b/wqflask/wqflask/external_tools/send_to_geneweaver.py
@@ -29,6 +29,7 @@ from utility import helper_functions, corr_result_helpers
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class SendToGeneWeaver:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
@@ -58,6 +59,7 @@ class SendToGeneWeaver:
                                  'list': ",".join(trait_name_list),
                                }
 
+
 def get_trait_name_list(trait_list):
     name_list = []
     for trait_db in trait_list:
@@ -65,6 +67,7 @@ def get_trait_name_list(trait_list):
 
     return name_list
 
+
 def test_chip(trait_list):
     final_chip_name = ""
 
diff --git a/wqflask/wqflask/external_tools/send_to_webgestalt.py b/wqflask/wqflask/external_tools/send_to_webgestalt.py
index f50eeb8b..6b78725c 100644
--- a/wqflask/wqflask/external_tools/send_to_webgestalt.py
+++ b/wqflask/wqflask/external_tools/send_to_webgestalt.py
@@ -29,6 +29,7 @@ from utility import helper_functions, corr_result_helpers
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class SendToWebGestalt:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
@@ -69,6 +70,7 @@ class SendToWebGestalt:
             else:
                 self.hidden_vars['organism'] = "others"
 
+
 def test_chip(trait_list):
     final_chip_name = ""
 
@@ -113,6 +115,7 @@ def test_chip(trait_list):
 
     return chip_name
 
+
 def gen_gene_id_list(trait_list):
     trait_name_list = []
     gene_id_list = []
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index f29c0e4d..92a65112 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -12,6 +12,7 @@ from utility.redis_tools import get_user_groups, get_group_info, save_user, crea
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 @app.route("/groups/manage", methods=('GET', 'POST'))
 def manage_groups():
    params = request.form if request.form else request.args
@@ -21,6 +22,7 @@ def manage_groups():
       admin_groups, member_groups = get_user_groups(g.user_session.user_id)
       return render_template("admin/group_manager.html", admin_groups=admin_groups, member_groups=member_groups)
 
+
 @app.route("/groups/view", methods=('GET', 'POST'))
 def view_group():
    params = request.form if request.form else request.args
@@ -58,6 +60,7 @@ def view_group():
 
    return render_template("admin/view_group.html", group_info=group_info, admins=admins_info, members=members_info, user_is_admin=user_is_admin, resources=resources_info)
 
+
 @app.route("/groups/remove", methods=('POST',))
 def remove_groups():
    group_ids_to_remove = request.form['selected_group_ids']
@@ -66,6 +69,7 @@ def remove_groups():
 
    return redirect(url_for('manage_groups'))
 
+
 @app.route("/groups/remove_users", methods=('POST',))
 def remove_users():
    group_id = request.form['group_id']
@@ -77,6 +81,7 @@ def remove_users():
 
    return redirect(url_for('view_group', id=group_id))
 
+
 @app.route("/groups/add_<path:user_type>", methods=('POST',))
 def add_users(user_type='members'):
    group_id = request.form['group_id']
@@ -89,6 +94,7 @@ def add_users(user_type='members'):
 
    return redirect(url_for('view_group', id=group_id))
 
+
 @app.route("/groups/change_name", methods=('POST',))
 def change_name():
    group_id = request.form['group_id']
@@ -97,6 +103,7 @@ def change_name():
 
    return new_name
 
+
 @app.route("/groups/create", methods=('GET', 'POST'))
 def add_or_edit_group():
    params = request.form if request.form else request.args
@@ -125,6 +132,8 @@ def add_or_edit_group():
       return render_template("admin/create_group.html")
 
 # ZS: Will integrate this later, for now just letting users be added directly
+
+
 def send_group_invites(group_id, user_email_list=[], user_type="members"):
    for user_email in user_email_list:
       user_details = get_user_by_unique_column("email_address", user_email)
diff --git a/wqflask/wqflask/gsearch.py b/wqflask/wqflask/gsearch.py
index 8cb81dcc..a21dae84 100644
--- a/wqflask/wqflask/gsearch.py
+++ b/wqflask/wqflask/gsearch.py
@@ -18,6 +18,7 @@ from utility.type_checking import is_float, is_int, is_str, get_float, get_int,
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class GSearch:
 
     def __init__(self, kw):
diff --git a/wqflask/wqflask/heatmap/heatmap.py b/wqflask/wqflask/heatmap/heatmap.py
index f8ef7028..0b477446 100644
--- a/wqflask/wqflask/heatmap/heatmap.py
+++ b/wqflask/wqflask/heatmap/heatmap.py
@@ -14,6 +14,7 @@ Redis = Redis()
 
 logger = getLogger(__name__)
 
+
 class Heatmap:
 
     def __init__(self, start_vars, temp_uuid):
@@ -132,6 +133,7 @@ class Heatmap:
                 else:
                     self.trait_results[this_trait.name].append(float(qtl['lrs_value']))
 
+
 def gen_pheno_txt_file(samples, vals, filename):
     """Generates phenotype file for GEMMA"""
 
@@ -151,6 +153,7 @@ def gen_pheno_txt_file(samples, vals, filename):
         values_string = "\t".join(filtered_vals_list)
         outfile.write(values_string)
 
+
 def parse_reaper_output(gwa_filename):
     included_markers = []
     p_values = []
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index 9779878e..8dd1c7c0 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -4,6 +4,8 @@ from flask import Flask, g
 
 # Just return a list of dictionaries
 # each dictionary contains sub-dictionary
+
+
 def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 	fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
 	'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index 3753d1ce..5c7b81dd 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -509,9 +509,6 @@ class DisplayMappingResults:
             self.graphHeight = self.graphHeight + 2 * (self.NR_INDIVIDUALS + 10) * self.EACH_GENE_HEIGHT
 # END HaplotypeAnalyst
 
-
-
-
         #########################
         # Get the sorting column
         #########################
@@ -1640,7 +1637,6 @@ class DisplayMappingResults:
                                                  geneYLocation + 2 *ind*self.EACH_GENE_HEIGHT + 2*self.EACH_GENE_HEIGHT*zoom)),
                                             outline=outlineColor, fill=fillColor)
 
-
                                     COORDS = "%d, %d, %d, %d" % (geneStartPix, geneYLocation + ind * self.EACH_GENE_HEIGHT, geneEndPix + 1, (geneYLocation + ind * self.EACH_GENE_HEIGHT))
                                     TITLE = "Strain: %s, marker (%s) \n Position  %2.3f Mb." % (samplelist[k], _chr[j].name, float(txStart))
                                     HREF = ''
@@ -1663,7 +1659,6 @@ class DisplayMappingResults:
                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
                                         fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
-
                             if lastGene == 0:
                                 draw_rotated_text(
                                     canvas, text="%s" % (_chr[j].name),
@@ -2085,7 +2080,6 @@ class DisplayMappingResults:
         im_drawer.line(xy=((xLeftOffset, yZero), (xLeftOffset + plotWidth, yZero)),
                        fill=BLACK, width=X_AXIS_THICKNESS)  # Draw the X axis itself
 
-
     def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
@@ -2427,7 +2421,6 @@ class DisplayMappingResults:
 
                 yLRS = yZero - (item / LRS_LOD_Max) * LRSHeightThresh
 
-
                 if 'lrs_value' in qtlresult:
                     if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
                         if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
@@ -2621,7 +2614,6 @@ class DisplayMappingResults:
                                 # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
 
-
         # draw additive scale
         if not self.multipleInterval and self.additiveChecked:
             additiveScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
@@ -2653,7 +2645,6 @@ class DisplayMappingResults:
             xy=((xLeftOffset, yZero), (xLeftOffset, yTopOffset + 30 * (zoom - 1))),
             fill=self.LRS_COLOR, width=1 * zoom)  # the blue line running up the y axis
 
-
     def drawGraphBackground(self, canvas, gifmap, offset=(80, 120, 80, 50), zoom=1, startMb= None, endMb = None):
         # conditions
         # multiple Chromosome view
diff --git a/wqflask/wqflask/marker_regression/plink_mapping.py b/wqflask/wqflask/marker_regression/plink_mapping.py
index e6c78536..22a50bb8 100644
--- a/wqflask/wqflask/marker_regression/plink_mapping.py
+++ b/wqflask/wqflask/marker_regression/plink_mapping.py
@@ -8,11 +8,11 @@ from utility.tools import flat_files, PLINK_COMMAND
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 def run_plink(this_trait, dataset, species, vals, maf):
     plink_output_filename = webqtlUtil.genRandStr(f"{dataset.group.name}_{this_trait.name}_")
     gen_pheno_txt_file(dataset, vals)
 
-    
     plink_command = f"{PLINK_COMMAND}  --noweb --bfile {flat_files('mapping')}/{dataset.group.name} --no-pheno --no-fid --no-parents --no-sex --maf {maf} --out { TMPDIR}{plink_output_filename} --assoc "
     logger.debug("plink_command:", plink_command)
 
@@ -25,6 +25,7 @@ def run_plink(this_trait, dataset, species, vals, maf):
 
     return dataset.group.markers.markers
 
+
 def gen_pheno_txt_file(this_dataset, vals):
     """Generates phenotype file for GEMMA/PLINK"""
 
@@ -42,6 +43,7 @@ def gen_pheno_txt_file(this_dataset, vals):
                 this_val = vals[i]
             outfile.write("0 " + line[1] + " " + line[2] + " " + line[3] + " " + line[4] + " " + str(this_val) + "\n")
 
+
 def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename=''):
     ped_sample_list = get_samples_from_ped_file(dataset)
     output_file = open(f"{TMPDIR}{pheno_filename}.txt", "wb")
@@ -77,6 +79,8 @@ def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename=''):
     output_file.close()
 
 # get strain name from ped file in order
+
+
 def get_samples_from_ped_file(dataset):
     ped_file = open(f"{flat_files('mapping')}{dataset.group.name}.ped", "r")
     line = ped_file.readline()
@@ -93,6 +97,7 @@ def get_samples_from_ped_file(dataset):
 
     return sample_list
 
+
 def parse_plink_output(output_filename, species):
     plink_results = {}
 
@@ -154,6 +159,8 @@ def parse_plink_output(output_filename, species):
 # function: convert line from str to list;
 # output: lineList list
 #######################################################
+
+
 def build_line_list(line=""):
     line_list = line.strip().split(' ')  # irregular number of whitespaces between columns
     line_list = [item for item in line_list if item != '']
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index dd044cb0..313c40ca 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -8,6 +8,7 @@ from utility.tools import flat_files, REAPER_COMMAND, TEMPDIR
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boot_check, num_bootstrap, do_control, control_marker, manhattan_plot, first_run=True, output_files=None):
     """Generates p-values for each marker using qtlreaper"""
 
@@ -73,6 +74,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
     return (marker_obs, permu_vals, suggestive, significant, bootstrap_vals, 
         [output_filename, permu_filename, bootstrap_filename])
 
+
 def gen_pheno_txt_file(samples, vals, trait_filename):
     """Generates phenotype file for GEMMA"""
 
@@ -92,6 +94,7 @@ def gen_pheno_txt_file(samples, vals, trait_filename):
         values_string = "\t".join(filtered_vals_list)
         outfile.write(values_string)
 
+
 def parse_reaper_output(gwa_filename, permu_filename, bootstrap_filename):
     included_markers = []
     p_values = []
@@ -163,6 +166,7 @@ def parse_reaper_output(gwa_filename, permu_filename, bootstrap_filename):
 
     return marker_obs, permu_vals, bootstrap_vals
 
+
 def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_data, num_perm, bootCheck, num_bootstrap, do_control, control_marker, manhattan_plot):
     genotype = dataset.group.read_genotype_file(use_reaper=True)
 
@@ -255,6 +259,7 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         qtl_results.append(qtl)
     return qtl_results, json_data, perm_output, suggestive, significant, bootstrap_results
 
+
 def natural_sort(marker_list):
     """
     Function to naturally sort numbers + strings, adopted from user Mark Byers here: https://stackoverflow.com/questions/4836710/does-python-have-a-built-in-function-for-string-natural-sort
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index 2bd94512..588600f5 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -16,6 +16,8 @@ import utility.logger
 logger = utility.logger.getLogger(__name__)
 
 # Get a trait's type (numeric, categorical, etc) from the DB
+
+
 def get_trait_data_type(trait_db_string):
     logger.info("get_trait_data_type");
     the_query = "SELECT value FROM TraitMetadata WHERE type='trait_data_type'"
@@ -133,6 +135,7 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
         else:
             return process_rqtl_results(result_data_frame, dataset.group.species)
 
+
 def generate_cross_from_rdata(dataset):
     rdata_location = locate(dataset.group.name + ".RData", "genotype/rdata")
     ro.r("""
@@ -143,6 +146,7 @@ def generate_cross_from_rdata(dataset):
        }
     """ % (rdata_location))
 
+
 def generate_cross_from_geno(dataset, scale_units):        # TODO: Need to figure out why some genofiles have the wrong format and don't convert properly
 
     ro.r("""
@@ -187,6 +191,7 @@ def generate_cross_from_geno(dataset, scale_units):        # TODO: Need to figur
       }
     """ % (dataset.group.genofile, scale_units))
 
+
 def add_perm_strata(cross, perm_strata):
     col_string = 'c("the_strata")'
     perm_strata_string = "c("
@@ -201,6 +206,7 @@ def add_perm_strata(cross, perm_strata):
 
     return cross, strata_ob
 
+
 def sanitize_rqtl_phenotype(vals):
     pheno_as_string = "c("
     for i, val in enumerate(vals):
@@ -218,6 +224,7 @@ def sanitize_rqtl_phenotype(vals):
 
     return pheno_as_string
 
+
 def sanitize_rqtl_names(vals):
     pheno_as_string = "c("
     for i, val in enumerate(vals):
@@ -235,12 +242,14 @@ def sanitize_rqtl_names(vals):
 
     return pheno_as_string
 
+
 def add_phenotype(cross, pheno_as_string, col_name):
     ro.globalenv["the_cross"] = cross
     ro.r('pheno <- data.frame(pull.pheno(the_cross))')
     ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = as.numeric(' + pheno_as_string + '))')
     return ro.r["the_cross"]
 
+
 def add_categorical_covar(cross, covar_as_string, i):
     ro.globalenv["the_cross"] = cross
     logger.info("cross set"); 
@@ -275,12 +284,14 @@ def add_names(cross, names_as_string, col_name):
     ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = ' + names_as_string + ')')
     return ro.r["the_cross"]
 
+
 def pull_var(var_name, cross, var_string):
     ro.globalenv["the_cross"] = cross
     ro.r(var_name + ' <- pull.pheno(the_cross, ' + var_string + ')')
 
     return ro.r[var_name]
 
+
 def add_cofactors(cross, this_dataset, covariates, samples):
     ro.numpy2ri.activate()
 
@@ -341,6 +352,7 @@ def add_cofactors(cross, this_dataset, covariates, samples):
     covars_ob = pull_var("trait_covars", cross, covar_name_string)
     return cross, covars_ob
 
+
 def create_marker_covariates(control_marker, cross):
     ro.globalenv["the_cross"] = cross
     ro.r('genotypes <- pull.geno(the_cross)')                             # Get the genotype matrix
@@ -358,6 +370,7 @@ def create_marker_covariates(control_marker, cross):
     # TODO: Create a design matrix from the marker covars for the markers in case of an F2, 4way, etc
     return ro.r["marker_covars"]
 
+
 def process_pair_scan_results(result):
     pair_scan_results = []
 
@@ -374,6 +387,7 @@ def process_pair_scan_results(result):
 
     return pair_scan_results
 
+
 def process_rqtl_perm_results(num_perm, results):
     perm_vals = []
     for line in str(results).split("\n")[1:(num_perm + 1)]:
@@ -386,6 +400,7 @@ def process_rqtl_perm_results(num_perm, results):
 
     return perm_output, suggestive, significant
 
+
 def process_rqtl_results(result, species_name):        # TODO: how to make this a one liner and not copy the stuff in a loop
     qtl_results = []
     output = [tuple([result[j][i] for j in range(result.ncol)]) for i in range(result.nrow)]
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index f1665570..31c58083 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -45,6 +45,7 @@ from base.webqtlConfig import TMPDIR, GENERATED_TEXT_DIR
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 class RunMapping:
 
     def __init__(self, start_vars, temp_uuid):
@@ -504,6 +505,7 @@ class RunMapping:
             trimmed_genotype_data.append(new_genotypes)
         return trimmed_genotype_data
 
+
 def export_mapping_results(dataset, trait, markers, results_path, mapping_scale, score_type, transform, covariates, n_samples):
     with open(results_path, "w+") as output_file:
         output_file.write("Time/Date: " + datetime.datetime.now().strftime("%x / %X") + "\n")
@@ -564,6 +566,7 @@ def export_mapping_results(dataset, trait, markers, results_path, mapping_scale,
             if i < (len(markers) - 1):
                 output_file.write("\n")
 
+
 def trim_markers_for_figure(markers):
     if 'p_wald' in list(markers[0].keys()):
         score_type = 'p_wald'
@@ -624,6 +627,7 @@ def trim_markers_for_figure(markers):
                 filtered_markers.append(marker)
     return filtered_markers
 
+
 def trim_markers_for_table(markers):
     if 'lod_score' in list(markers[0].keys()):
         sorted_markers = sorted(markers, key=lambda k: k['lod_score'], reverse=True)
@@ -637,6 +641,7 @@ def trim_markers_for_table(markers):
     else:
         return sorted_markers
 
+
 def write_input_for_browser(this_dataset, gwas_results, annotations):
     file_base = this_dataset.group.name + "_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
     gwas_filename = file_base + "_GWAS"
@@ -650,6 +655,7 @@ def write_input_for_browser(this_dataset, gwas_results, annotations):
 
     return [gwas_filename, annot_filename]
 
+
 def geno_db_exists(this_dataset):
     geno_db_name = this_dataset.group.name + "Geno"
     try:
@@ -658,6 +664,7 @@ def geno_db_exists(this_dataset):
     except:
         return "False"
 
+
 def get_chr_lengths(mapping_scale, mapping_method, dataset, qtl_results):
     chr_lengths = []
     if mapping_scale == "physic":
@@ -696,6 +703,7 @@ def get_chr_lengths(mapping_scale, mapping_method, dataset, qtl_results):
 
     return chr_lengths
 
+
 def get_genofile_samplelist(dataset):
     genofile_samplelist = []
 
@@ -706,6 +714,7 @@ def get_genofile_samplelist(dataset):
 
     return genofile_samplelist
 
+
 def get_perm_strata(this_trait, sample_list, categorical_vars, used_samples):
     perm_strata_strings = []
     for sample in used_samples:
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index 8abd6516..d7c9ef95 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -14,6 +14,7 @@ from sqlalchemy.orm import relationship
 
 from wqflask.database import Base, init_db
 
+
 class User(Base):
     __tablename__ = "user"
     id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
@@ -63,7 +64,6 @@ class User(Base):
             print("Couldn't display_num_collections:", why)
             return ""
 
-
     def get_collection_by_name(self, collection_name):
         try:
             collect = self.user_collections.filter_by(name=collection_name).first()
@@ -83,7 +83,6 @@ class User(Base):
     def login_count(self):
         return self.logins.filter_by(successful=True).count()
 
-
     @property
     def confirmed_at(self):
         if self.confirmed:
@@ -116,6 +115,7 @@ class User(Base):
         except IndexError:
             return None
 
+
 class Login(Base):
     __tablename__ = "login"
     id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
@@ -134,6 +134,7 @@ class Login(Base):
 
 ##################################################################################################
 
+
 class UserCollection(Base):
     __tablename__ = "user_collection"
     id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
@@ -158,12 +159,14 @@ class UserCollection(Base):
     def members_as_set(self):
         return set(json.loads(self.members))
 
+
 def display_collapsible(number):
     if number:
         return number
     else:
         return ""
 
+
 def user_uuid():
     """Unique cookie for a user"""
     user_uuid = request.cookies.get('user_uuid')
diff --git a/wqflask/wqflask/network_graph/network_graph.py b/wqflask/wqflask/network_graph/network_graph.py
index 93785a3a..e089643e 100644
--- a/wqflask/wqflask/network_graph/network_graph.py
+++ b/wqflask/wqflask/network_graph/network_graph.py
@@ -27,6 +27,7 @@ from utility import helper_functions
 from utility import corr_result_helpers
 from utility.tools import GN2_BRANCH_URL
 
+
 class NetworkGraph:
 
     def __init__(self, start_vars):
diff --git a/wqflask/wqflask/news.py b/wqflask/wqflask/news.py
index 861a93f2..e262dd51 100644
--- a/wqflask/wqflask/news.py
+++ b/wqflask/wqflask/news.py
@@ -1,5 +1,6 @@
 from flask import g
 
+
 class News:
 
     def __init__(self):
diff --git a/wqflask/wqflask/parser.py b/wqflask/wqflask/parser.py
index dfd374e2..6b836e20 100644
--- a/wqflask/wqflask/parser.py
+++ b/wqflask/wqflask/parser.py
@@ -24,6 +24,7 @@ from pprint import pformat as pf
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 def parse(pstring):
     """
 
diff --git a/wqflask/wqflask/pbkdf2.py b/wqflask/wqflask/pbkdf2.py
index 6346df03..1a965fc5 100644
--- a/wqflask/wqflask/pbkdf2.py
+++ b/wqflask/wqflask/pbkdf2.py
@@ -4,6 +4,8 @@ from werkzeug.security import safe_str_cmp as ssc
 
 # Replace this because it just wraps around Python3's internal
 # functions. Added this during migration.
+
+
 def pbkdf2_hex(data, salt, iterations=1000, keylen=24, hashfunc="sha1"):
     """Wrapper function of python's hashlib.pbkdf2_hmac.
     """
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index a1fe0f8f..4591710c 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -11,6 +11,7 @@ from utility.redis_tools import get_resource_info, get_group_info, get_groups_li
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 @app.route("/resources/manage", methods=('GET', 'POST'))
 def manage_resource():
     params = request.form if request.form else request.args
@@ -40,6 +41,7 @@ def manage_resource():
 
         return render_template("admin/manage_resource.html", owner_name=owner_display_name, resource_id=resource_id, resource_info=resource_info, default_mask=default_mask, group_masks=group_masks_with_names, admin_status=admin_status)
 
+
 @app.route("/search_for_users", methods=('POST',))
 def search_for_user():
     params = request.form
@@ -49,6 +51,7 @@ def search_for_user():
 
     return json.dumps(user_list)
 
+
 @app.route("/search_for_groups", methods=('POST',))
 def search_for_groups():
     params = request.form
@@ -65,6 +68,7 @@ def search_for_groups():
 
     return json.dumps(group_list)
 
+
 @app.route("/resources/change_owner", methods=('POST',))
 def change_owner():
     resource_id = request.form['resource_id']
@@ -81,6 +85,7 @@ def change_owner():
     else:
         return render_template("admin/change_resource_owner.html", resource_id=resource_id)
 
+
 @app.route("/resources/change_default_privileges", methods=('POST',))
 def change_default_privileges():
     resource_id = request.form['resource_id']
@@ -99,6 +104,7 @@ def change_default_privileges():
     else:
         return redirect(url_for("no_access_page"))
 
+
 @app.route("/resources/add_group", methods=('POST',))
 def add_group_to_resource():
     resource_id = request.form['resource_id']
@@ -125,6 +131,7 @@ def add_group_to_resource():
     else:
         return redirect(url_for("no_access_page"))
 
+
 def get_group_names(group_masks):
     group_masks_with_names = {}
     for group_id, group_mask in list(group_masks.items()):
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index 16eb1864..ed5f9bad 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -24,6 +24,7 @@ from utility.type_checking import is_str
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class SearchResultPage:
     #maxReturn = 3000
 
@@ -270,6 +271,7 @@ class SearchResultPage:
         else:
             return None
 
+
 def get_GO_symbols(a_search):
     query = """SELECT genes
                FROM GORef
@@ -287,6 +289,7 @@ def get_GO_symbols(a_search):
 
     return new_terms
 
+
 def insert_newlines(string, every=64):
     """ This is because it is seemingly impossible to change the width of the description column, so I'm just manually adding line breaks """
     lines = []
@@ -294,6 +297,7 @@ def insert_newlines(string, every=64):
         lines.append(string[i:i + every])
     return '\n'.join(lines)
 
+
 def get_aliases(symbol_list, species):
 
     updated_symbols = []
diff --git a/wqflask/wqflask/send_mail.py b/wqflask/wqflask/send_mail.py
index 86e8a558..299c866a 100644
--- a/wqflask/wqflask/send_mail.py
+++ b/wqflask/wqflask/send_mail.py
@@ -8,10 +8,12 @@ Redis = StrictRedis()
 
 import mailer
 
+
 def timestamp():
     ts = datetime.datetime.utcnow()
     return ts.isoformat()
 
+
 def main():
     while True:
         print("I'm alive!")
@@ -31,7 +33,6 @@ def main():
             process_message(msg)
 
 
-
 def process_message(msg):
     msg = json.loads(msg)
 
diff --git a/wqflask/wqflask/server_side.py b/wqflask/wqflask/server_side.py
index 48761fa0..8b3a4faa 100644
--- a/wqflask/wqflask/server_side.py
+++ b/wqflask/wqflask/server_side.py
@@ -1,7 +1,6 @@
 # handles server side table processing
 
 
-
 class ServerSideTable:
     """
         This class is used to do server-side processing
diff --git a/wqflask/wqflask/show_trait/SampleList.py b/wqflask/wqflask/show_trait/SampleList.py
index 388f831f..496dee57 100644
--- a/wqflask/wqflask/show_trait/SampleList.py
+++ b/wqflask/wqflask/show_trait/SampleList.py
@@ -8,6 +8,7 @@ from pprint import pformat as pf
 from utility import Plot
 from utility import Bunch
 
+
 class SampleList:
     def __init__(self,
                  dataset,
diff --git a/wqflask/wqflask/show_trait/export_trait_data.py b/wqflask/wqflask/show_trait/export_trait_data.py
index 379b746c..f0fcd27d 100644
--- a/wqflask/wqflask/show_trait/export_trait_data.py
+++ b/wqflask/wqflask/show_trait/export_trait_data.py
@@ -5,6 +5,7 @@ from functools import cmp_to_key
 from base.trait import create_trait
 from base import data_set
 
+
 def export_sample_table(targs):
 
     sample_data = json.loads(targs['export_data'])
@@ -28,6 +29,7 @@ def export_sample_table(targs):
 
     return trait_name, final_sample_data
 
+
 def get_export_metadata(trait_id, dataset_name):
     dataset = data_set.create_dataset(dataset_name)
     this_trait = create_trait(dataset=dataset,
@@ -64,6 +66,7 @@ def dict_to_sorted_list(dictionary):
     sorted_values = [item[1] for item in sorted_list]
     return sorted_values
 
+
 def cmp_samples(a, b):
     if b[0] == 'name':
         return 1
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index 7a0df94b..e5c67165 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -9,6 +9,7 @@ logger = getLogger(__name__)
 from base import species
 from base import webqtlConfig
 
+
 class SnpBrowser:
 
     def __init__(self, start_vars):
@@ -472,7 +473,6 @@ class SnpBrowser:
                 base_color_dict = {"A": "#C33232", "C": "#1569C7", "T": "#CFCF32", "G": "#32C332", 
                                    "t": "#FF6", "c": "#5CB3FF", "a": "#F66", "g": "#CF9", ":": "#FFFFFF", "-": "#FFFFFF", "?": "#FFFFFF"}
 
-
                 the_bases = []
                 for j, item in enumerate(allele_value_list):
                     if item and isinstance(item, str):
@@ -641,6 +641,7 @@ class SnpBrowser:
         # for i in range(n_click):
         #    href = url_for('snp_browser', first_run="false", chosen_strains_mouse=self.chosen_strains_mouse, chosen_strains_rat=self.chosen_strains_rat, variant=self.variant_type, species=self.species_name, gene_name=self.gene_name, chr=self.chr, start_mb=self.start_mb, end_mb=self.end_mb, limit_strains=self.limit_strains, domain=self.domain, function=self.function, criteria=self.criteria, score=self.score, diff_alleles=self.diff_alleles)
 
+
 def get_browser_sample_lists(species_id=1):
     strain_lists = {}
     mouse_strain_list = []
@@ -660,6 +661,7 @@ def get_browser_sample_lists(species_id=1):
 
     return strain_lists
 
+
 def get_header_list(variant_type, strains, species=None, empty_columns=None):
     if species == "Mouse":
         strain_list = strains['mouse']
@@ -715,6 +717,7 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
 
     return header_fields, empty_field_count, header_data_names
 
+
 def get_effect_details_by_category(effect_name=None, effect_value=None):
     gene_list = []
     transcript_list = []
@@ -764,6 +767,7 @@ def get_effect_details_by_category(effect_name=None, effect_value=None):
 
     return [gene_list, transcript_list, exon_list, function_list, function_detail_list]
 
+
 def get_effect_info(effect_list):
     domain = ""
     effect_detail_list = []
@@ -836,6 +840,7 @@ def get_effect_info(effect_list):
 
     return effect_info_dict
 
+
 def get_gene_id(species_id, gene_name):
     query = """
                 SELECT
@@ -853,6 +858,7 @@ def get_gene_id(species_id, gene_name):
     else:
         return ""
 
+
 def get_gene_id_name_dict(species_id, gene_name_list):
     gene_id_name_dict = {}
     if len(gene_name_list) == 0:
@@ -877,6 +883,7 @@ def get_gene_id_name_dict(species_id, gene_name_list):
 
     return gene_id_name_dict
 
+
 def check_if_in_gene(species_id, chr, mb):
     if species_id != 0:  # ZS: Check if this is necessary
         query = """SELECT geneId, geneSymbol
diff --git a/wqflask/wqflask/submit_bnw.py b/wqflask/wqflask/submit_bnw.py
index 4ad6f9e3..b21a88cc 100644
--- a/wqflask/wqflask/submit_bnw.py
+++ b/wqflask/wqflask/submit_bnw.py
@@ -5,5 +5,6 @@ from utility import helper_functions
 import utility.logger
 logger = utility.logger.getLogger(__name__)
 
+
 def get_bnw_input(start_vars):
     logger.debug("BNW VARS:", start_vars)
diff --git a/wqflask/wqflask/update_search_results.py b/wqflask/wqflask/update_search_results.py
index 08b4f9f5..07073d6a 100644
--- a/wqflask/wqflask/update_search_results.py
+++ b/wqflask/wqflask/update_search_results.py
@@ -10,6 +10,7 @@ from utility.benchmark import Bench
 from utility.logger import getLogger
 logger = getLogger(__name__)
 
+
 class GSearch:
 
     def __init__(self, kw):
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index 3f5b43ee..2a2f8484 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -29,9 +29,11 @@ from utility.tools import SMTP_CONNECT, SMTP_USERNAME, SMTP_PASSWORD, LOG_SQL_AL
 
 THREE_DAYS = 60 * 60 * 24 * 3
 
+
 def timestamp():
     return datetime.datetime.utcnow().isoformat()
 
+
 def basic_info():
     return dict(timestamp=timestamp(),
                 ip_address=request.remote_addr,
@@ -54,6 +56,7 @@ def encode_password(pass_gen_fields, unencrypted_password):
 
     return pass_gen_fields
 
+
 def set_password(password):
     pass_gen_fields = {
       "unencrypted_password": password,
@@ -71,6 +74,7 @@ def set_password(password):
 
     return encoded_password
 
+
 def get_signed_session_id(user):
     session_id = str(uuid.uuid4())
 
@@ -109,6 +113,7 @@ def get_signed_session_id(user):
     
     return session_id_signed
 
+
 def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
     """Send an E-mail through SMTP_CONNECT host. If SMTP_USERNAME is not
     'UNKNOWN' TLS is used
@@ -125,6 +130,7 @@ def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
         server.quit()
     logger.info("Successfully sent email to " + toaddr)
 
+
 def send_verification_email(user_details, template_name="email/user_verification.txt", key_prefix="verification_code", subject = "GeneNetwork e-mail verification"):
     verification_code = str(uuid.uuid4())
     key = key_prefix + ":" + verification_code
@@ -139,12 +145,14 @@ def send_verification_email(user_details, template_name="email/user_verification
     send_email(recipient, subject, body)
     return {"recipient": recipient, "subject": subject, "body": body}
 
+
 def send_invitation_email(user_email, temp_password, template_name="email/user_invitation.txt", subject= "You've been added to a GeneNetwork user group"):
     recipient = user_email
     body = render_template(template_name, temp_password)
     send_email(recipient, subject, body)
     return {"recipient": recipient, "subject": subject, "body": body}
 
+
 @app.route("/manage/verify_email")
 def verify_email():
     if 'code' in request.args:
@@ -160,6 +168,7 @@ def verify_email():
         else:
             flash("Invalid code: Password reset code does not exist or might have expired!", "error")
 
+
 @app.route("/n/login", methods=('GET', 'POST'))
 def login():
     params = request.form if request.form else request.args
@@ -232,6 +241,7 @@ def login():
 
                 return response
 
+
 @app.route("/n/login/github_oauth2", methods=('GET', 'POST'))
 def github_oauth2():
     from utility.tools import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, GITHUB_AUTH_URL
@@ -264,12 +274,14 @@ def github_oauth2():
     url = "/n/login?type=github&uid=" + user_details["user_id"]
     return redirect(url)
 
+
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
     result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
 
     return json.loads(result)
 
+
 @app.route("/n/login/orcid_oauth2", methods=('GET', 'POST'))
 def orcid_oauth2():
     from uuid import uuid4
@@ -308,6 +320,7 @@ def orcid_oauth2():
         flash("There was an error getting code from ORCID")
     return redirect(url)
 
+
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
     result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
@@ -325,6 +338,7 @@ def logout():
     response.set_cookie(UserSession.user_cookie_name, '', expires=0)
     return response
 
+
 @app.route("/n/forgot_password", methods=['GET'])
 def forgot_password():
     """Entry point for forgotten password"""
@@ -333,6 +347,7 @@ def forgot_password():
     print("ERRORS: ", errors)
     return render_template("new_security/forgot_password.html", errors=errors)
 
+
 def send_forgot_password_email(verification_email):
     from email.mime.multipart import MIMEMultipart
     from email.mime.text import MIMEText
@@ -365,6 +380,7 @@ def send_forgot_password_email(verification_email):
 
     return subject
 
+
 @app.route("/n/forgot_password_submit", methods=('POST',))
 def forgot_password_submit():
     """When a forgotten password form is submitted we get here"""
@@ -386,6 +402,7 @@ def forgot_password_submit():
         flash("You MUST provide an email", "alert-danger")
         return redirect(url_for("forgot_password"))
 
+
 @app.route("/n/password_reset", methods=['GET'])
 def password_reset():
     """Entry point after user clicks link in E-mail"""
@@ -405,6 +422,7 @@ def password_reset():
     else:
         return redirect(url_for("login"))
 
+
 @app.route("/n/password_reset_step2", methods=('POST',))
 def password_reset_step2():
     """Handle confirmation E-mail for password reset"""
@@ -422,6 +440,7 @@ def password_reset_step2():
     flash("Password changed successfully. You can now sign in.", "alert-info")
     return redirect(url_for('login'))
 
+
 def register_user(params):
         thank_you_mode = False
         errors = []
@@ -461,6 +480,7 @@ def register_user(params):
 
         return errors
 
+
 @app.route("/n/register", methods=('GET', 'POST'))
 def register():
     errors = []
@@ -478,6 +498,7 @@ def register():
 
     return render_template("new_security/register_user.html", values=params, errors=errors)
 
+
 @app.errorhandler(401)
 def unauthorized(error):
     return redirect(url_for('login'))
diff --git a/wqflask/wqflask/user_manager.py b/wqflask/wqflask/user_manager.py
index 013920f9..a9bd65e6 100644
--- a/wqflask/wqflask/user_manager.py
+++ b/wqflask/wqflask/user_manager.py
@@ -151,6 +151,7 @@ def verify_cookie(cookie):
     assert the_signature == actual_hmac_creation(the_uuid), "Uh-oh, someone tampering with the cookie?"
     return the_uuid
 
+
 def create_signed_cookie():
     the_uuid = str(uuid.uuid4())
     signature = actual_hmac_creation(the_uuid)
@@ -158,6 +159,7 @@ def create_signed_cookie():
     logger.debug("uuid_signed:", uuid_signed)
     return the_uuid, uuid_signed
 
+
 class UserSession:
     """Logged in user handling"""
 
@@ -341,6 +343,7 @@ class UserSession:
         Redis.delete(self.cookie_name)
         logger.debug("At end of delete_session")
 
+
 @app.before_request
 def get_cookie():
     logger.info("@app.before_request get cookie")
@@ -348,16 +351,20 @@ def get_cookie():
     g.cookie_session = AnonUser()
 
 # @app.after_request
+
+
 def set_cookie(response):
     if not request.cookies.get(g.cookie_session.cookie_name):
         response.set_cookie(g.cookie_session.cookie_name, g.cookie_session.cookie)
     return response
 
+
 class UsersManager:
     def __init__(self):
         self.users = model.User.query.all()
         logger.debug("Users are:", self.users)
 
+
 class UserManager:
     def __init__(self, kw):
         self.user_id = kw['user_id']
@@ -419,6 +426,7 @@ class RegisterUser:
         self.user.registration_info = json.dumps(basic_info(), sort_keys=True)
         save_user(self.user.__dict__, self.user.user_id)
 
+
 def set_password(password, user):
     pwfields = Bunch()
 
@@ -476,6 +484,7 @@ class VerificationEmail:
                                verification_code=verification_code)
         send_email(to, subject, body)
 
+
 class ForgotPasswordEmail(VerificationEmail):
     template_name = "email/forgot_password.txt"
     key_prefix = "forgot_password_code"
@@ -496,7 +505,6 @@ class ForgotPasswordEmail(VerificationEmail):
 
         save_verification_code(toaddr, verification_code)
 
-
         subject = self.subject
         body = render_template(
             self.template_name,
@@ -530,6 +538,8 @@ def basic_info():
                 user_agent=request.headers.get('User-Agent'))
 
 # @app.route("/manage/verify_email")
+
+
 def verify_email():
     user = DecodeUser(VerificationEmail.key_prefix).user
     user.confirmed = json.dumps(basic_info(), sort_keys=True)
@@ -544,6 +554,8 @@ def verify_email():
     return response
 
 # @app.route("/n/password_reset", methods=['GET'])
+
+
 def password_reset():
     """Entry point after user clicks link in E-mail"""
     logger.debug("in password_reset request.url is:", request.url)
@@ -568,6 +580,8 @@ def password_reset():
         return redirect(url_for("login"))
 
 # @app.route("/n/password_reset_step2", methods=('POST',))
+
+
 def password_reset_step2():
     """Handle confirmation E-mail for password reset"""
     logger.debug("in password_reset request.url is:", request.url)
@@ -577,7 +591,6 @@ def password_reset_step2():
 
     logger.debug("locals are:", locals())
 
-
     user = Bunch()
     password = request.form['password']
     set_password(password, user)
@@ -589,6 +602,7 @@ def password_reset_step2():
 
     return response
 
+
 class DecodeUser:
 
     def __init__(self, code_prefix):
@@ -612,6 +626,8 @@ class DecodeUser:
         return model.User.query.get(data['id'])
 
 # @app.route("/n/login", methods=('GET', 'POST'))
+
+
 def login():
     lu = LoginUser()
     login_type = request.args.get("type")
@@ -622,6 +638,8 @@ def login():
         return lu.standard_login()
 
 # @app.route("/n/login/github_oauth2", methods=('GET', 'POST'))
+
+
 def github_oauth2():
     from utility.tools import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET
     code = request.args.get("code")
@@ -646,6 +664,8 @@ def github_oauth2():
     return redirect(url)
 
 # @app.route("/n/login/orcid_oauth2", methods=('GET', 'POST'))
+
+
 def orcid_oauth2():
     from uuid import uuid4
     from utility.tools import ORCID_CLIENT_ID, ORCID_CLIENT_SECRET, ORCID_TOKEN_URL, ORCID_AUTH_URL
@@ -673,11 +693,13 @@ def orcid_oauth2():
         flash("There was an error getting code from ORCID")
     return redirect(url)
 
+
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
     result = requests.get(GITHUB_API_URL, params={"access_token": access_token})
     return result.json()
 
+
 class LoginUser:
     remember_time = 60 * 60 * 24 * 30  # One month in seconds
 
@@ -814,6 +836,8 @@ class LoginUser:
         db_session.commit()
 
 # @app.route("/n/logout")
+
+
 def logout():
     logger.debug("Logging out...")
     UserSession().delete_session()
@@ -833,6 +857,8 @@ def forgot_password():
     return render_template("new_security/forgot_password.html", errors=errors)
 
 # @app.route("/n/forgot_password_submit", methods=('POST',))
+
+
 def forgot_password_submit():
     """When a forgotten password form is submitted we get here"""
     params = request.form
@@ -853,10 +879,12 @@ def forgot_password_submit():
         flash("You MUST provide an email", "alert-danger")
         return redirect(url_for("forgot_password"))
 
+
 @app.errorhandler(401)
 def unauthorized(error):
     return redirect(url_for('login'))
 
+
 def is_redis_available():
     try:
         Redis.ping()
@@ -922,7 +950,6 @@ def register():
     params = None
     errors = None
 
-
     params = request.form if request.form else request.args
     params = params.to_dict(flat=True)
 
@@ -952,6 +979,7 @@ def url_for_hmac(endpoint, **values):
         combiner = "?"
     return url + combiner + "hm=" + hm
 
+
 def data_hmac(stringy):
     """Takes arbitray data string and appends :hmac so we know data hasn't been tampered with"""
     return stringy + ":" + actual_hmac_creation(stringy)
@@ -974,6 +1002,7 @@ def verify_url_hmac(url):
 
     assert hm == hmac, "Unexpected url (stage 3)"
 
+
 def actual_hmac_creation(stringy):
     """Helper function to create the actual hmac"""
 
@@ -986,6 +1015,7 @@ def actual_hmac_creation(stringy):
     hm = hm[:20]
     return hm
 
+
 app.jinja_env.globals.update(url_for_hmac=url_for_hmac,
                              data_hmac=data_hmac)
 
@@ -998,6 +1028,7 @@ app.jinja_env.globals.update(url_for_hmac=url_for_hmac,
 #                      Body=body))
 #     Redis.rpush("mail_queue", msg)
 
+
 def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
     """Send an E-mail through SMTP_CONNECT host. If SMTP_USERNAME is not
     'UNKNOWN' TLS is used
@@ -1020,6 +1051,7 @@ def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
         server.quit()
     logger.info("Successfully sent email to " + toaddr)
 
+
 class GroupsManager:
     def __init__(self, kw):
         self.datasets = create_datasets_list()
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index 78db7bd2..f0f0d60c 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -20,6 +20,7 @@ logger = getLogger(__name__)
 THREE_DAYS = 60 * 60 * 24 * 3
 THIRTY_DAYS = 60 * 60 * 24 * 30
 
+
 @app.before_request
 def get_user_session():
     logger.info("@app.before_request get_session")
@@ -30,6 +31,7 @@ def get_user_session():
         response.set_cookie('session_id_v2', '', expires=0)
         return response
 
+
 @app.after_request
 def set_user_session(response):
     if hasattr(g, 'user_session'):
@@ -37,6 +39,7 @@ def set_user_session(response):
             response.set_cookie(g.user_session.cookie_name, g.user_session.cookie)
     return response
 
+
 def verify_cookie(cookie):
     the_uuid, separator, the_signature = cookie.partition(':')
     assert len(the_uuid) == 36, "Is session_id a uuid?"
@@ -44,6 +47,7 @@ def verify_cookie(cookie):
     assert the_signature == hmac.hmac_creation(the_uuid), "Uh-oh, someone tampering with the cookie?"
     return the_uuid
 
+
 def create_signed_cookie():
     the_uuid = str(uuid.uuid4())
     signature = hmac.hmac_creation(the_uuid)
@@ -51,6 +55,7 @@ def create_signed_cookie():
     logger.debug("uuid_signed:", uuid_signed)
     return the_uuid, uuid_signed
 
+
 @app.route("/user/manage", methods=('GET', 'POST'))
 def manage_user():
     params = request.form if request.form else request.args
@@ -63,6 +68,7 @@ def manage_user():
 
     return render_template("admin/manage_user.html", user_details=user_details)
 
+
 class UserSession:
     """Logged in user handling"""
 
-- 
cgit v1.2.3


From 03b6bcee689c1910bd850c6109cc37adc509cf5a Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 12:45:59 +0300
Subject: autopep8: Fix E501

---
 wqflask/base/data_set.py                           |   6 +-
 wqflask/base/mrna_assay_tissue_data.py             |   3 +-
 wqflask/base/species.py                            |   3 +-
 wqflask/base/webqtlCaseData.py                     |   6 +-
 wqflask/db/webqtlDatabaseFunction.py               |   6 +-
 wqflask/maintenance/convert_geno_to_bimbam.py      |  21 +-
 wqflask/maintenance/gen_select_dataset.py          |   6 +-
 .../maintenance/generate_kinship_from_bimbam.py    |  13 +-
 wqflask/maintenance/geno_to_json.py                |   3 +-
 wqflask/maintenance/quantile_normalize.py          |   3 +-
 .../test_display_mapping_results.py                |   3 +-
 .../marker_regression/test_gemma_mapping.py        |  15 +-
 .../marker_regression/test_qtlreaper_mapping.py    |   6 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |   3 +-
 .../wqflask/marker_regression/test_run_mapping.py  |   3 +-
 wqflask/tests/unit/wqflask/test_server_side.py     |   9 +-
 wqflask/tests/wqflask/show_trait/testSampleList.py |   3 +-
 .../tests/wqflask/show_trait/test_show_trait.py    |   3 +-
 wqflask/utility/Plot.py                            |   9 +-
 wqflask/utility/benchmark.py                       |   9 +-
 wqflask/utility/corestats.py                       |   3 +-
 wqflask/utility/elasticsearch_tools.py             |   6 +-
 wqflask/utility/gen_geno_ob.py                     |  12 +-
 wqflask/utility/genofile_parser.py                 |   3 +-
 wqflask/utility/logger.py                          |   3 +-
 wqflask/utility/redis_tools.py                     |   9 +-
 wqflask/utility/startup_config.py                  |   6 +-
 wqflask/utility/svg.py                             |  60 ++-
 wqflask/utility/tools.py                           |  12 +-
 wqflask/wqflask/api/correlation.py                 |  54 +-
 wqflask/wqflask/api/mapping.py                     |  15 +-
 wqflask/wqflask/api/router.py                      |  48 +-
 wqflask/wqflask/collect.py                         |  15 +-
 .../comparison_bar_chart/comparison_bar_chart.py   |   6 +-
 wqflask/wqflask/correlation/corr_scatter_plot.py   |  33 +-
 wqflask/wqflask/correlation/show_corr_results.py   |  75 ++-
 .../wqflask/correlation_matrix/show_corr_matrix.py |  64 ++-
 wqflask/wqflask/ctl/ctl_analysis.py                |  72 ++-
 wqflask/wqflask/do_search.py                       |  69 ++-
 wqflask/wqflask/docs.py                            |   6 +-
 wqflask/wqflask/export_traits.py                   |  24 +-
 wqflask/wqflask/external_tools/send_to_bnw.py      |   6 +-
 .../wqflask/external_tools/send_to_geneweaver.py   |   3 +-
 .../wqflask/external_tools/send_to_webgestalt.py   |   3 +-
 wqflask/wqflask/group_manager.py                   |  24 +-
 wqflask/wqflask/gsearch.py                         |  41 +-
 wqflask/wqflask/heatmap/heatmap.py                 |  19 +-
 wqflask/wqflask/interval_analyst/GeneUtil.py       |   9 +-
 .../marker_regression/display_mapping_results.py   | 548 ++++++++++++++-------
 wqflask/wqflask/marker_regression/gemma_mapping.py |   3 +-
 wqflask/wqflask/marker_regression/plink_mapping.py |   9 +-
 .../wqflask/marker_regression/qtlreaper_mapping.py |  27 +-
 wqflask/wqflask/marker_regression/rqtl_mapping.py  | 103 ++--
 wqflask/wqflask/marker_regression/run_mapping.py   | 126 +++--
 wqflask/wqflask/model.py                           |  30 +-
 wqflask/wqflask/resource_manager.py                |   9 +-
 wqflask/wqflask/search_results.py                  |  33 +-
 wqflask/wqflask/show_trait/SampleList.py           |  24 +-
 wqflask/wqflask/show_trait/export_trait_data.py    |  21 +-
 wqflask/wqflask/snp_browser/snp_browser.py         | 150 ++++--
 wqflask/wqflask/update_search_results.py           |   9 +-
 wqflask/wqflask/user_login.py                      |  87 ++--
 wqflask/wqflask/user_manager.py                    |  96 ++--
 wqflask/wqflask/user_session.py                    |  28 +-
 64 files changed, 1431 insertions(+), 705 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index c14808d6..8ec0aaad 100644
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -168,7 +168,8 @@ class DatasetType:
         results = g.db.execute(sql_query_mapping[t] % group_name).fetchone()
         if results:
             self.datasets[name] = dataset_name_mapping[t]
-            self.redis_instance.set("dataset_structure", json.dumps(self.datasets))
+            self.redis_instance.set(
+                "dataset_structure", json.dumps(self.datasets))
             return True
         return None
 
@@ -239,7 +240,8 @@ class Markers:
             for line in bimbam_fh:
                 marker = {}
                 marker['name'] = line.split(delimiter)[0].rstrip()
-                marker['Mb'] = float(line.split(delimiter)[1].rstrip()) / 1000000
+                marker['Mb'] = float(line.split(delimiter)[
+                                     1].rstrip()) / 1000000
                 marker['chr'] = line.split(delimiter)[2].rstrip()
                 markers.append(marker)
 
diff --git a/wqflask/base/mrna_assay_tissue_data.py b/wqflask/base/mrna_assay_tissue_data.py
index cbc05738..9bb29664 100644
--- a/wqflask/base/mrna_assay_tissue_data.py
+++ b/wqflask/base/mrna_assay_tissue_data.py
@@ -88,6 +88,7 @@ class MrnaAssayTissueData:
                 if result.Symbol.lower() not in symbol_values_dict:
                     symbol_values_dict[result.Symbol.lower()] = [result.value]
                 else:
-                    symbol_values_dict[result.Symbol.lower()].append(result.value)
+                    symbol_values_dict[result.Symbol.lower()].append(
+                        result.value)
 
         return symbol_values_dict
diff --git a/wqflask/base/species.py b/wqflask/base/species.py
index 44f133b5..e3c29916 100644
--- a/wqflask/base/species.py
+++ b/wqflask/base/species.py
@@ -55,4 +55,5 @@ class Chromosomes:
         results = g.db.execute(query).fetchall()
 
         for item in results:
-            self.chromosomes[item.OrderId] = IndChromosome(item.Name, item.Length)
+            self.chromosomes[item.OrderId] = IndChromosome(
+                item.Name, item.Length)
diff --git a/wqflask/base/webqtlCaseData.py b/wqflask/base/webqtlCaseData.py
index 2d07ab9d..25b6cb8a 100644
--- a/wqflask/base/webqtlCaseData.py
+++ b/wqflask/base/webqtlCaseData.py
@@ -34,12 +34,14 @@ class webqtlCaseData:
 
     def __init__(self, name, value=None, variance=None, num_cases=None, name2=None):
         self.name = name
-        self.name2 = name2                  # Other name (for traits like BXD65a)
+        # Other name (for traits like BXD65a)
+        self.name2 = name2
         self.value = value                  # Trait Value
         self.variance = variance            # Trait Variance
         self.num_cases = num_cases          # Number of individuals/cases
         self.extra_attributes = None
-        self.this_id = None   # Set a sane default (can't be just "id" cause that's a reserved word)
+        # Set a sane default (can't be just "id" cause that's a reserved word)
+        self.this_id = None
         self.outlier = None   # Not set to True/False until later
 
     def __repr__(self):
diff --git a/wqflask/db/webqtlDatabaseFunction.py b/wqflask/db/webqtlDatabaseFunction.py
index 50ac06fd..29112949 100644
--- a/wqflask/db/webqtlDatabaseFunction.py
+++ b/wqflask/db/webqtlDatabaseFunction.py
@@ -36,13 +36,15 @@ def retrieve_species(group):
     """Get the species of a group (e.g. returns string "mouse" on "BXD"
 
     """
-    result = fetch1("select Species.Name from Species, InbredSet where InbredSet.Name = '%s' and InbredSet.SpeciesId = Species.Id" % (group), "/cross/" + group + ".json", lambda r: (r["species"],))[0]
+    result = fetch1("select Species.Name from Species, InbredSet where InbredSet.Name = '%s' and InbredSet.SpeciesId = Species.Id" % (
+        group), "/cross/" + group + ".json", lambda r: (r["species"],))[0]
     logger.debug("retrieve_species result:", result)
     return result
 
 
 def retrieve_species_id(group):
 
-    result = fetch1("select SpeciesId from InbredSet where Name = '%s'" % (group), "/cross/" + group + ".json", lambda r: (r["species_id"],))[0]
+    result = fetch1("select SpeciesId from InbredSet where Name = '%s'" % (
+        group), "/cross/" + group + ".json", lambda r: (r["species_id"],))[0]
     logger.debug("retrieve_species_id result:", result)
     return result
diff --git a/wqflask/maintenance/convert_geno_to_bimbam.py b/wqflask/maintenance/convert_geno_to_bimbam.py
index 5b2369c9..a1712500 100644
--- a/wqflask/maintenance/convert_geno_to_bimbam.py
+++ b/wqflask/maintenance/convert_geno_to_bimbam.py
@@ -83,7 +83,8 @@ class ConvertGenoFile:
                 genotypes = row_items[2:]
             for item_count, genotype in enumerate(genotypes):
                 if genotype.upper().strip() in self.configurations:
-                    this_marker.genotypes.append(self.configurations[genotype.upper().strip()])
+                    this_marker.genotypes.append(
+                        self.configurations[genotype.upper().strip()])
                 else:
                     this_marker.genotypes.append("NA")
 
@@ -106,9 +107,11 @@ class ConvertGenoFile:
         with open(self.output_files[2], "w") as snp_fh:
             for marker in self.markers:
                 if self.mb_exists:
-                    snp_fh.write(marker['name'] + ", " + str(int(float(marker['Mb']) * 1000000)) + ", " + marker['chr'] + "\n")
+                    snp_fh.write(
+                        marker['name'] + ", " + str(int(float(marker['Mb']) * 1000000)) + ", " + marker['chr'] + "\n")
                 else:
-                    snp_fh.write(marker['name'] + ", " + str(int(float(marker['cM']) * 1000000)) + ", " + marker['chr'] + "\n")
+                    snp_fh.write(
+                        marker['name'] + ", " + str(int(float(marker['cM']) * 1000000)) + ", " + marker['chr'] + "\n")
 
     def get_sample_list(self, row_contents):
         self.sample_list = []
@@ -160,10 +163,14 @@ class ConvertGenoFile:
             group_name = ".".join(input_file.split('.')[:-1])
             if group_name == "HSNIH-Palmer":
                 continue
-            geno_output_file = os.path.join(new_directory, group_name + "_geno.txt")
-            pheno_output_file = os.path.join(new_directory, group_name + "_pheno.txt")
-            snp_output_file = os.path.join(new_directory, group_name + "_snps.txt")
-            output_files = [geno_output_file, pheno_output_file, snp_output_file]
+            geno_output_file = os.path.join(
+                new_directory, group_name + "_geno.txt")
+            pheno_output_file = os.path.join(
+                new_directory, group_name + "_pheno.txt")
+            snp_output_file = os.path.join(
+                new_directory, group_name + "_snps.txt")
+            output_files = [geno_output_file,
+                pheno_output_file, snp_output_file]
             print("%s -> %s" % (
                 os.path.join(old_directory, input_file), geno_output_file))
             convertob = ConvertGenoFile(input_file, output_files)
diff --git a/wqflask/maintenance/gen_select_dataset.py b/wqflask/maintenance/gen_select_dataset.py
index 583a06e1..484336a6 100644
--- a/wqflask/maintenance/gen_select_dataset.py
+++ b/wqflask/maintenance/gen_select_dataset.py
@@ -120,14 +120,16 @@ def get_types(groups):
                 else:
                     if not phenotypes_exist(group_name) and not genotypes_exist(group_name):
                         types[species].pop(group_name, None)
-                        groups[species] = tuple(group for group in groups[species] if group[0] != group_name)
+                        groups[species] = tuple(
+                            group for group in groups[species] if group[0] != group_name)
             else:  # ZS: This whole else statement might be unnecessary, need to check
                 types_list = build_types(species, group_name)
                 if len(types_list) > 0:
                     types[species][group_name] = types_list
                 else:
                     types[species].pop(group_name, None)
-                    groups[species] = tuple(group for group in groups[species] if group[0] != group_name)
+                    groups[species] = tuple(
+                        group for group in groups[species] if group[0] != group_name)
     return types
 
 
diff --git a/wqflask/maintenance/generate_kinship_from_bimbam.py b/wqflask/maintenance/generate_kinship_from_bimbam.py
index 7cc60c9e..bed634fa 100644
--- a/wqflask/maintenance/generate_kinship_from_bimbam.py
+++ b/wqflask/maintenance/generate_kinship_from_bimbam.py
@@ -21,7 +21,9 @@ class GenerateKinshipMatrices:
         self.pheno_file = pheno_file
     
     def generate_kinship(self):
-        gemma_command = "/gnu/store/xhzgjr0jvakxv6h3blj8z496xjig69b0-profile/bin/gemma -g " + self.geno_file + " -p " + self.pheno_file + " -gk 1 -outdir /home/zas1024/genotype_files/genotype/bimbam/ -o " + self.group_name
+        gemma_command = "/gnu/store/xhzgjr0jvakxv6h3blj8z496xjig69b0-profile/bin/gemma -g " + self.geno_file + \
+            " -p " + self.pheno_file + \
+                " -gk 1 -outdir /home/zas1024/genotype_files/genotype/bimbam/ -o " + self.group_name
         print("command:", gemma_command)
         os.system(gemma_command)
 
@@ -34,9 +36,12 @@ class GenerateKinshipMatrices:
             group_name = ".".join(input_file.split('.')[:-1])
             if group_name == "HSNIH-Palmer":
                 continue
-            geno_input_file = os.path.join(bimbam_dir, group_name + "_geno.txt")
-            pheno_input_file = os.path.join(bimbam_dir, group_name + "_pheno.txt")
-            convertob = GenerateKinshipMatrices(group_name, geno_input_file, pheno_input_file)
+            geno_input_file = os.path.join(
+                bimbam_dir, group_name + "_geno.txt")
+            pheno_input_file = os.path.join(
+                bimbam_dir, group_name + "_pheno.txt")
+            convertob = GenerateKinshipMatrices(
+                group_name, geno_input_file, pheno_input_file)
             try:
                 convertob.generate_kinship()
             except EmptyConfigurations as why:
diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index ad3f2b72..7bdf2b53 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -100,7 +100,8 @@ class ConvertGenoFile:
                 genotypes = row_items[2:]
             for item_count, genotype in enumerate(genotypes):
                 if genotype.upper() in self.configurations:
-                    this_marker.genotypes.append(self.configurations[genotype.upper()])
+                    this_marker.genotypes.append(
+                        self.configurations[genotype.upper()])
                 else:
                     this_marker.genotypes.append("NA")
                 
diff --git a/wqflask/maintenance/quantile_normalize.py b/wqflask/maintenance/quantile_normalize.py
index 1896bc52..ac7689f5 100644
--- a/wqflask/maintenance/quantile_normalize.py
+++ b/wqflask/maintenance/quantile_normalize.py
@@ -34,7 +34,8 @@ def create_dataframe(input_file):
     with open(input_file) as f:
         ncols = len(f.readline().split("\t"))
 
-    input_array = np.loadtxt(open(input_file, "rb"), delimiter="\t", skiprows=1, usecols=list(range(1, ncols)))
+    input_array = np.loadtxt(open(
+        input_file, "rb"), delimiter="\t", skiprows=1, usecols=list(range(1, ncols)))
     return pd.DataFrame(input_array)
 
 # This function taken from https://github.com/ShawnLYU/Quantile_Normalize
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
index 219a6a29..f4869c45 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_display_mapping_results.py
@@ -39,7 +39,8 @@ class TestHtmlGenWrapper(unittest.TestCase):
             cgi="/testing/",
             enctype='multipart/form-data',
             name="formName",
-            submit=HtmlGenWrapper.create_input_tag(type_='hidden', name='Default_Name')
+            submit=HtmlGenWrapper.create_input_tag(
+                type_='hidden', name='Default_Name')
         )
         test_image = HtmlGenWrapper.create_image_tag(
             src="test.png",
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index f194c6c9..5cbaf0e0 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -70,7 +70,8 @@ class TestGemmaMapping(unittest.TestCase):
         ], vals=[], covariates="", use_loco=True)
         self.assertEqual(mock_os.system.call_count, 2)
         mock_gen_pheno_txt.assert_called_once()
-        mock_parse_loco.assert_called_once_with(dataset, "GP1_GWA_RRRRRR", True)
+        mock_parse_loco.assert_called_once_with(
+            dataset, "GP1_GWA_RRRRRR", True)
         mock_os.path.isfile.assert_called_once_with(
             ('/home/user/imgfile_output.assoc.txt'))
         self.assertEqual(mock_flat_files.call_count, 4)
@@ -102,7 +103,8 @@ class TestGemmaMapping(unittest.TestCase):
         create_trait_side_effect = []
 
         for i in range(4):
-            create_dataset_side_effect.append(AttributeSetter({"name": f'name_{i}'}))
+            create_dataset_side_effect.append(
+                AttributeSetter({"name": f'name_{i}'}))
             create_trait_side_effect.append(
                 AttributeSetter({"data": [f'data_{i}']}))
 
@@ -160,9 +162,12 @@ X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
             results = parse_loco_output(
                 this_dataset={}, gwa_output_filename=".xw/")
             expected_results = [
-            {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85, 'additive': 23.3, 'lod_score': 0.07058107428570727},
-            {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5, 'additive': 24.0, 'lod_score': 0.3010299956639812},
-            {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7, 'additive': 11.6, 'lod_score': 0.1549019599857432},
+            {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85,
+                'additive': 23.3, 'lod_score': 0.07058107428570727},
+            {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5,
+                'additive': 24.0, 'lod_score': 0.3010299956639812},
+            {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7,
+                'additive': 11.6, 'lod_score': 0.1549019599857432},
             {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': 21.1, 'lod_score': 0.22184874961635637}]
 
             self.assertEqual(expected_results, results)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index 5cc8fd0f..c762982b 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -13,10 +13,12 @@ class TestQtlReaperMapping(unittest.TestCase):
 		samples = ["S1", "S2", "S3", "S4","S5"]
 		trait_filename = "trait_file"
 		with mock.patch("builtins.open", mock.mock_open())as mock_open:
-			gen_pheno_txt_file(samples=samples, vals=vals, trait_filename=trait_filename)
+			gen_pheno_txt_file(samples=samples, vals=vals,
+			                   trait_filename=trait_filename)
 			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
 			filehandler = mock_open()
-			write_calls = [mock.call('Trait\t'), mock.call('S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
+			write_calls = [mock.call('Trait\t'), mock.call(
+				'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
 
 			filehandler.write.assert_has_calls(write_calls)
 
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 6267ce9a..6996c275 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -20,7 +20,8 @@ class TestRqtlMapping(unittest.TestCase):
 	def test_get_trait_data(self, mock_logger, mock_db):
 		"""test for getting trait data_type return True"""
 		query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-		mock_db.db.execute.return_value.fetchone.return_value = ["""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+		mock_db.db.execute.return_value.fetchone.return_value = [
+			"""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
 		results = get_trait_data_type("traid_id")
 		mock_db.db.execute.assert_called_with(query_value)
 		self.assertEqual(results, "fer434f")
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index a29d8cfb..78cd3be9 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -187,7 +187,8 @@ class TestRunMapping(unittest.TestCase):
                     mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
                     mock.call('Population: Human GP1_\n'), mock.call(
                         'Data Set: dataser_1\n'),
-                    mock.call('N Samples: 100\n'), mock.call('Transform - Quantile Normalized\n'),
+                    mock.call('N Samples: 100\n'), mock.call(
+                        'Transform - Quantile Normalized\n'),
                     mock.call('Gene Symbol: IGFI\n'), mock.call(
                         'Location: X1 @ 123313 Mb\n'),
                     mock.call('Cofactors (dataset - trait):\n'),
diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
index 4f91d8ca..69977146 100644
--- a/wqflask/tests/unit/wqflask/test_server_side.py
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -22,10 +22,13 @@ class TestServerSideTableTests(unittest.TestCase):
             {'first': 'c', 'second': 1, 'third': 'ss'},
         ]
         headers = ['first', 'second', 'third']
-        request_args = {'sEcho': '1', 'iSortCol_0': '1', 'iSortingCols': '1', 'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'}
+        request_args = {'sEcho': '1', 'iSortCol_0': '1', 'iSortingCols': '1',
+            'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'}
 
-        test_page = ServerSideTable(rows_count, table_rows, headers, request_args).get_page()
+        test_page = ServerSideTable(
+            rows_count, table_rows, headers, request_args).get_page()
         self.assertEqual(test_page['sEcho'], '1')
         self.assertEqual(test_page['iTotalRecords'], 'nan')
         self.assertEqual(test_page['iTotalDisplayRecords'], '3')
-        self.assertEqual(test_page['data'], [{'first': 'b', 'second': 2, 'third': 'aa'}, {'first': 'c', 'second': 1, 'third': 'ss'}, {'first': 'd', 'second': 4, 'third': 'zz'}])
+        self.assertEqual(test_page['data'], [{'first': 'b', 'second': 2, 'third': 'aa'}, {
+                         'first': 'c', 'second': 1, 'third': 'ss'}, {'first': 'd', 'second': 4, 'third': 'zz'}])
diff --git a/wqflask/tests/wqflask/show_trait/testSampleList.py b/wqflask/tests/wqflask/show_trait/testSampleList.py
index 441a88a7..305586ce 100644
--- a/wqflask/tests/wqflask/show_trait/testSampleList.py
+++ b/wqflask/tests/wqflask/show_trait/testSampleList.py
@@ -13,4 +13,5 @@ class TestSampleList(unittest.TestCase):
         sorted_list_a = natural_sort(characters_list)
         sorted_list_b = natural_sort(names_list)
         self.assertEqual(sorted_list_a, ["a", "f", "g", "q", "s", "t", "z"])
-        self.assertEqual(sorted_list_b, ["Dataset", "Sample", "publish", "temp1"])
+        self.assertEqual(
+            sorted_list_b, ["Dataset", "Sample", "publish", "temp1"])
diff --git a/wqflask/tests/wqflask/show_trait/test_show_trait.py b/wqflask/tests/wqflask/show_trait/test_show_trait.py
index 24c3923e..63df2ba5 100644
--- a/wqflask/tests/wqflask/show_trait/test_show_trait.py
+++ b/wqflask/tests/wqflask/show_trait/test_show_trait.py
@@ -72,7 +72,8 @@ class TestTraits(unittest.TestCase):
         mock_get.return_value = get_return_obj
         results = get_ncbi_summary(trait)
         mock_exists.assert_called_once()
-        mock_get.assert_called_once_with(f"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=gene&id={trait.geneid}&retmode=json")
+        mock_get.assert_called_once_with(
+            f"http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=gene&id={trait.geneid}&retmode=json")
 
         self.assertEqual(results, "this is a summary of the geneid")
 
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index d35b2089..4f5691c1 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -178,7 +178,8 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
 
     # draw drawing region
     im_drawer.rectangle(
-        xy=((xLeftOffset, yTopOffset), (xLeftOffset + plotWidth, yTopOffset + plotHeight))
+        xy=((xLeftOffset, yTopOffset),
+            (xLeftOffset + plotWidth, yTopOffset + plotHeight))
     )
 
     # draw scale
@@ -199,11 +200,13 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     y = yLow
     for i in range(int(stepY) + 1):
        yc = yTopOffset + plotHeight - (y - yLow) * yScale
-       im_drawer.line(xy=((xLeftOffset, yc), (xLeftOffset - 5, yc)), fill=axesColor)
+       im_drawer.line(
+           xy=((xLeftOffset, yc), (xLeftOffset - 5, yc)), fill=axesColor)
        strY = "%d" % y
        im_drawer.text(
            text=strY,
-           xy=(xLeftOffset - im_drawer.textsize(strY, font=scaleFont)[0] - 6, yc + 5),
+           xy=(xLeftOffset - im_drawer.textsize(strY,
+               font=scaleFont)[0] - 6, yc + 5),
            font=scaleFont)
        y += (yTop - yLow) / stepY
 
diff --git a/wqflask/utility/benchmark.py b/wqflask/utility/benchmark.py
index 48ab1dc0..6ece2f21 100644
--- a/wqflask/utility/benchmark.py
+++ b/wqflask/utility/benchmark.py
@@ -19,7 +19,8 @@ class Bench:
             if self.name:
                 logger.debug("Starting benchmark: %s" % (self.name))
             else:
-                logger.debug("Starting benchmark at: %s [%i]" % (inspect.stack()[1][3], inspect.stack()[1][2]))
+                logger.debug("Starting benchmark at: %s [%i]" % (
+                    inspect.stack()[1][3], inspect.stack()[1][2]))
         self.start_time = time.time()
 
     def __exit__(self, type, value, traceback):
@@ -33,11 +34,13 @@ class Bench:
             logger.info("  %s took: %f seconds" % (name, (time_taken)))
 
         if self.name:
-            Bench.entries[self.name] = Bench.entries.get(self.name, 0) + time_taken
+            Bench.entries[self.name] = Bench.entries.get(
+                self.name, 0) + time_taken
 
     @classmethod
     def report(cls):
-        total_time = sum((time_taken for time_taken in list(cls.entries.values())))
+        total_time = sum(
+            (time_taken for time_taken in list(cls.entries.values())))
         print("\nTiming report\n")
         for name, time_taken in list(cls.entries.items()):
             percent = int(round((time_taken / total_time) * 100))
diff --git a/wqflask/utility/corestats.py b/wqflask/utility/corestats.py
index 523280a1..da0a21db 100644
--- a/wqflask/utility/corestats.py
+++ b/wqflask/utility/corestats.py
@@ -65,7 +65,8 @@ class Stats:
         if len(self.sequence) < 1:
             value = None
         elif (percentile >= 100):
-            sys.stderr.write('ERROR: percentile must be < 100.  you supplied: %s\n' % percentile)
+            sys.stderr.write(
+                'ERROR: percentile must be < 100.  you supplied: %s\n' % percentile)
             value = None
         else:
             element_idx = int(len(self.sequence) * (percentile / 100.0))
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index 9415cef0..55907dd5 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -49,7 +49,8 @@ from utility.tools import ELASTICSEARCH_HOST, ELASTICSEARCH_PORT
 
 
 def test_elasticsearch_connection():
-    es = Elasticsearch(['http://' + ELASTICSEARCH_HOST + ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
+    es = Elasticsearch(['http://' + ELASTICSEARCH_HOST + \
+                       ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
     if not es.ping():
         logger.warning("Elasticsearch is DOWN")
 
@@ -88,7 +89,8 @@ def setup_users_index(es_connection):
                     "type": "keyword"}}}
 
         es_connection.indices.create(index='users', ignore=400)
-        es_connection.indices.put_mapping(body=index_settings, index="users", doc_type="local")
+        es_connection.indices.put_mapping(
+            body=index_settings, index="users", doc_type="local")
 
 
 def get_user_by_unique_column(es, column_name, column_value, index="users", doc_type="local"):
diff --git a/wqflask/utility/gen_geno_ob.py b/wqflask/utility/gen_geno_ob.py
index 24604e58..e619b7b6 100644
--- a/wqflask/utility/gen_geno_ob.py
+++ b/wqflask/utility/gen_geno_ob.py
@@ -38,13 +38,15 @@ class genotype:
 
     def read_rdata_output(self, qtl_results):
         # ZS: This is necessary because R/qtl requires centimorgan marker positions, which it normally gets from the .geno file, but that doesn't exist for HET3-ITP (which only has RData), so it needs to read in the marker cM positions from the results
-        self.chromosomes = []  # ZS: Overwriting since the .geno file's contents are just placeholders
+        # ZS: Overwriting since the .geno file's contents are just placeholders
+        self.chromosomes = []
 
         this_chr = ""  # ZS: This is so it can track when the chromosome changes as it iterates through markers
         chr_ob = None
         for marker in qtl_results:
             locus = Locus(self)
-            if (str(marker['chr']) != this_chr) and this_chr != "X":  # ZS: This is really awkward but works as a temporary fix
+            # ZS: This is really awkward but works as a temporary fix
+            if (str(marker['chr']) != this_chr) and this_chr != "X":
                 if this_chr != "":
                     self.chromosomes.append(chr_ob)
                 this_chr = str(marker['chr'])
@@ -156,9 +158,11 @@ class Locus:
             try:
                 self.cM = float(marker_row[geno_ob.cm_column])
             except:
-                self.cM = float(marker_row[geno_ob.mb_column]) if geno_ob.mb_exists else 0
+                self.cM = float(
+                    marker_row[geno_ob.mb_column]) if geno_ob.mb_exists else 0
             try:
-                self.Mb = float(marker_row[geno_ob.mb_column]) if geno_ob.mb_exists else None
+                self.Mb = float(
+                    marker_row[geno_ob.mb_column]) if geno_ob.mb_exists else None
             except:
                 self.Mb = self.cM
 
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index 94a08c17..09100bd9 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -92,7 +92,8 @@ class ConvertGenoFile:
         genotypes = row_items[2:]
       for item_count, genotype in enumerate(genotypes):
         if genotype.upper().strip() in self.configurations:
-          this_marker.genotypes.append(self.configurations[genotype.upper().strip()])
+          this_marker.genotypes.append(
+            self.configurations[genotype.upper().strip()])
         else:
           print("WARNING:", genotype.upper())
           this_marker.genotypes.append("NA")
diff --git a/wqflask/utility/logger.py b/wqflask/utility/logger.py
index 47079818..d706e32a 100644
--- a/wqflask/utility/logger.py
+++ b/wqflask/utility/logger.py
@@ -151,5 +151,6 @@ def getLogger(name, level=None):
     else:
         logger.setLevel(LOG_LEVEL)
 
-    logger.info("Log level of " + name + " set to " + logging.getLevelName(logger.getEffectiveLevel()))
+    logger.info("Log level of " + name + " set to " + \
+                logging.getLevelName(logger.getEffectiveLevel()))
     return gnlogger
diff --git a/wqflask/utility/redis_tools.py b/wqflask/utility/redis_tools.py
index 8052035f..96a4be12 100644
--- a/wqflask/utility/redis_tools.py
+++ b/wqflask/utility/redis_tools.py
@@ -133,8 +133,10 @@ def get_user_groups(user_id):
     for key in groups_list:
         try:
             group_ob = json.loads(groups_list[key])
-            group_admins = set([this_admin.encode('utf-8') if this_admin else None for this_admin in group_ob['admins']])
-            group_members = set([this_member.encode('utf-8') if this_member else None for this_member in group_ob['members']])
+            group_admins = set([this_admin.encode(
+                'utf-8') if this_admin else None for this_admin in group_ob['admins']])
+            group_members = set([this_member.encode(
+                'utf-8') if this_member else None for this_member in group_ob['members']])
             if user_id in group_admins:
                 admin_group_ids.append(group_ob['id'])
             elif user_id in group_members:
@@ -203,7 +205,8 @@ def get_groups_like_unique_column(column_name, column_value):
                         if column_value in group_info[column_name]:
                             matched_groups.append(group_info)
         else:
-            matched_groups.append(load_json_from_redis(group_list, column_value))
+            matched_groups.append(
+                load_json_from_redis(group_list, column_value))
 
     return matched_groups
 
diff --git a/wqflask/utility/startup_config.py b/wqflask/utility/startup_config.py
index 92f944bc..05f8a2b0 100644
--- a/wqflask/utility/startup_config.py
+++ b/wqflask/utility/startup_config.py
@@ -28,7 +28,8 @@ def app_config():
     port = get_setting_int("SERVER_PORT")
 
     if get_setting_bool("USE_GN_SERVER"):
-        print(("GN2 API server URL is [" + BLUE + get_setting("GN_SERVER_URL") + ENDC + "]"))
+        print(
+            ("GN2 API server URL is [" + BLUE + get_setting("GN_SERVER_URL") + ENDC + "]"))
         import requests
         page = requests.get(get_setting("GN_SERVER_URL"))
         if page.status_code != 200:
@@ -37,4 +38,5 @@ def app_config():
     # import utility.elasticsearch_tools as es
     # es.test_elasticsearch_connection()
 
-    print(("GN2 is running. Visit %s[http://localhost:%s/%s](%s)" % (BLUE, str(port), ENDC, get_setting("WEBSERVER_URL"))))
+    print(("GN2 is running. Visit %s[http://localhost:%s/%s](%s)" %
+          (BLUE, str(port), ENDC, get_setting("WEBSERVER_URL"))))
diff --git a/wqflask/utility/svg.py b/wqflask/utility/svg.py
index f5ef81e1..8d2e13ab 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -239,19 +239,23 @@ class pathdata:
 
     def smbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy absolut"""
-        self.path.append('S' + str(x2) + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
+        self.path.append('S' + str(x2) + ',' + str(y2) + \
+                         ' ' + str(x) + ',' + str(y))
 
     def relsmbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy relative"""
-        self.path.append('s' + str(x2) + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
+        self.path.append('s' + str(x2) + ',' + str(y2) + \
+                         ' ' + str(x) + ',' + str(y))
 
     def qbezier(self, x1, y1, x, y):
         """quadratic bezier with xy1 to xy absolut"""
-        self.path.append('Q' + str(x1) + ',' + str(y1) + ' ' + str(x) + ',' + str(y))
+        self.path.append('Q' + str(x1) + ',' + str(y1) + \
+                         ' ' + str(x) + ',' + str(y))
 
     def relqbezier(self, x1, y1, x, y):
         """quadratic bezier with xy1 to xy relative"""
-        self.path.append('q' + str(x1) + ',' + str(y1) + ' ' + str(x) + ',' + str(y))
+        self.path.append('q' + str(x1) + ',' + str(y1) + \
+                         ' ' + str(x) + ',' + str(y))
 
     def smqbezier(self, x, y):
         """smooth quadratic bezier to xy absolut"""
@@ -447,7 +451,8 @@ class rect(SVGelement):
         if width == None or height == None:
             raise ValueError('both height and width are required')
 
-        SVGelement.__init__(self, 'rect', {'width': width, 'height': height}, **args)
+        SVGelement.__init__(
+            self, 'rect', {'width': width, 'height': height}, **args)
         if x != None:
             self.attributes['x'] = x
         if y != None:
@@ -545,7 +550,8 @@ class polyline(SVGelement):
     """
 
     def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
-        SVGelement.__init__(self, 'polyline', {'points': _xypointlist(points)}, **args)
+        SVGelement.__init__(self, 'polyline', {
+                            'points': _xypointlist(points)}, **args)
         if fill != None:
             self.attributes['fill'] = fill
         if stroke_width != None:
@@ -561,7 +567,8 @@ class polygon(SVGelement):
     """
 
     def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
-        SVGelement.__init__(self, 'polygon', {'points': _xypointlist(points)}, **args)
+        SVGelement.__init__(
+            self, 'polygon', {'points': _xypointlist(points)}, **args)
         if fill != None:
             self.attributes['fill'] = fill
         if stroke_width != None:
@@ -745,7 +752,8 @@ class image(SVGelement):
     def __init__(self, url, x=None, y=None, width=None,height=None,**args):
         if width == None or height == None:
             raise ValueError('both height and width are required')
-        SVGelement.__init__(self, 'image', {'xlink:href': url, 'width': width, 'height':height}, **args)
+        SVGelement.__init__(
+            self, 'image', {'xlink:href': url, 'width': width, 'height':height}, **args)
         if x != None:
             self.attributes['x'] = x
         if y != None:
@@ -886,7 +894,8 @@ class script(SVGelement):
     """
 
     def __init__(self, type, cdata=None, **args):
-        SVGelement.__init__(self, 'script', {'type': type}, cdata=cdata, **args)
+        SVGelement.__init__(
+            self, 'script', {'type': type}, cdata=cdata, **args)
 
 
 class animate(SVGelement):
@@ -896,7 +905,8 @@ class animate(SVGelement):
     """
 
     def __init__(self, attribute, fr=None, to=None, dur=None,**args):
-        SVGelement.__init__(self, 'animate', {'attributeName': attribute}, **args)
+        SVGelement.__init__(
+            self, 'animate', {'attributeName': attribute}, **args)
         if fr != None:
             self.attributes['from'] = fr
         if to != None:
@@ -926,7 +936,8 @@ class animateTransform(SVGelement):
     """
 
     def __init__(self, type=None, fr=None, to=None, dur=None,**args):
-        SVGelement.__init__(self, 'animateTransform', {'attributeName': 'transform'}, **args)
+        SVGelement.__init__(self, 'animateTransform', {
+                            'attributeName': 'transform'}, **args)
         # As far as I know the attributeName is always transform
         if type != None:
             self.attributes['type'] = type
@@ -945,7 +956,8 @@ class animateColor(SVGelement):
     """
 
     def __init__(self, attribute, type=None, fr=None, to=None,dur=None,**args):
-        SVGelement.__init__(self, 'animateColor', {'attributeName': attribute}, **args)
+        SVGelement.__init__(self, 'animateColor', {
+                            'attributeName': attribute}, **args)
         if type != None:
             self.attributes['type'] = type
         if fr != None:
@@ -1020,11 +1032,13 @@ class drawing:
             import io
             xml = io.StringIO()
             xml.write("<?xml version='1.0' encoding='UTF-8'?>\n")
-            xml.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\"")
+            xml.write(
+                "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\" \"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\"")
             if self.entity:
                 xml.write(" [\n")
                 for item in list(self.entity.keys()):
-                    xml.write("<!ENTITY %s \"%s\">\n" % (item, self.entity[item]))
+                    xml.write("<!ENTITY %s \"%s\">\n" %
+                              (item, self.entity[item]))
                 xml.write("]")
             xml.write(">\n")
             self.svg.toXml(0, xml)
@@ -1042,7 +1056,8 @@ class drawing:
             else:
                 if filename[-4:] == 'svgz':
                     import gzip
-                    f = gzip.GzipFile(filename=filename, mode="wb", compresslevel=9)
+                    f = gzip.GzipFile(filename=filename,
+                                      mode="wb", compresslevel=9)
                     f.write(xml.getvalue())
                     f.close()
                 else:
@@ -1057,7 +1072,8 @@ class drawing:
             writes a svg drawing to the screen or to a file
             compresses if filename ends with svgz or if compress is true
             """
-            doctype = implementation.createDocumentType('svg', "-//W3C//DTD SVG 1.0//EN""", 'http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd ')
+            doctype = implementation.createDocumentType(
+                'svg', "-//W3C//DTD SVG 1.0//EN""", 'http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd ')
 
             global root
             # root is defined global so it can be used by the appender. Its also possible to use it as an arugument but
@@ -1076,8 +1092,10 @@ class drawing:
                 if element.text:
                     textnode = root.createTextNode(element.text)
                     e.appendChild(textnode)
-                for attribute in list(element.attributes.keys()):  # in element.attributes is supported from python 2.2
-                    e.setAttribute(attribute, str(element.attributes[attribute]))
+                # in element.attributes is supported from python 2.2
+                for attribute in list(element.attributes.keys()):
+                    e.setAttribute(attribute, str(
+                        element.attributes[attribute]))
                 if element.elements:
                     for el in element.elements:
                         e = appender(el, e)
@@ -1105,7 +1123,8 @@ class drawing:
                         import io
                         xml = io.StringIO()
                         PrettyPrint(root, xml)
-                        f = gzip.GzipFile(filename=filename, mode='wb', compresslevel=9)
+                        f = gzip.GzipFile(filename=filename,
+                                          mode='wb', compresslevel=9)
                         f.write(xml.getvalue())
                         f.close()
                     else:
@@ -1119,7 +1138,8 @@ class drawing:
         try:
             import xml.parsers.xmlproc.xmlval
         except:
-            raise exceptions.ImportError('PyXml is required for validating SVG')
+            raise exceptions.ImportError(
+                'PyXml is required for validating SVG')
         svg = self.toXml()
         xv = xml.parsers.xmlproc.xmlval.XMLValidator()
         try:
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index 4fe4db08..263c3948 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -64,7 +64,8 @@ def get_setting(command_id, guess=None):
                 command = value(guess)
                 if command is None or command == "":
                     # print command
-                    raise Exception(command_id + ' setting unknown or faulty (update default_settings.py?).')
+                    raise Exception(
+                        command_id + ' setting unknown or faulty (update default_settings.py?).')
     # print("Set "+command_id+"="+str(command))
     return command
 
@@ -113,7 +114,8 @@ def js_path(module=None):
     try_guix = get_setting("JS_GUIX_PATH") + "/" + module
     if valid_path(try_guix):
         return try_guix
-    raise "No JS path found for " + module + " (if not in Guix check JS_GN_PATH)"
+    raise "No JS path found for " + module + \
+        " (if not in Guix check JS_GN_PATH)"
 
 
 def reaper_command(guess=None):
@@ -292,7 +294,8 @@ ORCID_CLIENT_SECRET = get_setting('ORCID_CLIENT_SECRET')
 ORCID_AUTH_URL = None
 if ORCID_CLIENT_ID != 'UNKNOWN' and ORCID_CLIENT_SECRET:
     ORCID_AUTH_URL = "https://orcid.org/oauth/authorize?response_type=code&scope=/authenticate&show_login=true&client_id=" + \
-                      ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
+                      ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + \
+                          "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
     ORCID_TOKEN_URL = get_setting('ORCID_TOKEN_URL')
 
 ELASTICSEARCH_HOST = get_setting('ELASTICSEARCH_HOST')
@@ -320,7 +323,8 @@ assert_dir(JS_GUIX_PATH + '/cytoscape-panzoom')
 CSS_PATH = JS_GUIX_PATH  # The CSS is bundled together with the JS
 # assert_dir(JS_PATH)
 
-JS_TWITTER_POST_FETCHER_PATH = get_setting("JS_TWITTER_POST_FETCHER_PATH", js_path("javascript-twitter-post-fetcher"))
+JS_TWITTER_POST_FETCHER_PATH = get_setting(
+    "JS_TWITTER_POST_FETCHER_PATH", js_path("javascript-twitter-post-fetcher"))
 assert_dir(JS_TWITTER_POST_FETCHER_PATH)
 assert_file(JS_TWITTER_POST_FETCHER_PATH + "/js/twitterFetcher_min.js")
 
diff --git a/wqflask/wqflask/api/correlation.py b/wqflask/wqflask/api/correlation.py
index f1dd148f..52026a82 100644
--- a/wqflask/wqflask/api/correlation.py
+++ b/wqflask/wqflask/api/correlation.py
@@ -25,13 +25,16 @@ def do_correlation(start_vars):
     assert('trait_id' in start_vars)
 
     this_dataset = data_set.create_dataset(dataset_name=start_vars['db'])
-    target_dataset = data_set.create_dataset(dataset_name=start_vars['target_db'])
-    this_trait = create_trait(dataset=this_dataset, name=start_vars['trait_id'])
+    target_dataset = data_set.create_dataset(
+        dataset_name=start_vars['target_db'])
+    this_trait = create_trait(dataset=this_dataset,
+                              name=start_vars['trait_id'])
     this_trait = retrieve_sample_data(this_trait, this_dataset)
 
     corr_params = init_corr_params(start_vars)
 
-    corr_results = calculate_results(this_trait, this_dataset, target_dataset, corr_params)
+    corr_results = calculate_results(
+        this_trait, this_dataset, target_dataset, corr_params)
     #corr_results = collections.OrderedDict(sorted(corr_results.items(), key=lambda t: -abs(t[1][0])))
 
     final_results = []
@@ -75,54 +78,66 @@ def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
 
     if corr_params['type'] == "tissue":
         trait_symbol_dict = this_dataset.retrieve_genes("Symbol")
-        corr_results = do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_params)
+        corr_results = do_tissue_correlation_for_all_traits(
+            this_trait, trait_symbol_dict, corr_params)
         sorted_results = collections.OrderedDict(sorted(list(corr_results.items()),
                                                         key=lambda t: -abs(t[1][1])))
-    elif corr_params['type'] == "literature" or corr_params['type'] == "lit":  # ZS: Just so a user can use either "lit" or "literature"
+    # ZS: Just so a user can use either "lit" or "literature"
+    elif corr_params['type'] == "literature" or corr_params['type'] == "lit":
         trait_geneid_dict = this_dataset.retrieve_genes("GeneId")
-        corr_results = do_literature_correlation_for_all_traits(this_trait, this_dataset, trait_geneid_dict, corr_params)
+        corr_results = do_literature_correlation_for_all_traits(
+            this_trait, this_dataset, trait_geneid_dict, corr_params)
         sorted_results = collections.OrderedDict(sorted(list(corr_results.items()),
                                                  key=lambda t: -abs(t[1][1])))
     else:
         for target_trait, target_vals in list(target_dataset.trait_data.items()):
-            result = get_sample_r_and_p_values(this_trait, this_dataset, target_vals, target_dataset, corr_params['type'])
+            result = get_sample_r_and_p_values(
+                this_trait, this_dataset, target_vals, target_dataset, corr_params['type'])
             if result is not None:
                 corr_results[target_trait] = result
 
-        sorted_results = collections.OrderedDict(sorted(list(corr_results.items()), key=lambda t: -abs(t[1][0])))
+        sorted_results = collections.OrderedDict(
+            sorted(list(corr_results.items()), key=lambda t: -abs(t[1][0])))
 
     return sorted_results
 
 
 def do_tissue_correlation_for_all_traits(this_trait, trait_symbol_dict, corr_params, tissue_dataset_id=1):
     # Gets tissue expression values for the primary trait
-    primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(symbol_list=[this_trait.symbol])
+    primary_trait_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
+        symbol_list=[this_trait.symbol])
 
     if this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
-        primary_trait_tissue_values = primary_trait_tissue_vals_dict[this_trait.symbol.lower()]
+        primary_trait_tissue_values = primary_trait_tissue_vals_dict[this_trait.symbol.lower(
+        )]
 
-        corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(symbol_list=list(trait_symbol_dict.values()))
+        corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
+            symbol_list=list(trait_symbol_dict.values()))
 
         tissue_corr_data = {}
         for trait, symbol in list(trait_symbol_dict.items()):
             if symbol and symbol.lower() in corr_result_tissue_vals_dict:
-                this_trait_tissue_values = corr_result_tissue_vals_dict[symbol.lower()]
+                this_trait_tissue_values = corr_result_tissue_vals_dict[symbol.lower(
+                )]
 
                 result = correlation_functions.cal_zero_order_corr_for_tiss(primary_trait_tissue_values,
                                                                             this_trait_tissue_values,
                                                                             corr_params['method'])
 
-                tissue_corr_data[trait] = [result[0], result[1], result[2], symbol]
+                tissue_corr_data[trait] = [
+                    result[0], result[1], result[2], symbol]
 
         return tissue_corr_data
 
 
 def do_literature_correlation_for_all_traits(this_trait, target_dataset, trait_geneid_dict, corr_params):
-    input_trait_mouse_gene_id = convert_to_mouse_gene_id(target_dataset.group.species.lower(), this_trait.geneid)
+    input_trait_mouse_gene_id = convert_to_mouse_gene_id(
+        target_dataset.group.species.lower(), this_trait.geneid)
 
     lit_corr_data = {}
     for trait, gene_id in list(trait_geneid_dict.items()):
-        mouse_gene_id = convert_to_mouse_gene_id(target_dataset.group.species.lower(), gene_id)
+        mouse_gene_id = convert_to_mouse_gene_id(
+            target_dataset.group.species.lower(), gene_id)
 
         if mouse_gene_id and str(mouse_gene_id).find(";") == -1:
             result = g.db.execute(
@@ -168,12 +183,15 @@ def get_sample_r_and_p_values(this_trait, this_dataset, target_vals, target_data
             this_trait_vals.append(this_sample_value)
             shared_target_vals.append(target_sample_value)
 
-    this_trait_vals, shared_target_vals, num_overlap = corr_result_helpers.normalize_values(this_trait_vals, shared_target_vals)
+    this_trait_vals, shared_target_vals, num_overlap = corr_result_helpers.normalize_values(
+        this_trait_vals, shared_target_vals)
 
     if type == 'pearson':
-        sample_r, sample_p = scipy.stats.pearsonr(this_trait_vals, shared_target_vals)
+        sample_r, sample_p = scipy.stats.pearsonr(
+            this_trait_vals, shared_target_vals)
     else:
-        sample_r, sample_p = scipy.stats.spearmanr(this_trait_vals, shared_target_vals)
+        sample_r, sample_p = scipy.stats.spearmanr(
+            this_trait_vals, shared_target_vals)
 
     if num_overlap > 5:
         if scipy.isnan(sample_r):
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index 662090d5..c22b44a9 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -37,20 +37,25 @@ def do_mapping_for_api(start_vars):
 
     mapping_params = initialize_parameters(start_vars, dataset, this_trait)
 
-    covariates = ""  # ZS: It seems to take an empty string as default. This should probably be changed.
+    # ZS: It seems to take an empty string as default. This should probably be changed.
+    covariates = ""
 
     if mapping_params['mapping_method'] == "gemma":
         header_row = ["name", "chr", "Mb", "lod_score", "p_value"]
-        if mapping_params['use_loco'] == "True":  # ZS: gemma_mapping returns both results and the filename for LOCO, so need to only grab the former for api
-            result_markers = gemma_mapping.run_gemma(this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])[0]
+        # ZS: gemma_mapping returns both results and the filename for LOCO, so need to only grab the former for api
+        if mapping_params['use_loco'] == "True":
+            result_markers = gemma_mapping.run_gemma(
+                this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])[0]
         else:
-            result_markers = gemma_mapping.run_gemma(this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])
+            result_markers = gemma_mapping.run_gemma(
+                this_trait, dataset, samples, vals, covariates, mapping_params['use_loco'], mapping_params['maf'])
     elif mapping_params['mapping_method'] == "rqtl":
         header_row = ["name", "chr", "cM", "lod_score"]
         if mapping_params['num_perm'] > 0:
             _sperm_output, _suggestive, _significant, result_markers = rqtl_mapping.run_rqtl_geno(vals, dataset, mapping_params['rqtl_method'], mapping_params['rqtl_model'],
                                                                                         mapping_params['perm_check'], mapping_params['num_perm'],
-                                                                                        mapping_params['do_control'], mapping_params['control_marker'],
+                                                                                        mapping_params['do_control'], mapping_params[
+                                                                                            'control_marker'],
                                                                                         mapping_params['manhattan_plot'], mapping_params['pair_scan'])
         else:
             result_markers = rqtl_mapping.run_rqtl_geno(vals, dataset, mapping_params['rqtl_method'], mapping_params['rqtl_model'],
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index 4f9cc6e5..e7dfa4e0 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -35,7 +35,8 @@ def hello_world():
 
 @app.route("/api/v_{}/species".format(version))
 def get_species_list():
-    results = g.db.execute("SELECT SpeciesId, Name, FullName, TaxonomyId FROM Species;")
+    results = g.db.execute(
+        "SELECT SpeciesId, Name, FullName, TaxonomyId FROM Species;")
     the_species = results.fetchall()
     species_list = []
     for species in the_species:
@@ -313,7 +314,8 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
 @app.route("/api/v_{}/traits/<path:dataset_name>".format(version), methods=("GET",))
 @app.route("/api/v_{}/traits/<path:dataset_name>.<path:file_format>".format(version), methods=("GET",))
 def fetch_traits(dataset_name, file_format="json"):
-    trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(dataset_name, request.args)
+    trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(
+        dataset_name, request.args)
     if ("ids_only" in request.args) and (len(trait_ids) > 0):
         if file_format == "json":
             filename = dataset_name + "_trait_ids.json"
@@ -361,7 +363,8 @@ def fetch_traits(dataset_name, file_format="json"):
                                 ProbeSet.Id
                         """
 
-                field_list = ["Id", "Name", "Symbol", "Description", "Chr", "Mb", "Aliases", "Mean", "SE", "Locus", "LRS", "P-Value", "Additive", "h2"]
+                field_list = ["Id", "Name", "Symbol", "Description", "Chr", "Mb",
+                    "Aliases", "Mean", "SE", "Locus", "LRS", "P-Value", "Additive", "h2"]
             elif data_type == "Geno":
                 query = """
                             SELECT
@@ -378,7 +381,8 @@ def fetch_traits(dataset_name, file_format="json"):
                                 Geno.Id
                         """
 
-                field_list = ["Id", "Name", "Marker_Name", "Chr", "Mb", "Sequence", "Source"]
+                field_list = ["Id", "Name", "Marker_Name",
+                    "Chr", "Mb", "Sequence", "Source"]
             else:
                 query = """
                             SELECT
@@ -394,7 +398,8 @@ def fetch_traits(dataset_name, file_format="json"):
                                 PublishXRef.Id
                         """
 
-                field_list = ["Id", "PhenotypeId", "PublicationId", "Locus", "LRS", "Additive", "Sequence"]
+                field_list = ["Id", "PhenotypeId", "PublicationId",
+                    "Locus", "LRS", "Additive", "Sequence"]
 
             if 'limit_to' in request.args:
                 limit_number = request.args['limit_to']
@@ -442,7 +447,8 @@ def fetch_traits(dataset_name, file_format="json"):
 @app.route("/api/v_{}/sample_data/<path:dataset_name>".format(version))
 @app.route("/api/v_{}/sample_data/<path:dataset_name>.<path:file_format>".format(version))
 def all_sample_data(dataset_name, file_format="csv"):
-    trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(dataset_name, request.args)
+    trait_ids, trait_names, data_type, dataset_id = get_dataset_trait_ids(
+        dataset_name, request.args)
 
     if len(trait_ids) > 0:
         sample_list = get_samplelist(dataset_name)
@@ -676,7 +682,8 @@ def get_trait_info(dataset_name, trait_name, file_format="json"):
 
         return flask.jsonify(trait_dict)
     else:
-        if "Publish" in dataset_name:  # ZS: Check if the user input the dataset_name as BXDPublish, etc (which is always going to be the group name + "Publish"
+        # ZS: Check if the user input the dataset_name as BXDPublish, etc (which is always going to be the group name + "Publish"
+        if "Publish" in dataset_name:
             dataset_name = dataset_name.replace("Publish", "")
         
         group_id = get_group_id(dataset_name)
@@ -711,7 +718,8 @@ def get_corr_results():
     results = correlation.do_correlation(request.args)
 
     if len(results) > 0:
-        return flask.jsonify(results)  # ZS: I think flask.jsonify expects a dict/list instead of JSON
+        # ZS: I think flask.jsonify expects a dict/list instead of JSON
+        return flask.jsonify(results)
     else:
         return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
@@ -768,7 +776,8 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                         output_lines.append(line.split())
                         i += 1
 
-            csv_writer = csv.writer(si, delimiter="\t", escapechar="\\", quoting = csv.QUOTE_NONE)
+            csv_writer = csv.writer(
+                si, delimiter="\t", escapechar="\\", quoting = csv.QUOTE_NONE)
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
     elif file_format == "rqtl2":
@@ -779,18 +788,23 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
             filename = group_name
 
         if os.path.isfile("{0}/{1}_geno.csv".format(flat_files("genotype/rqtl2"), group_name)):
-            yaml_file = json.load(open("{0}/{1}.json".format(flat_files("genotype/rqtl2"), group_name)))
+            yaml_file = json.load(
+                open("{0}/{1}.json".format(flat_files("genotype/rqtl2"), group_name)))
             yaml_file["geno"] = filename + "_geno.csv"
             yaml_file["gmap"] = filename + "_gmap.csv"
             yaml_file["pheno"] = filename + "_pheno.csv"
             config_file = [filename + ".json", json.dumps(yaml_file)]
             #config_file = [filename + ".yaml", open("{0}/{1}.yaml".format(flat_files("genotype/rqtl2"), group_name))]
-            geno_file = [filename + "_geno.csv", open("{0}/{1}_geno.csv".format(flat_files("genotype/rqtl2"), group_name))]
-            gmap_file = [filename + "_gmap.csv", open("{0}/{1}_gmap.csv".format(flat_files("genotype/rqtl2"), group_name))]
+            geno_file = [filename + "_geno.csv",
+                open("{0}/{1}_geno.csv".format(flat_files("genotype/rqtl2"), group_name))]
+            gmap_file = [filename + "_gmap.csv",
+                open("{0}/{1}_gmap.csv".format(flat_files("genotype/rqtl2"), group_name))]
             if dataset_name:
-                phenotypes = requests.get("http://gn2.genenetwork.org/api/v_pre1/sample_data/" + dataset_name)
+                phenotypes = requests.get(
+                    "http://gn2.genenetwork.org/api/v_pre1/sample_data/" + dataset_name)
             else:
-                phenotypes = requests.get("http://gn2.genenetwork.org/api/v_pre1/sample_data/" + group_name + "Publish")
+                phenotypes = requests.get(
+                    "http://gn2.genenetwork.org/api/v_pre1/sample_data/" + group_name + "Publish")
 
             with ZipFile(memory_file, 'w', compression=ZIP_DEFLATED) as zf:
                 zf.writestr(config_file[0], config_file[1])
@@ -813,7 +827,8 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                 for line in genofile:
                     if limit_num and i >= limit_num:
                         break
-                    output_lines.append([line.strip() for line in line.split(",")])
+                    output_lines.append([line.strip()
+                                        for line in line.split(",")])
                     i += 1
 
             csv_writer = csv.writer(si, delimiter=",")
@@ -898,7 +913,8 @@ def get_dataset_trait_ids(dataset_name, start_vars):
         results = g.db.execute(query).fetchall()
 
         trait_ids = [result[0] for result in results]
-        trait_names = [str(result[2]) + "_" + str(result[1]) for result in results]
+        trait_names = [str(result[2]) + "_" + str(result[1])
+                           for result in results]
 
         return trait_ids, trait_names, data_type, dataset_id
 
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 61f73106..1fcf15f0 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -158,7 +158,8 @@ def remove_traits():
     traits_to_remove = params['trait_list']
     traits_to_remove = process_traits(traits_to_remove)
 
-    members_now = g.user_session.remove_traits_from_collection(uc_id, traits_to_remove)
+    members_now = g.user_session.remove_traits_from_collection(
+        uc_id, traits_to_remove)
 
     return redirect(url_for("view_collection", uc_id=uc_id))
 
@@ -181,7 +182,8 @@ def delete_collection():
         else:
             flash("We've deleted the selected collection.", "alert-info")
     else:
-        flash("We've deleted the collection: {}.".format(collection_name), "alert-info")
+        flash("We've deleted the collection: {}.".format(
+            collection_name), "alert-info")
 
     return redirect(url_for('list_collections'))
 
@@ -191,7 +193,8 @@ def view_collection():
     params = request.args
 
     uc_id = params['uc_id']
-    uc = next((collection for collection in g.user_session.user_collections if collection["id"] == uc_id))
+    uc = next(
+        (collection for collection in g.user_session.user_collections if collection["id"] == uc_id))
     traits = uc["members"]
 
     trait_obs = []
@@ -203,12 +206,14 @@ def view_collection():
         name, dataset_name = atrait.split(':')
         if dataset_name == "Temp":
             group = name.split("_")[2]
-            dataset = create_dataset(dataset_name, dataset_type="Temp", group_name=group)
+            dataset = create_dataset(
+                dataset_name, dataset_type="Temp", group_name=group)
             trait_ob = create_trait(name=name, dataset=dataset)
         else:
             dataset = create_dataset(dataset_name)
             trait_ob = create_trait(name=name, dataset=dataset)
-            trait_ob = retrieve_trait_info(trait_ob, dataset, get_qtl_info=True)
+            trait_ob = retrieve_trait_info(
+                trait_ob, dataset, get_qtl_info=True)
         trait_obs.append(trait_ob)
 
         json_version.append(jsonable(trait_ob))
diff --git a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
index c135faa3..0fabb833 100644
--- a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
+++ b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
@@ -34,14 +34,16 @@ from flask import Flask, g
 class ComparisonBarChart:
 
     def __init__(self, start_vars):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
 
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.all_sample_list = []
         self.traits = []
         self.insufficient_shared_samples = False
-        this_group = self.trait_list[0][1].group.name  # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        this_group = self.trait_list[0][1].group.name
         for trait_db in self.trait_list:
             
             if trait_db[1].group.name != this_group:
diff --git a/wqflask/wqflask/correlation/corr_scatter_plot.py b/wqflask/wqflask/correlation/corr_scatter_plot.py
index 6afea715..f9a0ea11 100644
--- a/wqflask/wqflask/correlation/corr_scatter_plot.py
+++ b/wqflask/wqflask/correlation/corr_scatter_plot.py
@@ -17,17 +17,21 @@ class CorrScatterPlot:
 
     def __init__(self, params):
         if "Temp" in params['dataset_1']:
-            self.dataset_1 = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_1'].split("_")[1])
+            self.dataset_1 = data_set.create_dataset(
+                dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_1'].split("_")[1])
         else:
             self.dataset_1 = data_set.create_dataset(params['dataset_1'])
         if "Temp" in params['dataset_2']:
-            self.dataset_2 = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_2'].split("_")[1])
+            self.dataset_2 = data_set.create_dataset(
+                dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_2'].split("_")[1])
         else:
             self.dataset_2 = data_set.create_dataset(params['dataset_2'])
 
         #self.dataset_3 = data_set.create_dataset(params['dataset_3'])
-        self.trait_1 = create_trait(name=params['trait_1'], dataset=self.dataset_1)
-        self.trait_2 = create_trait(name=params['trait_2'], dataset=self.dataset_2)
+        self.trait_1 = create_trait(
+            name=params['trait_1'], dataset=self.dataset_1)
+        self.trait_2 = create_trait(
+            name=params['trait_2'], dataset=self.dataset_2)
         #self.trait_3 = create_trait(name=params['trait_3'], dataset=self.dataset_3)
 
         self.method = params['method']
@@ -38,10 +42,13 @@ class CorrScatterPlot:
         if self.dataset_1.group.f1list != None:
             primary_samples += self.dataset_1.group.f1list
 
-        self.trait_1 = retrieve_sample_data(self.trait_1, self.dataset_1, primary_samples)
-        self.trait_2 = retrieve_sample_data(self.trait_2, self.dataset_2, primary_samples)
+        self.trait_1 = retrieve_sample_data(
+            self.trait_1, self.dataset_1, primary_samples)
+        self.trait_2 = retrieve_sample_data(
+            self.trait_2, self.dataset_2, primary_samples)
 
-        samples_1, samples_2, num_overlap = corr_result_helpers.normalize_values_with_samples(self.trait_1.data, self.trait_2.data)
+        samples_1, samples_2, num_overlap = corr_result_helpers.normalize_values_with_samples(
+            self.trait_1.data, self.trait_2.data)
 
         self.data = []
         self.indIDs = list(samples_1.keys())
@@ -54,7 +61,8 @@ class CorrScatterPlot:
             vals_2.append(samples_2[sample].value)
         self.data.append(vals_2)
 
-        slope, intercept, r_value, p_value, std_err = stats.linregress(vals_1, vals_2)
+        slope, intercept, r_value, p_value, std_err = stats.linregress(
+            vals_1, vals_2)
 
         if slope < 0.001:
             slope_string = '%.3E' % slope
@@ -67,14 +75,16 @@ class CorrScatterPlot:
         x_range = [min(vals_1) - x_buffer, max(vals_1) + x_buffer]
         y_range = [min(vals_2) - y_buffer, max(vals_2) + y_buffer]
 
-        intercept_coords = get_intercept_coords(slope, intercept, x_range, y_range)
+        intercept_coords = get_intercept_coords(
+            slope, intercept, x_range, y_range)
 
         rx = stats.rankdata(vals_1)
         ry = stats.rankdata(vals_2)
         self.rdata = []
         self.rdata.append(rx.tolist())
         self.rdata.append(ry.tolist())        
-        srslope, srintercept, srr_value, srp_value, srstd_err = stats.linregress(rx, ry)
+        srslope, srintercept, srr_value, srp_value, srstd_err = stats.linregress(
+            rx, ry)
 
         if srslope < 0.001:
             srslope_string = '%.3E' % srslope
@@ -86,7 +96,8 @@ class CorrScatterPlot:
 
         sr_range = [min(rx) - x_buffer, max(rx) + x_buffer]
 
-        sr_intercept_coords = get_intercept_coords(srslope, srintercept, sr_range, sr_range)
+        sr_intercept_coords = get_intercept_coords(
+            srslope, srintercept, sr_range, sr_range)
 
         self.collections_exist = "False"
         if g.user_session.num_collections > 0:
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index e2fe1ff4..e75c4a85 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -78,7 +78,8 @@ class CorrelationResults:
 
         with Bench("Doing correlations"):
             if start_vars['dataset'] == "Temp":
-                self.dataset = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = start_vars['group'])
+                self.dataset = data_set.create_dataset(
+                    dataset_name="Temp", dataset_type="Temp", group_name = start_vars['group'])
                 self.trait_id = start_vars['trait_id']
                 self.this_trait = create_trait(dataset=self.dataset,
                                            name=self.trait_id,
@@ -129,12 +130,15 @@ class CorrelationResults:
                 if corr_samples_group == 'samples_other':
                     primary_samples = [x for x in primary_samples if x not in (
                                     self.dataset.group.parlist + self.dataset.group.f1list)]
-                self.process_samples(start_vars, list(self.this_trait.data.keys()), primary_samples)
+                self.process_samples(start_vars, list(
+                    self.this_trait.data.keys()), primary_samples)
 
-            self.target_dataset = data_set.create_dataset(start_vars['corr_dataset'])
+            self.target_dataset = data_set.create_dataset(
+                start_vars['corr_dataset'])
             self.target_dataset.get_trait_data(list(self.sample_data.keys()))
 
-            self.header_fields = get_header_fields(self.target_dataset.type, self.corr_method)
+            self.header_fields = get_header_fields(
+                self.target_dataset.type, self.corr_method)
 
             if self.target_dataset.type == "ProbeSet":
                 self.filter_cols = [7, 6]
@@ -153,7 +157,8 @@ class CorrelationResults:
                 tissue_corr_data = self.do_tissue_correlation_for_all_traits()
                 if tissue_corr_data != None:
                     for trait in list(tissue_corr_data.keys())[:self.return_number]:
-                        self.get_sample_r_and_p_values(trait, self.target_dataset.trait_data[trait])
+                        self.get_sample_r_and_p_values(
+                            trait, self.target_dataset.trait_data[trait])
                 else:
                     for trait, values in list(self.target_dataset.trait_data.items()):
                         self.get_sample_r_and_p_values(trait, values)
@@ -163,7 +168,8 @@ class CorrelationResults:
                 lit_corr_data = self.do_lit_correlation_for_all_traits()
 
                 for trait in list(lit_corr_data.keys())[:self.return_number]:
-                    self.get_sample_r_and_p_values(trait, self.target_dataset.trait_data[trait])
+                    self.get_sample_r_and_p_values(
+                        trait, self.target_dataset.trait_data[trait])
 
             elif self.corr_type == "sample":
                 for trait, values in list(self.target_dataset.trait_data.items()):
@@ -180,7 +186,8 @@ class CorrelationResults:
                         range_chr_as_int = order_id
 
             for _trait_counter, trait in enumerate(list(self.correlation_data.keys())[:self.return_number]):
-                trait_object = create_trait(dataset=self.target_dataset, name=trait, get_qtl_info=True, get_sample_info=False)
+                trait_object = create_trait(
+                    dataset=self.target_dataset, name=trait, get_qtl_info=True, get_sample_info=False)
                 if not trait_object:
                     continue
 
@@ -235,7 +242,8 @@ class CorrelationResults:
             if self.corr_type != "tissue" and self.dataset.type == "ProbeSet" and self.target_dataset.type == "ProbeSet":
                 self.do_tissue_correlation_for_trait_list()
 
-        self.json_results = generate_corr_json(self.correlation_results, self.this_trait, self.dataset, self.target_dataset)
+        self.json_results = generate_corr_json(
+            self.correlation_results, self.this_trait, self.dataset, self.target_dataset)
 
 ############################################################################################################################################
 
@@ -263,15 +271,18 @@ class CorrelationResults:
             symbol_list=[self.this_trait.symbol])
 
         if self.this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
-            primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower()]
-            gene_symbol_list = [trait.symbol for trait in self.correlation_results if trait.symbol]
+            primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower(
+            )]
+            gene_symbol_list = [
+                trait.symbol for trait in self.correlation_results if trait.symbol]
 
             corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
                                                     symbol_list=gene_symbol_list)
 
             for trait in self.correlation_results:
                 if trait.symbol and trait.symbol.lower() in corr_result_tissue_vals_dict:
-                    this_trait_tissue_values = corr_result_tissue_vals_dict[trait.symbol.lower()]
+                    this_trait_tissue_values = corr_result_tissue_vals_dict[trait.symbol.lower(
+                    )]
 
                     result = correlation_functions.cal_zero_order_corr_for_tiss(primary_trait_tissue_values,
                                                                           this_trait_tissue_values,
@@ -286,7 +297,8 @@ class CorrelationResults:
             symbol_list=[self.this_trait.symbol])
 
         if self.this_trait.symbol.lower() in primary_trait_tissue_vals_dict:
-            primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower()]
+            primary_trait_tissue_values = primary_trait_tissue_vals_dict[self.this_trait.symbol.lower(
+            )]
 
             #print("trait_gene_symbols: ", pf(trait_gene_symbols.values()))
             corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
@@ -299,7 +311,8 @@ class CorrelationResults:
             tissue_corr_data = {}
             for trait, symbol in list(self.trait_symbol_dict.items()):
                 if symbol and symbol.lower() in corr_result_tissue_vals_dict:
-                    this_trait_tissue_values = corr_result_tissue_vals_dict[symbol.lower()]
+                    this_trait_tissue_values = corr_result_tissue_vals_dict[symbol.lower(
+                    )]
 
                     result = correlation_functions.cal_zero_order_corr_for_tiss(primary_trait_tissue_values,
                                                                           this_trait_tissue_values,
@@ -314,12 +327,14 @@ class CorrelationResults:
 
     def do_lit_correlation_for_trait_list(self):
 
-        input_trait_mouse_gene_id = self.convert_to_mouse_gene_id(self.dataset.group.species.lower(), self.this_trait.geneid)
+        input_trait_mouse_gene_id = self.convert_to_mouse_gene_id(
+            self.dataset.group.species.lower(), self.this_trait.geneid)
 
         for trait in self.correlation_results:
 
             if trait.geneid:
-                trait.mouse_gene_id = self.convert_to_mouse_gene_id(self.dataset.group.species.lower(), trait.geneid)
+                trait.mouse_gene_id = self.convert_to_mouse_gene_id(
+                    self.dataset.group.species.lower(), trait.geneid)
             else:
                 trait.mouse_gene_id = None
 
@@ -348,11 +363,13 @@ class CorrelationResults:
                 trait.lit_corr = 0
 
     def do_lit_correlation_for_all_traits(self):
-        input_trait_mouse_gene_id = self.convert_to_mouse_gene_id(self.dataset.group.species.lower(), self.this_trait.geneid)
+        input_trait_mouse_gene_id = self.convert_to_mouse_gene_id(
+            self.dataset.group.species.lower(), self.this_trait.geneid)
 
         lit_corr_data = {}
         for trait, gene_id in list(self.trait_geneid_dict.items()):
-            mouse_gene_id = self.convert_to_mouse_gene_id(self.dataset.group.species.lower(), gene_id)
+            mouse_gene_id = self.convert_to_mouse_gene_id(
+                self.dataset.group.species.lower(), gene_id)
 
             if mouse_gene_id and str(mouse_gene_id).find(";") == -1:
                 #print("gene_symbols:", input_trait_mouse_gene_id + " / " + mouse_gene_id)
@@ -438,21 +455,26 @@ class CorrelationResults:
                 self.this_trait_vals.append(sample_value)
                 target_vals.append(target_sample_value)
 
-        self.this_trait_vals, target_vals, num_overlap = corr_result_helpers.normalize_values(self.this_trait_vals, target_vals)
+        self.this_trait_vals, target_vals, num_overlap = corr_result_helpers.normalize_values(
+            self.this_trait_vals, target_vals)
 
         if num_overlap > 5:
             # ZS: 2015 could add biweight correlation, see http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3465711/
             if self.corr_method == 'bicor':
-                sample_r, sample_p = do_bicor(self.this_trait_vals, target_vals)
+                sample_r, sample_p = do_bicor(
+                    self.this_trait_vals, target_vals)
             elif self.corr_method == 'pearson':
-                sample_r, sample_p = scipy.stats.pearsonr(self.this_trait_vals, target_vals)
+                sample_r, sample_p = scipy.stats.pearsonr(
+                    self.this_trait_vals, target_vals)
             else:
-                sample_r, sample_p = scipy.stats.spearmanr(self.this_trait_vals, target_vals)
+                sample_r, sample_p = scipy.stats.spearmanr(
+                    self.this_trait_vals, target_vals)
 
             if numpy.isnan(sample_r):
                 pass
             else:
-                self.correlation_data[trait] = [sample_r, sample_p, num_overlap]
+                self.correlation_data[trait] = [
+                    sample_r, sample_p, num_overlap]
 
     def process_samples(self, start_vars, sample_names, excluded_samples=None):
         if not excluded_samples:
@@ -478,7 +500,8 @@ def do_bicor(this_trait_vals, target_trait_vals):
     this_vals = ro.Vector(this_trait_vals)
     target_vals = ro.Vector(target_trait_vals)
 
-    the_r, the_p, _fisher_transform, _the_t, _n_obs = [numpy.asarray(x) for x in r_bicor(x=this_vals, y=target_vals)]
+    the_r, the_p, _fisher_transform, _the_t, _n_obs = [
+        numpy.asarray(x) for x in r_bicor(x=this_vals, y=target_vals)]
 
     return the_r, the_p
 
@@ -492,7 +515,8 @@ def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_ap
         results_dict['index'] = i + 1
         results_dict['trait_id'] = trait.name
         results_dict['dataset'] = trait.dataset.name
-        results_dict['hmac'] = hmac.data_hmac('{}:{}'.format(trait.name, trait.dataset.name))
+        results_dict['hmac'] = hmac.data_hmac(
+            '{}:{}'.format(trait.name, trait.dataset.name))
         if target_dataset.type == "ProbeSet":
             results_dict['symbol'] = trait.symbol
             results_dict['description'] = "N/A"
@@ -543,7 +567,8 @@ def generate_corr_json(corr_results, this_trait, dataset, target_dataset, for_ap
             if bool(trait.authors):
                 authors_list = trait.authors.split(',')
                 if len(authors_list) > 6:
-                    results_dict['authors_display'] = ", ".join(authors_list[:6]) + ", et al."
+                    results_dict['authors_display'] = ", ".join(
+                        authors_list[:6]) + ", et al."
                 else:
                     results_dict['authors_display'] = trait.authors
             if bool(trait.pubmed_id):
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index 331cb1dc..aefb4453 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -44,7 +44,8 @@ THIRTY_DAYS = 60 * 60 * 24 * 30
 class CorrelationMatrix:
 
     def __init__(self, start_vars):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
 
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
@@ -52,7 +53,8 @@ class CorrelationMatrix:
         self.traits = []
         self.insufficient_shared_samples = False
         self.do_PCA = True
-        this_group = self.trait_list[0][1].group.name  # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
+        this_group = self.trait_list[0][1].group.name
         for trait_db in self.trait_list:
             this_group = trait_db[1].group.name
             this_trait = trait_db[0]
@@ -76,10 +78,12 @@ class CorrelationMatrix:
                     this_trait_vals.append('')
             self.sample_data.append(this_trait_vals)
 
-        if len(this_trait_vals) < len(self.trait_list):  # Shouldn't do PCA if there are more traits than observations/samples
+        # Shouldn't do PCA if there are more traits than observations/samples
+        if len(this_trait_vals) < len(self.trait_list):
             self.do_PCA = False
 
-        self.lowest_overlap = 8  # ZS: Variable set to the lowest overlapping samples in order to notify user, or 8, whichever is lower (since 8 is when we want to display warning)
+        # ZS: Variable set to the lowest overlapping samples in order to notify user, or 8, whichever is lower (since 8 is when we want to display warning)
+        self.lowest_overlap = 8
 
         self.corr_results = []
         self.pca_corr_results = []
@@ -112,7 +116,8 @@ class CorrelationMatrix:
                         if sample in self.shared_samples_list:
                             self.shared_samples_list.remove(sample)
 
-                this_trait_vals, target_vals, num_overlap = corr_result_helpers.normalize_values(this_trait_vals, target_vals)
+                this_trait_vals, target_vals, num_overlap = corr_result_helpers.normalize_values(
+                    this_trait_vals, target_vals)
 
                 if num_overlap < self.lowest_overlap:
                     self.lowest_overlap = num_overlap
@@ -120,21 +125,25 @@ class CorrelationMatrix:
                     corr_result_row.append([target_trait, 0, num_overlap])
                     pca_corr_result_row.append(0)
                 else:
-                    pearson_r, pearson_p = scipy.stats.pearsonr(this_trait_vals, target_vals)
+                    pearson_r, pearson_p = scipy.stats.pearsonr(
+                        this_trait_vals, target_vals)
                     if is_spearman == False:
                         sample_r, sample_p = pearson_r, pearson_p
                         if sample_r == 1:
                             is_spearman = True
                     else:
-                        sample_r, sample_p = scipy.stats.spearmanr(this_trait_vals, target_vals)
+                        sample_r, sample_p = scipy.stats.spearmanr(
+                            this_trait_vals, target_vals)
 
-                    corr_result_row.append([target_trait, sample_r, num_overlap])
+                    corr_result_row.append(
+                        [target_trait, sample_r, num_overlap])
                     pca_corr_result_row.append(pearson_r)
 
             self.corr_results.append(corr_result_row)
             self.pca_corr_results.append(pca_corr_result_row)
 
-        self.export_filename, self.export_filepath = export_corr_matrix(self.corr_results)
+        self.export_filename, self.export_filepath = export_corr_matrix(
+            self.corr_results)
 
         self.trait_data_array = []
         for trait_db in self.trait_list:
@@ -156,12 +165,14 @@ class CorrelationMatrix:
 
         try:
             corr_result_eigen = np.linalg.eig(np.array(self.pca_corr_results))
-            corr_eigen_value, corr_eigen_vectors = sortEigenVectors(corr_result_eigen)
+            corr_eigen_value, corr_eigen_vectors = sortEigenVectors(
+                corr_result_eigen)
 
             if self.do_PCA == True:
                 self.pca_works = "True"
                 self.pca_trait_ids = []
-                pca = self.calculate_pca(list(range(len(self.traits))), corr_eigen_value, corr_eigen_vectors)
+                pca = self.calculate_pca(
+                    list(range(len(self.traits))), corr_eigen_value, corr_eigen_vectors)
                 self.loadings_array = self.process_loadings()
             else:
                 self.pca_works = "False"
@@ -179,7 +190,8 @@ class CorrelationMatrix:
         base = importr('base')
         stats = importr('stats')
 
-        corr_results_to_list = robjects.FloatVector([item for sublist in self.pca_corr_results for item in sublist])
+        corr_results_to_list = robjects.FloatVector(
+            [item for sublist in self.pca_corr_results for item in sublist])
 
         m = robjects.r.matrix(corr_results_to_list, nrow=len(cols))
         eigen = base.eigen(m)
@@ -198,10 +210,12 @@ class CorrelationMatrix:
             pca_traits.append((vector * -1.0).tolist())
 
         this_group_name = self.trait_list[0][1].group.name
-        temp_dataset = data_set.create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = this_group_name)
+        temp_dataset = data_set.create_dataset(
+            dataset_name="Temp", dataset_type="Temp", group_name = this_group_name)
         temp_dataset.group.get_samplelist()
         for i, pca_trait in enumerate(pca_traits):
-            trait_id = "PCA" + str(i + 1) + "_" + temp_dataset.group.species + "_" + this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
+            trait_id = "PCA" + str(i + 1) + "_" + temp_dataset.group.species + "_" + \
+                                   this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
             this_vals_string = ""
             position = 0
             for sample in temp_dataset.group.all_samples_ordered():
@@ -235,17 +249,23 @@ class CorrelationMatrix:
 
 
 def export_corr_matrix(corr_results):
-    corr_matrix_filename = "corr_matrix_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
-    matrix_export_path = "{}{}.csv".format(GENERATED_TEXT_DIR, corr_matrix_filename)
+    corr_matrix_filename = "corr_matrix_" + \
+        ''.join(random.choice(string.ascii_uppercase + string.digits)
+                for _ in range(6))
+    matrix_export_path = "{}{}.csv".format(
+        GENERATED_TEXT_DIR, corr_matrix_filename)
     with open(matrix_export_path, "w+") as output_file:
-        output_file.write("Time/Date: " + datetime.datetime.now().strftime("%x / %X") + "\n")
+        output_file.write(
+            "Time/Date: " + datetime.datetime.now().strftime("%x / %X") + "\n")
         output_file.write("\n")
         output_file.write("Correlation ")
         for i, item in enumerate(corr_results[0]):
-            output_file.write("Trait" + str(i + 1) + ": " + str(item[0].dataset.name) + "::" + str(item[0].name) + "\t")
+            output_file.write("Trait" + str(i + 1) + ": " + \
+                              str(item[0].dataset.name) + "::" + str(item[0].name) + "\t")
         output_file.write("\n")
         for i, row in enumerate(corr_results):
-            output_file.write("Trait" + str(i + 1) + ": " + str(row[0][0].dataset.name) + "::" + str(row[0][0].name) + "\t")
+            output_file.write("Trait" + str(i + 1) + ": " + \
+                              str(row[0][0].dataset.name) + "::" + str(row[0][0].name) + "\t")
             for item in row:
                 output_file.write(str(item[1]) + "\t")
             output_file.write("\n")
@@ -254,10 +274,12 @@ def export_corr_matrix(corr_results):
         output_file.write("\n")
         output_file.write("N ")
         for i, item in enumerate(corr_results[0]):
-            output_file.write("Trait" + str(i) + ": " + str(item[0].dataset.name) + "::" + str(item[0].name) + "\t")
+            output_file.write("Trait" + str(i) + ": " + \
+                              str(item[0].dataset.name) + "::" + str(item[0].name) + "\t")
         output_file.write("\n")
         for i, row in enumerate(corr_results):
-            output_file.write("Trait" + str(i) + ": " + str(row[0][0].dataset.name) + "::" + str(row[0][0].name) + "\t")
+            output_file.write("Trait" + str(i) + ": " + \
+                              str(row[0][0].dataset.name) + "::" + str(row[0][0].name) + "\t")
             for item in row:
                 output_file.write(str(item[2]) + "\t")
             output_file.write("\n")
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index ec66e59f..48a82435 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -46,13 +46,18 @@ class CTL:
         #log = r_file("/tmp/genenetwork_ctl.log", open = "wt")
         # r_sink(log)                                                       # Uncomment the r_sink() commands to log output from stdout/stderr to a file
         #r_sink(log, type = "message")
-        r_library("ctl")                                                   # Load CTL - Should only be done once, since it is quite expensive
+        # Load CTL - Should only be done once, since it is quite expensive
+        r_library("ctl")
         r_options(stringsAsFactors=False)
         logger.info("Initialization of CTL done, package loaded in R session")
-        self.r_CTLscan = ro.r["CTLscan"]                        # Map the CTLscan function
-        self.r_CTLsignificant = ro.r["CTLsignificant"]                 # Map the CTLsignificant function
-        self.r_lineplot = ro.r["ctl.lineplot"]                   # Map the ctl.lineplot function
-        self.r_plotCTLobject = ro.r["plot.CTLobject"]                 # Map the CTLsignificant function
+        # Map the CTLscan function
+        self.r_CTLscan = ro.r["CTLscan"]
+        # Map the CTLsignificant function
+        self.r_CTLsignificant = ro.r["CTLsignificant"]
+        # Map the ctl.lineplot function
+        self.r_lineplot = ro.r["ctl.lineplot"]
+        # Map the CTLsignificant function
+        self.r_plotCTLobject = ro.r["plot.CTLobject"]
         self.nodes_list = []
         self.edges_list = []
         logger.info("Obtained pointers to CTL functions")
@@ -81,7 +86,8 @@ class CTL:
 
     def run_analysis(self, requestform):
         logger.info("Starting CTL analysis on dataset")
-        self.trait_db_list = [trait.strip() for trait in requestform['trait_list'].split(',')]
+        self.trait_db_list = [trait.strip()
+                                          for trait in requestform['trait_list'].split(',')]
         self.trait_db_list = [x for x in self.trait_db_list if x]
 
         logger.debug("strategy:", requestform.get("strategy"))
@@ -113,9 +119,11 @@ class CTL:
           markers.append(marker["genotypes"])
 
         genotypes = list(itertools.chain(*markers))
-        logger.debug(len(genotypes) / len(individuals), "==", len(parser.markers))
+        logger.debug(len(genotypes) / len(individuals),
+                     "==", len(parser.markers))
 
-        rGeno = r_t(ro.r.matrix(r_unlist(genotypes), nrow=len(markernames), ncol=len(individuals), dimnames=r_list(markernames, individuals), byrow=True))
+        rGeno = r_t(ro.r.matrix(r_unlist(genotypes), nrow=len(markernames), ncol=len(
+            individuals), dimnames=r_list(markernames, individuals), byrow=True))
 
         # Create a phenotype matrix
         traits = []
@@ -131,7 +139,8 @@ class CTL:
               else:
                 traits.append("-999")
 
-        rPheno = r_t(ro.r.matrix(r_as_numeric(r_unlist(traits)), nrow=len(self.trait_db_list), ncol=len(individuals), dimnames=r_list(self.trait_db_list, individuals), byrow=True))
+        rPheno = r_t(ro.r.matrix(r_as_numeric(r_unlist(traits)), nrow=len(self.trait_db_list), ncol=len(
+            individuals), dimnames=r_list(self.trait_db_list, individuals), byrow=True))
 
         logger.debug(rPheno)
 
@@ -144,7 +153,8 @@ class CTL:
         #r_write_table(rPheno, "~/outputGN/pheno.csv")
 
         # Perform the CTL scan
-        res = self.r_CTLscan(rGeno, rPheno, strategy=strategy, nperm=nperm, parametric = parametric, nthreads=6)
+        res = self.r_CTLscan(rGeno, rPheno, strategy=strategy,
+                             nperm=nperm, parametric = parametric, nthreads=6)
 
         # Get significant interactions
         significant = self.r_CTLsignificant(res, significance=significance)
@@ -155,20 +165,27 @@ class CTL:
         self.results['imgloc1'] = GENERATED_IMAGE_DIR + self.results['imgurl1']
 
         self.results['ctlresult'] = significant
-        self.results['requestform'] = requestform             # Store the user specified parameters for the output page
+        # Store the user specified parameters for the output page
+        self.results['requestform'] = requestform
 
         # Create the lineplot
-        r_png(self.results['imgloc1'], width=1000, height=600, type='cairo-png')
+        r_png(self.results['imgloc1'], width=1000,
+              height=600, type='cairo-png')
         self.r_lineplot(res, significance=significance)
         r_dev_off()
 
-        n = 2                                                 # We start from 2, since R starts from 1 :)
+        # We start from 2, since R starts from 1 :)
+        n = 2
         for trait in self.trait_db_list:
           # Create the QTL like CTL plots
-          self.results['imgurl' + str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
-          self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + self.results['imgurl' + str(n)]
-          r_png(self.results['imgloc' + str(n)], width=1000, height=600, type='cairo-png')
-          self.r_plotCTLobject(res, (n - 1), significance=significance, main='Phenotype ' + trait)
+          self.results['imgurl' + \
+              str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
+          self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + \
+                                      self.results['imgurl' + str(n)]
+          r_png(self.results['imgloc' + str(n)],
+                width=1000, height=600, type='cairo-png')
+          self.r_plotCTLobject(
+              res, (n - 1), significance=significance, main='Phenotype ' + trait)
           r_dev_off()
           n = n + 1
 
@@ -178,17 +195,24 @@ class CTL:
         # Create the interactive graph for cytoscape visualization (Nodes and Edges)
         if not isinstance(significant, ri.RNULLType):
           for x in range(len(significant[0])):
-            logger.debug(significant[0][x], significant[1][x], significant[2][x])     # Debug to console
-            tsS = significant[0][x].split(':')                                        # Source
-            tsT = significant[2][x].split(':')                                        # Target
-            gtS = create_trait(name=tsS[0], dataset_name=tsS[1])            # Retrieve Source info from the DB
-            gtT = create_trait(name=tsT[0], dataset_name=tsT[1])            # Retrieve Target info from the DB
+            logger.debug(significant[0][x], significant[1]
+                         [x], significant[2][x])     # Debug to console
+            # Source
+            tsS = significant[0][x].split(':')
+            # Target
+            tsT = significant[2][x].split(':')
+            # Retrieve Source info from the DB
+            gtS = create_trait(name=tsS[0], dataset_name=tsS[1])
+            # Retrieve Target info from the DB
+            gtT = create_trait(name=tsT[0], dataset_name=tsT[1])
             self.addNode(gtS)
             self.addNode(gtT)
             self.addEdge(gtS, gtT, significant, x)
 
-            significant[0][x] = "{} ({})".format(gtS.symbol, gtS.name)                    # Update the trait name for the displayed table
-            significant[2][x] = "{} ({})".format(gtT.symbol, gtT.name)                    # Update the trait name for the displayed table
+            # Update the trait name for the displayed table
+            significant[0][x] = "{} ({})".format(gtS.symbol, gtS.name)
+            # Update the trait name for the displayed table
+            significant[2][x] = "{} ({})".format(gtT.symbol, gtT.name)
 
         self.elements = json.dumps(self.nodes_list + self.edges_list)
 
diff --git a/wqflask/wqflask/do_search.py b/wqflask/wqflask/do_search.py
index 7442dc72..e50ff50b 100644
--- a/wqflask/wqflask/do_search.py
+++ b/wqflask/wqflask/do_search.py
@@ -26,14 +26,16 @@ class DoSearch:
     def __init__(self, search_term, search_operator=None, dataset=None, search_type=None):
         self.search_term = search_term
         # Make sure search_operator is something we expect
-        assert search_operator in (None, "=", "<", ">", "<=", ">="), "Bad search operator"
+        assert search_operator in (
+            None, "=", "<", ">", "<=", ">="), "Bad search operator"
         self.search_operator = search_operator
         self.dataset = dataset
         self.search_type = search_type
 
         if self.dataset:
             # Get group information for dataset and the species id
-            self.species_id = webqtlDatabaseFunction.retrieve_species_id(self.dataset.group.name)
+            self.species_id = webqtlDatabaseFunction.retrieve_species_id(
+                self.dataset.group.name)
 
     def execute(self, query):
         """Executes query and returns results"""
@@ -104,7 +106,8 @@ class MrnaAssaySearch(DoSearch):
         search_string = escape(self.search_term[0])
 
         if self.search_term[0] != "*":
-            match_clause = """((MATCH (ProbeSet.symbol) AGAINST ('%s' IN BOOLEAN MODE))) and """ % (search_string)
+            match_clause = """((MATCH (ProbeSet.symbol) AGAINST ('%s' IN BOOLEAN MODE))) and """ % (
+                search_string)
         else:
             match_clause = ""
 
@@ -223,16 +226,19 @@ class PhenotypeSearch(DoSearch):
         # and comment here
 
         # if "'" not in self.search_term[0]:
-        search_term = "[[:<:]]" + self.handle_wildcard(self.search_term[0]) + "[[:>:]]"
+        search_term = "[[:<:]]" + \
+            self.handle_wildcard(self.search_term[0]) + "[[:>:]]"
         if "_" in self.search_term[0]:
             if len(self.search_term[0].split("_")[0]) == 3:
-                search_term = "[[:<:]]" + self.handle_wildcard(self.search_term[0].split("_")[1]) + "[[:>:]]"
+                search_term = "[[:<:]]" + self.handle_wildcard(
+                    self.search_term[0].split("_")[1]) + "[[:>:]]"
 
         # This adds a clause to the query that matches the search term
         # against each field in the search_fields tuple
         where_clause_list = []
         for field in self.search_fields:
-            where_clause_list.append('''%s REGEXP "%s"''' % (field, search_term))
+            where_clause_list.append('''%s REGEXP "%s"''' %
+                                     (field, search_term))
         where_clause = "(%s) " % ' OR '.join(where_clause_list)
 
         return where_clause
@@ -364,7 +370,8 @@ class GenotypeSearch(DoSearch):
         if self.search_term[0] == "*":
             self.query = self.compile_final_query()
         else:
-            self.query = self.compile_final_query(where_clause=self.get_where_clause())
+            self.query = self.compile_final_query(
+                where_clause=self.get_where_clause())
 
         return self.execute(self.query)
 
@@ -497,7 +504,8 @@ class LrsSearch(DoSearch):
 
             where_clause = """ %sXRef.LRS > %s and
                              %sXRef.LRS < %s """ % self.mescape(self.dataset.type,
-                                                                min(lrs_min, lrs_max),
+                                                                min(lrs_min,
+                                                                    lrs_max),
                                                                 self.dataset.type,
                                                                 max(lrs_min, lrs_max))
 
@@ -537,7 +545,8 @@ class LrsSearch(DoSearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(self.from_clause, self.where_clause)
+        self.query = self.compile_final_query(
+            self.from_clause, self.where_clause)
 
         return self.execute(self.query)
 
@@ -551,7 +560,8 @@ class MrnaLrsSearch(LrsSearch, MrnaAssaySearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(from_clause=self.from_clause, where_clause=self.where_clause)
+        self.query = self.compile_final_query(
+            from_clause=self.from_clause, where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -566,7 +576,8 @@ class PhenotypeLrsSearch(LrsSearch, PhenotypeSearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(from_clause=self.from_clause, where_clause=self.where_clause)
+        self.query = self.compile_final_query(
+            from_clause=self.from_clause, where_clause=self.where_clause)
 
         return self.execute(self.query)
 
@@ -593,7 +604,8 @@ class CisTransLrsSearch(DoSearch):
             elif len(self.search_term) == 3:
                 lrs_min, lrs_max, self.mb_buffer = self.search_term
             elif len(self.search_term) == 4:
-                lrs_min, lrs_max, self.mb_buffer = [float(value) for value in self.search_term[:3]]
+                lrs_min, lrs_max, self.mb_buffer = [
+                    float(value) for value in self.search_term[:3]]
                 chromosome = self.search_term[3]
                 if "Chr" in chromosome or "chr" in chromosome:
                     chromosome = int(chromosome[3:])
@@ -636,14 +648,19 @@ class CisTransLrsSearch(DoSearch):
             if chromosome:
                 location_clause = "(%s.Chr = '%s' and %s.Chr = Geno.Chr and ABS(%s.Mb-Geno.Mb) %s %s) or (%s.Chr != Geno.Chr and Geno.Chr = '%s')" % (escape(self.dataset.type),
                                                                                                                                                   chromosome,
-                                                                                                                                                  escape(self.dataset.type),
-                                                                                                                                                  escape(self.dataset.type),
+                                                                                                                                                  escape(
+                                                                                                                                                      self.dataset.type),
+                                                                                                                                                  escape(
+                                                                                                                                                      self.dataset.type),
                                                                                                                                                   the_operator,
-                                                                                                                                                  escape(str(self.mb_buffer)),
-                                                                                                                                                  escape(self.dataset.type),
+                                                                                                                                                  escape(
+                                                                                                                                                      str(self.mb_buffer)),
+                                                                                                                                                  escape(
+                                                                                                                                                      self.dataset.type),
                                                                                                                                                   chromosome)
             else:
-                location_clause = "(ABS(%s.Mb-Geno.Mb) %s %s and %s.Chr = Geno.Chr) or (%s.Chr != Geno.Chr)" % (escape(self.dataset.type), the_operator, escape(str(self.mb_buffer)), escape(self.dataset.type), escape(self.dataset.type))
+                location_clause = "(ABS(%s.Mb-Geno.Mb) %s %s and %s.Chr = Geno.Chr) or (%s.Chr != Geno.Chr)" % (escape(
+                    self.dataset.type), the_operator, escape(str(self.mb_buffer)), escape(self.dataset.type), escape(self.dataset.type))
             where_clause = sub_clause + """
                     %sXRef.Locus = Geno.name and
                     Geno.SpeciesId = %s and
@@ -683,7 +700,8 @@ class CisLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(self.from_clause, self.where_clause)
+        self.query = self.compile_final_query(
+            self.from_clause, self.where_clause)
 
         return self.execute(self.query)
 
@@ -714,7 +732,8 @@ class TransLrsSearch(CisTransLrsSearch, MrnaAssaySearch):
         self.from_clause = self.get_from_clause()
         self.where_clause = self.get_where_clause()
 
-        self.query = self.compile_final_query(self.from_clause, self.where_clause)
+        self.query = self.compile_final_query(
+            self.from_clause, self.where_clause)
 
         return self.execute(self.query)
 
@@ -733,7 +752,8 @@ class MeanSearch(MrnaAssaySearch):
 
             where_clause = """ %sXRef.mean > %s and
                              %sXRef.mean < %s """ % self.mescape(self.dataset.type,
-                                                                min(self.mean_min, self.mean_max),
+                                                                min(self.mean_min,
+                                                                    self.mean_max),
                                                                 self.dataset.type,
                                                                 max(self.mean_min, self.mean_max))
         else:
@@ -796,7 +816,8 @@ class PositionSearch(DoSearch):
         DoSearch.search_types[search_key] = "PositionSearch"
 
     def get_where_clause(self):
-        self.search_term = [float(value) if is_number(value) else value for value in self.search_term]
+        self.search_term = [float(value) if is_number(
+            value) else value for value in self.search_term]
         chr, self.mb_min, self.mb_max = self.search_term[:3]
         self.chr = str(chr).lower()
         self.get_chr()
@@ -806,7 +827,8 @@ class PositionSearch(DoSearch):
                                 %s.Mb < %s """ % self.mescape(self.dataset.type,
                                                               self.chr,
                                                               self.dataset.type,
-                                                              min(self.mb_min, self.mb_max),
+                                                              min(self.mb_min,
+                                                                  self.mb_max),
                                                               self.dataset.type,
                                                               max(self.mb_min, self.mb_max))
 
@@ -923,7 +945,8 @@ def get_aliases(symbol, species):
         return []
 
     filtered_aliases = []
-    response = requests.get(GN2_BASE_URL + "/gn3/gene/aliases/" + symbol_string)
+    response = requests.get(
+        GN2_BASE_URL + "/gn3/gene/aliases/" + symbol_string)
     if response:
         alias_list = json.loads(response.content)
 
diff --git a/wqflask/wqflask/docs.py b/wqflask/wqflask/docs.py
index 81424b9c..fc93248a 100644
--- a/wqflask/wqflask/docs.py
+++ b/wqflask/wqflask/docs.py
@@ -35,11 +35,13 @@ class Docs:
 
 def update_text(start_vars):
     content = start_vars['ckcontent']
-    content = content.replace('%', '%%').replace('"', '\\"').replace("'", "\\'")
+    content = content.replace('%', '%%').replace(
+        '"', '\\"').replace("'", "\\'")
 
     try:
         if g.user_session.record['user_email_address'] == "zachary.a.sloan@gmail.com" or g.user_session.record['user_email_address'] == "labwilliams@gmail.com":
-            sql = "UPDATE Docs SET content='{0}' WHERE entry='{1}';".format(content, start_vars['entry_type'])
+            sql = "UPDATE Docs SET content='{0}' WHERE entry='{1}';".format(
+                content, start_vars['entry_type'])
             g.db.execute(sql)
     except:
         pass
diff --git a/wqflask/wqflask/export_traits.py b/wqflask/wqflask/export_traits.py
index d0745ef7..5bd54f9d 100644
--- a/wqflask/wqflask/export_traits.py
+++ b/wqflask/wqflask/export_traits.py
@@ -35,9 +35,12 @@ def export_search_results_csv(targs):
             metadata.append(["Data Set: " + targs['database_name']])
     if 'accession_id' in targs:
         if targs['accession_id'] != "None":
-            metadata.append(["Metadata Link: http://genenetwork.org/webqtl/main.py?FormID=sharinginfo&GN_AccessionId=" + targs['accession_id']])
-    metadata.append(["Export Date: " + datetime.datetime.now().strftime("%B %d, %Y")])
-    metadata.append(["Export Time: " + datetime.datetime.now().strftime("%H:%M GMT")])
+            metadata.append(
+                ["Metadata Link: http://genenetwork.org/webqtl/main.py?FormID=sharinginfo&GN_AccessionId=" + targs['accession_id']])
+    metadata.append(
+        ["Export Date: " + datetime.datetime.now().strftime("%B %d, %Y")])
+    metadata.append(
+        ["Export Time: " + datetime.datetime.now().strftime("%H:%M GMT")])
     if 'search_string' in targs:
         if targs['search_string'] != "None":
             metadata.append(["Search Query: " + targs['search_string']])
@@ -52,10 +55,12 @@ def export_search_results_csv(targs):
     for trait in table_rows:
         trait_name, dataset_name, _hash = trait.split(":")
         trait_ob = create_trait(name=trait_name, dataset_name=dataset_name)
-        trait_ob = retrieve_trait_info(trait_ob, trait_ob.dataset, get_qtl_info=True)
+        trait_ob = retrieve_trait_info(
+            trait_ob, trait_ob.dataset, get_qtl_info=True)
         trait_list.append(trait_ob)
 
-    table_headers = ['Index', 'URL', 'Species', 'Group', 'Dataset', 'Record ID', 'Symbol', 'Description', 'ProbeTarget', 'PubMed_ID', 'Chr', 'Mb', 'Alias', 'Gene_ID', 'Homologene_ID', 'UniGene_ID', 'Strand_Probe', 'Probe_set_specificity', 'Probe_set_BLAT_score', 'Probe_set_BLAT_Mb_start', 'Probe_set_BLAT_Mb_end', 'QTL_Chr', 'QTL_Mb', 'Locus_at_Peak', 'Max_LRS', 'P_value_of_MAX', 'Mean_Expression']
+    table_headers = ['Index', 'URL', 'Species', 'Group', 'Dataset', 'Record ID', 'Symbol', 'Description', 'ProbeTarget', 'PubMed_ID', 'Chr', 'Mb', 'Alias', 'Gene_ID', 'Homologene_ID', 'UniGene_ID',
+        'Strand_Probe', 'Probe_set_specificity', 'Probe_set_BLAT_score', 'Probe_set_BLAT_Mb_start', 'Probe_set_BLAT_Mb_end', 'QTL_Chr', 'QTL_Mb', 'Locus_at_Peak', 'Max_LRS', 'P_value_of_MAX', 'Mean_Expression']
 
     traits_by_group = sort_traits_by_group(trait_list)
 
@@ -87,7 +92,8 @@ def export_search_results_csv(targs):
                 trait_symbol = "N/A"
             row_contents = [
                 i + 1,
-                "https://genenetwork.org/show_trait?trait_id=" + str(trait.name) + "&dataset=" + str(trait.dataset.name),
+                "https://genenetwork.org/show_trait?trait_id=" + \
+                    str(trait.name) + "&dataset=" + str(trait.dataset.name),
                 trait.dataset.group.species,
                 trait.dataset.group.name,
                 trait.dataset.name,
@@ -117,13 +123,15 @@ def export_search_results_csv(targs):
 
             for sample in trait.dataset.group.samplelist:
                 if sample in trait.data:
-                    row_contents += [trait.data[sample].value, trait.data[sample].variance]
+                    row_contents += [trait.data[sample].value,
+                        trait.data[sample].variance]
                 else:
                     row_contents += ["x", "x"]
 
             csv_rows.append(row_contents)
 
-        csv_rows = list(map(list, itertools.zip_longest(*[row for row in csv_rows])))
+        csv_rows = list(
+            map(list, itertools.zip_longest(*[row for row in csv_rows])))
         writer.writerows(csv_rows)
         csv_data = buff.getvalue()
         buff.close()
diff --git a/wqflask/wqflask/external_tools/send_to_bnw.py b/wqflask/wqflask/external_tools/send_to_bnw.py
index 1556c6a0..3c0f2ca7 100644
--- a/wqflask/wqflask/external_tools/send_to_bnw.py
+++ b/wqflask/wqflask/external_tools/send_to_bnw.py
@@ -27,7 +27,8 @@ logger = utility.logger.getLogger(__name__)
 
 class SendToBNW:
     def __init__(self, start_vars):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         trait_samples_list = []
@@ -39,7 +40,8 @@ class SendToBNW:
             trait1_samples = list(this_sample_data.keys())
             trait_samples_list.append(trait1_samples)
 
-        shared_samples = list(set(trait_samples_list[0]).intersection(*trait_samples_list))
+        shared_samples = list(
+            set(trait_samples_list[0]).intersection(*trait_samples_list))
 
         self.form_value = ""  # ZS: string that is passed to BNW through form
         values_list = []
diff --git a/wqflask/wqflask/external_tools/send_to_geneweaver.py b/wqflask/wqflask/external_tools/send_to_geneweaver.py
index c55c43e6..8af9bee9 100644
--- a/wqflask/wqflask/external_tools/send_to_geneweaver.py
+++ b/wqflask/wqflask/external_tools/send_to_geneweaver.py
@@ -32,7 +32,8 @@ logger = utility.logger.getLogger(__name__)
 
 class SendToGeneWeaver:
     def __init__(self, start_vars):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.chip_name = test_chip(self.trait_list)
diff --git a/wqflask/wqflask/external_tools/send_to_webgestalt.py b/wqflask/wqflask/external_tools/send_to_webgestalt.py
index 6b78725c..fd12562f 100644
--- a/wqflask/wqflask/external_tools/send_to_webgestalt.py
+++ b/wqflask/wqflask/external_tools/send_to_webgestalt.py
@@ -32,7 +32,8 @@ logger = utility.logger.getLogger(__name__)
 
 class SendToWebGestalt:
     def __init__(self, start_vars):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.chip_name = test_chip(self.trait_list)
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index 69ce3e7a..55a7da0e 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -77,8 +77,10 @@ def remove_users():
    admin_ids_to_remove = request.form['selected_admin_ids']
    member_ids_to_remove = request.form['selected_member_ids']
 
-   remove_users_from_group(g.user_session.user_id, admin_ids_to_remove.split(":"), group_id, user_type="admins")
-   remove_users_from_group(g.user_session.user_id, member_ids_to_remove.split(":"), group_id, user_type="members")
+   remove_users_from_group(g.user_session.user_id, admin_ids_to_remove.split(
+      ":"), group_id, user_type="admins")
+   remove_users_from_group(g.user_session.user_id, member_ids_to_remove.split(
+      ":"), group_id, user_type="members")
 
    return redirect(url_for('view_group', id=group_id))
 
@@ -88,10 +90,12 @@ def add_users(user_type='members'):
    group_id = request.form['group_id']
    if user_type == "admins":
       user_emails = request.form['admin_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins=True)
+      add_users_to_group(g.user_session.user_id, group_id,
+                         user_emails, admins=True)
    elif user_type == "members":
       user_emails = request.form['member_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id, user_emails, admins=False)
+      add_users_to_group(g.user_session.user_id, group_id,
+                         user_emails, admins=False)
 
    return redirect(url_for('view_group', id=group_id))
 
@@ -111,7 +115,8 @@ def add_or_edit_group():
    if "group_name" in params:
       member_user_ids = set()
       admin_user_ids = set()
-      admin_user_ids.add(g.user_session.user_id)  # ZS: Always add the user creating the group as an admin
+      # ZS: Always add the user creating the group as an admin
+      admin_user_ids.add(g.user_session.user_id)
       if "admin_emails_to_add" in params:
          admin_emails = params['admin_emails_to_add'].split(",")
          for email in admin_emails:
@@ -127,7 +132,8 @@ def add_or_edit_group():
                member_user_ids.add(user_details['user_id'])
          #send_group_invites(params['group_id'], user_email_list = user_emails, user_type="members")
 
-      create_group(list(admin_user_ids), list(member_user_ids), params['group_name'])
+      create_group(list(admin_user_ids), list(
+         member_user_ids), params['group_name'])
       return redirect(url_for('manage_groups'))
    else:
       return render_template("admin/create_group.html")
@@ -149,9 +155,11 @@ def send_group_invites(group_id, user_email_list=[], user_type="members"):
                ((user_type == "members") and (user_details['user_id'] in group_info['members'])):
                continue
             else:
-               send_verification_email(user_details, template_name="email/group_verification.txt", key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
+               send_verification_email(user_details, template_name="email/group_verification.txt",
+                                       key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
       else:
-         temp_password = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+         temp_password = ''.join(random.choice(
+            string.ascii_uppercase + string.digits) for _ in range(6))
          user_details = {
             'user_id': str(uuid.uuid4()),
             'email_address': user_email,
diff --git a/wqflask/wqflask/gsearch.py b/wqflask/wqflask/gsearch.py
index a21dae84..9548d130 100644
--- a/wqflask/wqflask/gsearch.py
+++ b/wqflask/wqflask/gsearch.py
@@ -77,18 +77,21 @@ class GSearch:
                     this_trait['name'] = line[5]
                     this_trait['dataset'] = line[3]
                     this_trait['dataset_fullname'] = line[4]
-                    this_trait['hmac'] = hmac.data_hmac('{}:{}'.format(line[5], line[3]))
+                    this_trait['hmac'] = hmac.data_hmac(
+                        '{}:{}'.format(line[5], line[3]))
                     this_trait['species'] = line[0]
                     this_trait['group'] = line[1]
                     this_trait['tissue'] = line[2]
                     this_trait['symbol'] = line[6]
                     if line[7]:
-                        this_trait['description'] = line[7].decode('utf-8', 'replace')
+                        this_trait['description'] = line[7].decode(
+                            'utf-8', 'replace')
                     else:
                         this_trait['description'] = "N/A"
                     this_trait['location_repr'] = 'N/A'
                     if (line[8] != "NULL" and line[8] != "") and (line[9] != 0):
-                        this_trait['location_repr'] = 'Chr%s: %.6f' % (line[8], float(line[9]))
+                        this_trait['location_repr'] = 'Chr%s: %.6f' % (
+                            line[8], float(line[9]))
                     try:
                         this_trait['mean'] = '%.3f' % line[10]
                     except:
@@ -103,7 +106,8 @@ class GSearch:
                     this_trait['locus_chr'] = line[16]
                     this_trait['locus_mb'] = line[17]
 
-                    dataset_ob = SimpleNamespace(id=this_trait["dataset_id"], type="ProbeSet", species=this_trait["species"])
+                    dataset_ob = SimpleNamespace(
+                        id=this_trait["dataset_id"], type="ProbeSet", species=this_trait["species"])
                     if dataset_ob.id not in dataset_to_permissions:
                         permissions = check_resource_availability(dataset_ob)
                         dataset_to_permissions[dataset_ob.id] = permissions
@@ -118,7 +122,9 @@ class GSearch:
 
                     max_lrs_text = "N/A"
                     if this_trait['locus_chr'] != None and this_trait['locus_mb'] != None:
-                        max_lrs_text = "Chr" + str(this_trait['locus_chr']) + ": " + str(this_trait['locus_mb'])
+                        max_lrs_text = "Chr" + \
+                            str(this_trait['locus_chr']) + \
+                                ": " + str(this_trait['locus_mb'])
                     this_trait['max_lrs_text'] = max_lrs_text
 
                     trait_list.append(this_trait)
@@ -146,7 +152,8 @@ class GSearch:
             if "_" in self.terms:
                 if len(self.terms.split("_")[0]) == 3:
                     search_term = self.terms.split("_")[1]
-                    group_clause = "AND InbredSet.`InbredSetCode` = '{}'".format(self.terms.split("_")[0])
+                    group_clause = "AND InbredSet.`InbredSetCode` = '{}'".format(
+                        self.terms.split("_")[0])
             sql = """
                 SELECT
                 Species.`Name`,
@@ -192,18 +199,22 @@ class GSearch:
                     this_trait['index'] = i + 1
                     this_trait['name'] = str(line[4])
                     if len(str(line[12])) == 3:
-                        this_trait['display_name'] = str(line[12]) + "_" + this_trait['name']
+                        this_trait['display_name'] = str(
+                            line[12]) + "_" + this_trait['name']
                     else:
                         this_trait['display_name'] = this_trait['name']
                     this_trait['dataset'] = line[2]
                     this_trait['dataset_fullname'] = line[3]
-                    this_trait['hmac'] = hmac.data_hmac('{}:{}'.format(line[4], line[2]))
+                    this_trait['hmac'] = hmac.data_hmac(
+                        '{}:{}'.format(line[4], line[2]))
                     this_trait['species'] = line[0]
                     this_trait['group'] = line[1]
                     if line[9] != None and line[6] != None:
-                        this_trait['description'] = line[6].decode('utf-8', 'replace')
+                        this_trait['description'] = line[6].decode(
+                            'utf-8', 'replace')
                     elif line[5] != None:
-                        this_trait['description'] = line[5].decode('utf-8', 'replace')
+                        this_trait['description'] = line[5].decode(
+                            'utf-8', 'replace')
                     else:
                         this_trait['description'] = "N/A"
                     if line[13] != None and line[13] != "":
@@ -221,7 +232,8 @@ class GSearch:
                     else:
                         this_trait['pubmed_link'] = "N/A"
                         if line[12]:
-                            this_trait['display_name'] = line[12] + "_" + str(this_trait['name'])
+                            this_trait['display_name'] = line[12] + \
+                                "_" + str(this_trait['name'])
                     this_trait['LRS_score_repr'] = "N/A"
                     if line[10] != "" and line[10] != None:
                         this_trait['LRS_score_repr'] = '%3.1f' % line[10]
@@ -230,13 +242,16 @@ class GSearch:
                         this_trait['additive'] = '%.3f' % line[11]
 
                     this_trait['max_lrs_text'] = "N/A"
-                    trait_ob = create_trait(dataset_name=this_trait['dataset'], name=this_trait['name'], get_qtl_info=True, get_sample_info=False)
+                    trait_ob = create_trait(
+                        dataset_name=this_trait['dataset'], name=this_trait['name'], get_qtl_info=True, get_sample_info=False)
                     if not trait_ob:
                         continue
                     if this_trait['dataset'] == this_trait['group'] + "Publish":
                       try:
                         if trait_ob.locus_chr != "" and trait_ob.locus_mb != "":
-                            this_trait['max_lrs_text'] = "Chr" + str(trait_ob.locus_chr) + ": " + str(trait_ob.locus_mb)
+                            this_trait['max_lrs_text'] = "Chr" + \
+                                str(trait_ob.locus_chr) + \
+                                    ": " + str(trait_ob.locus_mb)
                       except:
                           this_trait['max_lrs_text'] = "N/A"
 
diff --git a/wqflask/wqflask/heatmap/heatmap.py b/wqflask/wqflask/heatmap/heatmap.py
index 0b477446..aa11caa8 100644
--- a/wqflask/wqflask/heatmap/heatmap.py
+++ b/wqflask/wqflask/heatmap/heatmap.py
@@ -18,7 +18,8 @@ logger = getLogger(__name__)
 class Heatmap:
 
     def __init__(self, start_vars, temp_uuid):
-        trait_db_list = [trait.strip() for trait in start_vars['trait_list'].split(',')]
+        trait_db_list = [trait.strip()
+                                     for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.temp_uuid = temp_uuid
@@ -33,7 +34,8 @@ class Heatmap:
         chrnames = []
         self.species = species.TheSpecies(dataset=self.trait_list[0][1])
         for key in list(self.species.chromosomes.chromosomes.keys()):
-            chrnames.append([self.species.chromosomes.chromosomes[key].name, self.species.chromosomes.chromosomes[key].mb_length])
+            chrnames.append([self.species.chromosomes.chromosomes[key].name,
+                            self.species.chromosomes.chromosomes[key].mb_length])
 
         for trait_db in self.trait_list:
 
@@ -108,10 +110,13 @@ class Heatmap:
                     trimmed_samples.append(str(samples[i]))
                     trimmed_values.append(values[i])
 
-            trait_filename = str(this_trait.name) + "_" + str(self.dataset.name) + "_pheno"
+            trait_filename = str(this_trait.name) + "_" + \
+                                 str(self.dataset.name) + "_pheno"
             gen_pheno_txt_file(trimmed_samples, trimmed_values, trait_filename)
 
-            output_filename = self.dataset.group.name + "_GWA_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+            output_filename = self.dataset.group.name + "_GWA_" + \
+                ''.join(random.choice(string.ascii_uppercase + string.digits)
+                        for _ in range(6))
 
             reaper_command = REAPER_COMMAND + ' --geno {0}/{1}.geno --traits {2}/gn2/{3}.txt -n 1000 -o {4}{5}.txt'.format(flat_files('genotype'),
                                                                                                                     genofile_name,
@@ -129,9 +134,11 @@ class Heatmap:
             self.trait_results[this_trait.name] = []
             for qtl in reaper_results:
                 if qtl['additive'] > 0:
-                    self.trait_results[this_trait.name].append(-float(qtl['lrs_value']))
+                    self.trait_results[this_trait.name].append(
+                        -float(qtl['lrs_value']))
                 else:
-                    self.trait_results[this_trait.name].append(float(qtl['lrs_value']))
+                    self.trait_results[this_trait.name].append(
+                        float(qtl['lrs_value']))
 
 
 def gen_pheno_txt_file(samples, vals, filename):
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index 8dd1c7c0..cadff080 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -54,7 +54,8 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                               Mb >= %2.6f AND Mb < %2.6f AND
                                               StrainId1 = %d AND StrainId2 = %d
                                         """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
-				newdict["snpDensity"] = newdict["snpCount"] / (newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
+				newdict["snpDensity"] = newdict["snpCount"] / \
+					(newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
 			else:
 				newdict["snpDensity"] = newdict["snpCount"] = 0
 			
@@ -86,12 +87,14 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                                           StrainId1 = %d AND StrainId2 = %d
                                                     """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
 
-						newdict2["snpDensity"] = newdict2["snpCount"] / (newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
+						newdict2["snpDensity"] = newdict2["snpCount"] / \
+							(newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
 					else:
 						newdict2["snpDensity"] = newdict2["snpCount"] = 0
 						
 					try:
-						newdict2['GeneLength'] = 1000.0 * (newdict2['TxEnd'] - newdict2['TxStart'])
+						newdict2['GeneLength'] = 1000.0 * \
+							(newdict2['TxEnd'] - newdict2['TxStart'])
 					except:
 						pass
 						
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index 5c7b81dd..cde822e8 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -307,7 +307,8 @@ class DisplayMappingResults:
             if 'color_scheme' in start_vars:
                 self.color_scheme = start_vars['color_scheme']
                 if self.color_scheme == "single":
-                    self.manhattan_single_color = ImageColor.getrgb("#" + start_vars['manhattan_single_color'])
+                    self.manhattan_single_color = ImageColor.getrgb(
+                        "#" + start_vars['manhattan_single_color'])
 
         if 'permCheck' in list(start_vars.keys()):
             self.permChecked = start_vars['permCheck']
@@ -357,7 +358,8 @@ class DisplayMappingResults:
         if 'reaper_version' in list(start_vars.keys()) and self.mapping_method == "reaper":
             self.reaper_version = start_vars['reaper_version']
             if 'output_files' in start_vars:
-                self.output_files = ",".join([(the_file if the_file is not None else "") for the_file in start_vars['output_files']])
+                self.output_files = ",".join(
+                    [(the_file if the_file is not None else "") for the_file in start_vars['output_files']])
 
         self.categorical_vars = ""
         self.perm_strata = ""
@@ -386,16 +388,19 @@ class DisplayMappingResults:
 
         self.dataset.group.genofile = self.genofile_string.split(":")[0]
         if self.mapping_method == "reaper" and self.manhattan_plot != True:
-            self.genotype = self.dataset.group.read_genotype_file(use_reaper=True)
+            self.genotype = self.dataset.group.read_genotype_file(
+                use_reaper=True)
         else:
             self.genotype = self.dataset.group.read_genotype_file()
 
         # Darwing Options
         try:
            if self.selectedChr > -1:
-               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
+                   self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
            else:
-               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
+                   self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
         except:
            if self.selectedChr > -1:
                self.graphWidth = self.GRAPH_DEFAULT_WIDTH
@@ -472,9 +477,11 @@ class DisplayMappingResults:
                 """ % (self.dataset.group.name, ", ".join(["'%s'" % X[0] for X in self.ChrList[1:]])))
 
         self.ChrLengthMbList = [x[0] / 1000000.0 for x in self.ChrLengthMbList]
-        self.ChrLengthMbSum = reduce(lambda x, y: x + y, self.ChrLengthMbList, 0.0)
+        self.ChrLengthMbSum = reduce(
+            lambda x, y: x + y, self.ChrLengthMbList, 0.0)
         if self.ChrLengthMbList:
-            self.MbGraphInterval = self.ChrLengthMbSum / (len(self.ChrLengthMbList) * 12)  # Empirical Mb interval
+            self.MbGraphInterval = self.ChrLengthMbSum / \
+                (len(self.ChrLengthMbList) * 12)  # Empirical Mb interval
         else:
             self.MbGraphInterval = 1
 
@@ -482,7 +489,8 @@ class DisplayMappingResults:
         for i, _chr in enumerate(self.genotype):
             self.ChrLengthCMList.append(_chr[-1].cM - _chr[0].cM)
 
-        self.ChrLengthCMSum = reduce(lambda x, y: x + y, self.ChrLengthCMList, 0.0)
+        self.ChrLengthCMSum = reduce(
+            lambda x, y: x + y, self.ChrLengthCMList, 0.0)
 
         if self.plotScale == 'physic':
             self.GraphInterval = self.MbGraphInterval  # Mb
@@ -496,7 +504,8 @@ class DisplayMappingResults:
             smd = []
             for sample in self.sample_vals_dict.keys():
                 if self.sample_vals_dict[sample] != "x":
-                    temp = GeneralObject(name=sample, value=float(self.sample_vals_dict[sample]))
+                    temp = GeneralObject(name=sample, value=float(
+                        self.sample_vals_dict[sample]))
                     smd.append(temp)
                 else:
                     continue
@@ -506,7 +515,8 @@ class DisplayMappingResults:
                     if item.name == samplelist[j]:
                         self.NR_INDIVIDUALS = self.NR_INDIVIDUALS + 1
 # default:
-            self.graphHeight = self.graphHeight + 2 * (self.NR_INDIVIDUALS + 10) * self.EACH_GENE_HEIGHT
+            self.graphHeight = self.graphHeight + 2 * \
+                (self.NR_INDIVIDUALS + 10) * self.EACH_GENE_HEIGHT
 # END HaplotypeAnalyst
 
         #########################
@@ -529,7 +539,8 @@ class DisplayMappingResults:
             self.diffCol = []
 
         for i, strain in enumerate(self.diffCol):
-            self.diffCol[i] = g.db.execute("select Id from Strain where Symbol = %s", strain).fetchone()[0]
+            self.diffCol[i] = g.db.execute(
+                "select Id from Strain where Symbol = %s", strain).fetchone()[0]
 
         ################################################################
         # GeneCollection goes here
@@ -552,13 +563,15 @@ class DisplayMappingResults:
                     chrName = "X"
                 else:
                     chrName = self.selectedChr
-                self.geneCol = GeneUtil.loadGenes(chrName, self.diffCol, self.startMb, self.endMb, "mouse")
+                self.geneCol = GeneUtil.loadGenes(
+                    chrName, self.diffCol, self.startMb, self.endMb, "mouse")
             elif self.dataset.group.species == "rat":
                 if self.selectedChr == 21:
                     chrName = "X"
                 else:
                     chrName = self.selectedChr
-                self.geneCol = GeneUtil.loadGenes(chrName, self.diffCol, self.startMb, self.endMb, "rat")
+                self.geneCol = GeneUtil.loadGenes(
+                    chrName, self.diffCol, self.startMb, self.endMb, "rat")
 
             if self.geneCol and self.intervalAnalystChecked:
                #######################################################################
@@ -577,7 +590,8 @@ class DisplayMappingResults:
         showLocusForm = ""
         intCanvas = Image.new("RGBA", size=(self.graphWidth, self.graphHeight))
         with Bench("Drawing Plot"):
-            gifmap = self.plotIntMapping(intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm)
+            gifmap = self.plotIntMapping(
+                intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm)
 
         self.gifmap = gifmap.__str__()
 
@@ -593,8 +607,10 @@ class DisplayMappingResults:
 
         # Scales plot differently for high resolution
         if self.draw2X:
-            intCanvasX2 = Image.new("RGBA", size=(self.graphWidth * 2, self.graphHeight * 2))
-            gifmapX2 = self.plotIntMapping(intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm, zoom=2)
+            intCanvasX2 = Image.new("RGBA", size=(
+                self.graphWidth * 2, self.graphHeight * 2))
+            gifmapX2 = self.plotIntMapping(
+                intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm, zoom=2)
             intCanvasX2.save(
                 "{}.png".format(
                     os.path.join(webqtlConfig.GENERATED_IMAGE_DIR,
@@ -612,7 +628,8 @@ class DisplayMappingResults:
                 name=showLocusForm,
                 submit=HtmlGenWrapper.create_input_tag(type_='hidden'))
 
-            hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet+"Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
+            hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet+ \
+                "Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
             for key in hddn.keys():
                 showLocusForm.append(HtmlGenWrapper.create_input_tag(
                     name=key, value=hddn[key], type_='hidden'))
@@ -631,7 +648,8 @@ class DisplayMappingResults:
 
         if self.traitList and self.traitList[0].dataset and self.traitList[0].dataset.type == 'Geno':
             btminfo.append(HtmlGenWrapper.create_br_tag())
-            btminfo.append('Mapping using genotype data as a trait will result in infinity LRS at one locus. In order to display the result properly, all LRSs higher than 100 are capped at 100.')
+            btminfo.append(
+                'Mapping using genotype data as a trait will result in infinity LRS at one locus. In order to display the result properly, all LRSs higher than 100 are capped at 100.')
 
     def plotIntMapping(self, canvas, offset=(80, 120, 90, 100), zoom=1, startMb= None, endMb = None, showLocusForm = ""):
         im_drawer = ImageDraw.Draw(canvas)
@@ -673,7 +691,8 @@ class DisplayMappingResults:
             else:
                 drawAreaHeight -= 3 * self.BAND_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
             if self.geneChecked:
-                drawAreaHeight -= self.NUM_GENE_ROWS * self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
+                drawAreaHeight -= self.NUM_GENE_ROWS * \
+                    self.EACH_GENE_HEIGHT + 3 * self.BAND_SPACING + 10 * zoom
         else:
             if self.selectedChr > -1:
                 drawAreaHeight -= 20
@@ -682,7 +701,8 @@ class DisplayMappingResults:
 
 # BEGIN HaplotypeAnalyst
         if self.haplotypeAnalystChecked and self.selectedChr > -1:
-            drawAreaHeight -= self.EACH_GENE_HEIGHT * (self.NR_INDIVIDUALS + 10) * 2 * zoom
+            drawAreaHeight -= self.EACH_GENE_HEIGHT * \
+                (self.NR_INDIVIDUALS + 10) * 2 * zoom
 # END HaplotypeAnalyst
 
         if zoom == 2:
@@ -693,38 +713,48 @@ class DisplayMappingResults:
 
         newoffset = (xLeftOffset, xRightOffset, yTopOffset, yBottomOffset)
         # Draw the alternating-color background first and get plotXScale
-        plotXScale = self.drawGraphBackground(canvas, gifmap, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+        plotXScale = self.drawGraphBackground(
+            canvas, gifmap, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
         # draw bootstap
         if self.bootChecked and not self.multipleInterval:
-            self.drawBootStrapResult(canvas, self.nboot, drawAreaHeight, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+            self.drawBootStrapResult(canvas, self.nboot, drawAreaHeight, plotXScale,
+                                     offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
         # Draw clickable region and gene band if selected
         if self.plotScale == 'physic' and self.selectedChr > -1:
-            self.drawClickBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+            self.drawClickBand(canvas, gifmap, plotXScale, offset=newoffset,
+                               zoom=zoom, startMb=startMb, endMb=endMb)
             if self.geneChecked and self.geneCol:
-                self.drawGeneBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+                self.drawGeneBand(canvas, gifmap, plotXScale, offset=newoffset,
+                                  zoom=zoom, startMb=startMb, endMb=endMb)
             if self.SNPChecked:
-                self.drawSNPTrackNew(canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb = endMb)
+                self.drawSNPTrackNew(
+                    canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb = endMb)
 # BEGIN HaplotypeAnalyst
             if self.haplotypeAnalystChecked:
-                self.drawHaplotypeBand(canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+                self.drawHaplotypeBand(
+                    canvas, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 # END HaplotypeAnalyst
         # Draw X axis
-        self.drawXAxis(canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+        self.drawXAxis(canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm,
+                       offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
         # Draw QTL curve
-        self.drawQTL(canvas, drawAreaHeight, gifmap, plotXScale, offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
+        self.drawQTL(canvas, drawAreaHeight, gifmap, plotXScale,
+                     offset=newoffset, zoom=zoom, startMb=startMb, endMb=endMb)
 
         # draw legend
         if self.multipleInterval:
-            self.drawMultiTraitName(fd, canvas, gifmap, showLocusForm, offset=newoffset)
+            self.drawMultiTraitName(
+                fd, canvas, gifmap, showLocusForm, offset=newoffset)
         elif self.legendChecked:
             self.drawLegendPanel(canvas, offset=newoffset, zoom=zoom)
         else:
             pass
 
         # draw position, no need to use a separate function
-        self.drawProbeSetPosition(canvas, plotXScale, offset=newoffset, zoom=zoom)
+        self.drawProbeSetPosition(
+            canvas, plotXScale, offset=newoffset, zoom=zoom)
 
         return gifmap
 
@@ -756,19 +786,24 @@ class DisplayMappingResults:
                     if previous_chr_as_int != 1:
                         BootCoord.append(BootChrCoord)
                         BootChrCoord = []
-                        startX += (self.ChrLengthDistList[previous_chr_as_int - 2] + self.GraphInterval) * plotXScale
+                        startX += (
+                            self.ChrLengthDistList[previous_chr_as_int - 2] + self.GraphInterval) * plotXScale
                 if self.plotScale == 'physic':
                     Xc = startX + (result['Mb'] - self.startMb) * plotXScale
                 else:
-                    Xc = startX + (result['cM'] - self.qtlresults[0]['cM']) * plotXScale
+                    Xc = startX + \
+                        (result['cM'] - self.qtlresults[0]['cM']) * plotXScale
                 BootChrCoord.append([Xc, self.bootResult[i]])
         else:
             for i, result in enumerate(self.qtlresults):
                 if str(result['chr']) == str(self.ChrList[self.selectedChr][0]):
                     if self.plotScale == 'physic':
-                        Xc = startX + (result['Mb'] - self.startMb) * plotXScale
+                        Xc = startX + (result['Mb'] - \
+                                       self.startMb) * plotXScale
                     else:
-                        Xc = startX + (result['cM'] - self.qtlresults[0]['cM']) * plotXScale
+                        Xc = startX + \
+                            (result['cM'] - self.qtlresults[0]
+                             ['cM']) * plotXScale
                     BootChrCoord.append([Xc, self.bootResult[i]])
             BootCoord = [BootChrCoord]
 
@@ -793,14 +828,16 @@ class DisplayMappingResults:
                     if maxBootCount < bootCount:
                         maxBootCount = bootCount
                     # end if
-                    reducedBootCoord.append([bootStartPixX, BootChrCoord[i][0], bootCount])
+                    reducedBootCoord.append(
+                        [bootStartPixX, BootChrCoord[i][0], bootCount])
                     bootStartPixX = BootChrCoord[i][0]
                     bootCount = BootChrCoord[i][1]
                 # end else
             # end for
             # add last piece
             if BootChrCoord[-1][0] - bootStartPixX > stepBootStrap / 2.0:
-                reducedBootCoord.append([bootStartPixX, BootChrCoord[-1][0], bootCount])
+                reducedBootCoord.append(
+                    [bootStartPixX, BootChrCoord[-1][0], bootCount])
             else:
                 reducedBootCoord[-1][2] += bootCount
                 reducedBootCoord[-1][1] = BootChrCoord[-1][0]
@@ -827,11 +864,13 @@ class DisplayMappingResults:
         # draw boot scale
         highestPercent = (maxBootCount * 100.0) / nboot
         bootScale = Plot.detScale(0, highestPercent)
-        bootScale = Plot.frange(bootScale[0], bootScale[1], bootScale[1] / bootScale[2])
+        bootScale = Plot.frange(
+            bootScale[0], bootScale[1], bootScale[1] / bootScale[2])
         bootScale = bootScale[:-1] + [highestPercent]
 
         bootOffset = 50 * fontZoom
-        bootScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=13 * fontZoom)
+        bootScaleFont = ImageFont.truetype(
+            font=VERDANA_FILE, size=13 * fontZoom)
         im_drawer.rectangle(
             xy=((canvas.size[0] - bootOffset, yZero - bootHeightThresh),
                 (canvas.size[0] - bootOffset - 15*zoom, yZero)),
@@ -860,10 +899,12 @@ class DisplayMappingResults:
                 startPosY = 30
             else:
                 startPosY = 15
-            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
+            smallLabelFont = ImageFont.truetype(
+                font=TREBUC_FILE, size=12 * fontZoom)
             leftOffset = canvas.size[0] - xRightOffset - 190
             im_drawer.rectangle(
-                xy=((leftOffset, startPosY - 6), (leftOffset + 12, startPosY + 6)),
+                xy=((leftOffset, startPosY - 6),
+                    (leftOffset + 12, startPosY + 6)),
                 fill=YELLOW, outline=BLACK)
             im_drawer.text(xy=(canvas.size[0] - xRightOffset - 170, startPosY + TEXT_Y_DISPLACEMENT),
                            text='Frequency of the Peak LRS',
@@ -905,7 +946,8 @@ class DisplayMappingResults:
                 locPixel = xLeftOffset
                 for i, _chr in enumerate(self.ChrList[1:]):
                     if _chr[0] != Chr:
-                        locPixel += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
+                        locPixel += (self.ChrLengthDistList[i] + \
+                                     self.GraphInterval) * plotXScale
                     else:
                         locPixel += Mb * plotXScale
                         break
@@ -921,7 +963,8 @@ class DisplayMappingResults:
 
                     # the trait's position is between two traits
                     if i > 0 and self.qtlresults[i - 1]['Mb'] < Mb and qtlresult['Mb'] >= Mb:
-                        locPixel = xLeftOffset + plotXScale * (self.qtlresults[i - 1]['Mb'] + (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']) * (Mb - self.qtlresults[i - 1]['Mb']) / (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']))
+                        locPixel = xLeftOffset + plotXScale * (self.qtlresults[i - 1]['Mb'] + (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']) * (
+                            Mb - self.qtlresults[i - 1]['Mb']) / (qtlresult['Mb'] - self.qtlresults[i - 1]['Mb']))
                         break
 
                     # the trait's position is on the right of the last genotype
@@ -932,12 +975,15 @@ class DisplayMappingResults:
                 for i, _chr in enumerate(self.ChrList):
                     if i < (len(self.ChrList) - 1):
                         if _chr != Chr:
-                            locPixel += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
+                            locPixel += (self.ChrLengthDistList[i] + \
+                                         self.GraphInterval) * plotXScale
                         else:
-                            locPixel += (Mb * (_chr[-1].cM - _chr[0].cM) / self.ChrLengthCMList[i]) * plotXScale
+                            locPixel += (Mb * (_chr[-1].cM - _chr[0].cM) / \
+                                         self.ChrLengthCMList[i]) * plotXScale
                             break
         if locPixel >= 0 and self.plotScale == 'physic':
-            traitPixel = ((locPixel, yZero), (locPixel - 7, yZero + 14), (locPixel + 7, yZero + 14))
+            traitPixel = ((locPixel, yZero), (locPixel - 7,
+                          yZero + 14), (locPixel + 7, yZero + 14))
             draw_open_polygon(canvas, xy=traitPixel, outline=BLACK,
                               fill=self.TRANSCRIPT_LOCATION_COLOR)
 
@@ -979,7 +1025,8 @@ class DisplayMappingResults:
             maxCount = max(SNPCounts)
             if maxCount > 0:
                 for i in range(xLeftOffset, xLeftOffset + plotWidth):
-                    snpDensity = float(SNPCounts[i - xLeftOffset] * SNP_HEIGHT_MODIFIER / maxCount)
+                    snpDensity = float(
+                        SNPCounts[i - xLeftOffset] * SNP_HEIGHT_MODIFIER / maxCount)
                     im_drawer.line(
                         xy=((i, drawSNPLocationY + (snpDensity) * zoom),
                            (i, drawSNPLocationY - (snpDensity) * zoom)),
@@ -1015,12 +1062,16 @@ class DisplayMappingResults:
                     (rectWidth + rightShift, yPaddingTop + 10+kstep*15)),
                 fill=thisLRSColor, outline=BLACK)
             im_drawer.text(
-                text=name, xy=(rectWidth + 2 + rightShift, yPaddingTop + 10 + kstep * 15),
+                text=name, xy=(rectWidth + 2 + rightShift,
+                               yPaddingTop + 10 + kstep * 15),
                 font=colorFont, fill=BLACK)
             if thisTrait.db:
-                COORDS = "%d,%d,%d,%d" % (rectWidth + 2 + rightShift, yPaddingTop + kstep * 15, rectWidth + 2 + rightShift + nameWidth, yPaddingTop + 10 + kstep * 15,)
-                HREF = "javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm, thisTrait.db.name, thisTrait.name)
-                Areas = HtmlGenWrapper.create_area_tag(shape='rect', coords=COORDS, href=HREF)
+                COORDS = "%d,%d,%d,%d" % (rectWidth + 2 + rightShift, yPaddingTop + kstep * \
+                                          15, rectWidth + 2 + rightShift + nameWidth, yPaddingTop + 10 + kstep * 15,)
+                HREF = "javascript:showDatabase3('%s','%s','%s','');" % (
+                    showLocusForm, thisTrait.db.name, thisTrait.name)
+                Areas = HtmlGenWrapper.create_area_tag(
+                    shape='rect', coords=COORDS, href=HREF)
                 gifmap.append(Areas)  # TODO
 
     def drawLegendPanel(self, canvas, offset=(40, 120, 80, 10), zoom=1):
@@ -1042,7 +1093,8 @@ class DisplayMappingResults:
         if hasattr(self.traitList[0], 'chr') and hasattr(self.traitList[0], 'mb'):
             startPosY = 15
             nCol = 2
-            smallLabelFont = ImageFont.truetype(font=TREBUC_FILE, size=12 * fontZoom)
+            smallLabelFont = ImageFont.truetype(
+                font=TREBUC_FILE, size=12 * fontZoom)
 
             leftOffset = canvas.size[0] - xRightOffset - 190
             draw_open_polygon(
@@ -1064,7 +1116,8 @@ class DisplayMappingResults:
                 xy=((startPosX, startPosY), (startPosX + 32, startPosY)),
                 fill=self.LRS_COLOR, width=2)
             im_drawer.text(
-                text=self.LRS_LOD, xy=(startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
+                text=self.LRS_LOD, xy=(
+                    startPosX + 40, startPosY + TEXT_Y_DISPLACEMENT),
                 font=labelFont, fill=BLACK)
             startPosY += stepPosY
 
@@ -1118,10 +1171,12 @@ class DisplayMappingResults:
                 xy=((thisStartX, startPosY), (startPosX + 32, startPosY)),
                 fill=self.SIGNIFICANT_COLOR, width=self.SIGNIFICANT_WIDTH)
             im_drawer.line(
-                xy=((thisStartX, startPosY + stepPosY), (startPosX + 32, startPosY + stepPosY)),
+                xy=((thisStartX, startPosY + stepPosY),
+                    (startPosX + 32, startPosY + stepPosY)),
                 fill=self.SUGGESTIVE_COLOR, width=self.SUGGESTIVE_WIDTH)
             im_drawer.text(
-                text='Significant %s = %2.2f' % (self.LRS_LOD, self.significant),
+                text='Significant %s = %2.2f' % (
+                    self.LRS_LOD, self.significant),
                 xy=(thisStartX + 40, startPosY + TEXT_Y_DISPLACEMENT), font=labelFont, fill=BLACK)
             im_drawer.text(
                 text='Suggestive %s = %2.2f' % (self.LRS_LOD, self.suggestive),
@@ -1134,7 +1189,8 @@ class DisplayMappingResults:
         if self.dataset.type == "Publish" or self.dataset.type == "Geno":
             dataset_label = self.dataset.fullname
         else:
-            dataset_label = "%s - %s" % (self.dataset.group.name, self.dataset.fullname)
+            dataset_label = "%s - %s" % (self.dataset.group.name,
+                                         self.dataset.fullname)
 
         string1 = 'Dataset: %s' % (dataset_label)
 
@@ -1151,7 +1207,8 @@ class DisplayMappingResults:
                 string3 = 'Using GEMMA mapping method with '
             if self.covariates != "":
                 string3 += 'the cofactors below:'
-                cofactor_names = ", ".join([covar.split(":")[0] for covar in self.covariates.split(",")])
+                cofactor_names = ", ".join(
+                    [covar.split(":")[0] for covar in self.covariates.split(",")])
                 string4 = cofactor_names
             else:
                 string3 += 'no cofactors'
@@ -1159,7 +1216,8 @@ class DisplayMappingResults:
             string3 = 'Using R/qtl mapping method with '
             if self.covariates != "":
                 string3 += 'the cofactors below:'
-                cofactor_names = ", ".join([covar.split(":")[0] for covar in self.covariates.split(",")])
+                cofactor_names = ", ".join(
+                    [covar.split(":")[0] for covar in self.covariates.split(",")])
                 string4 = cofactor_names
             elif self.controlLocus and self.doControl != "false":
                 string3 += '%s as control' % self.controlLocus
@@ -1177,15 +1235,19 @@ class DisplayMappingResults:
             if self.selectedChr == -1:
                 identification = "Mapping on All Chromosomes for "
             else:
-                identification = "Mapping on Chromosome %s for " % (self.ChrList[self.selectedChr][0])
+                identification = "Mapping on Chromosome %s for " % (
+                    self.ChrList[self.selectedChr][0])
 
             if self.this_trait.symbol:
-                identification += "Trait: %s - %s" % (self.this_trait.name, self.this_trait.symbol)
+                identification += "Trait: %s - %s" % (
+                    self.this_trait.name, self.this_trait.symbol)
             elif self.dataset.type == "Publish":
                 if self.this_trait.post_publication_abbreviation:
-                    identification += "Trait: %s - %s" % (self.this_trait.name, self.this_trait.post_publication_abbreviation)
+                    identification += "Trait: %s - %s" % (
+                        self.this_trait.name, self.this_trait.post_publication_abbreviation)
                 elif self.this_trait.pre_publication_abbreviation:
-                    identification += "Trait: %s - %s" % (self.this_trait.name, self.this_trait.pre_publication_abbreviation)
+                    identification += "Trait: %s - %s" % (
+                        self.this_trait.name, self.this_trait.pre_publication_abbreviation)
                 else:
                     identification += "Trait: %s" % (self.this_trait.name)
             else:
@@ -1265,7 +1327,8 @@ class DisplayMappingResults:
                 tenPercentLength = geneLength * 0.0001
                 SNPdensity = theGO["snpCount"] / geneLength
 
-                exonStarts = list(map(float, theGO['exonStarts'].split(",")[:-1]))
+                exonStarts = list(
+                    map(float, theGO['exonStarts'].split(",")[:-1]))
                 exonEnds = list(map(float, theGO['exonEnds'].split(",")[:-1]))
                 cdsStart = theGO['cdsStart']
                 cdsEnd = theGO['cdsEnd']
@@ -1274,8 +1337,10 @@ class DisplayMappingResults:
                 strand = theGO["Strand"]
                 exonCount = theGO["exonCount"]
 
-                geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb)
-                geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  # at least one pixel
+                geneStartPix = xLeftOffset + \
+                    plotXScale * (float(txStart) - startMb)
+                geneEndPix = xLeftOffset + plotXScale * \
+                    (float(txEnd) - startMb)  # at least one pixel
 
                 if (geneEndPix < xLeftOffset):
                     return;  # this gene is not on the screen
@@ -1290,7 +1355,8 @@ class DisplayMappingResults:
                 # found earlier, needs to be recomputed as snps are added
                 # always apply colors now, even if SNP Track not checked - Zach 11/24/2010
 
-                densities = [1.0000000000000001e-05, 0.094094033555233408, 0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
+                densities = [1.0000000000000001e-05, 0.094094033555233408,
+                    0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
                 if SNPdensity < densities[0]:
                     myColor = BLACK
                 elif SNPdensity < densities[1]:
@@ -1309,7 +1375,8 @@ class DisplayMappingResults:
                 outlineColor = myColor
                 fillColor = myColor
 
-                TITLE = "Gene: %s (%s)\nFrom %2.3f to %2.3f Mb (%s)\nNum. exons: %d." % (geneSymbol, accession, float(txStart), float(txEnd), strand, exonCount)
+                TITLE = "Gene: %s (%s)\nFrom %2.3f to %2.3f Mb (%s)\nNum. exons: %d." % (
+                    geneSymbol, accession, float(txStart), float(txEnd), strand, exonCount)
                 # NL: 06-02-2011 Rob required to change this link for gene related
                 HREF = geneNCBILink % geneSymbol
 
@@ -1324,8 +1391,10 @@ class DisplayMappingResults:
                 strand = theGO["Strand"]
                 exonCount = 0
 
-                geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb)
-                geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  # at least one pixel
+                geneStartPix = xLeftOffset + \
+                    plotXScale * (float(txStart) - startMb)
+                geneEndPix = xLeftOffset + plotXScale * \
+                    (float(txEnd) - startMb)  # at least one pixel
 
                 if (geneEndPix < xLeftOffset):
                     return;  # this gene is not on the screen
@@ -1338,7 +1407,8 @@ class DisplayMappingResults:
 
                 outlineColor = DARKBLUE
                 fillColor = DARKBLUE
-                TITLE = "Gene: %s\nFrom %2.3f to %2.3f Mb (%s)" % (geneSymbol, float(txStart), float(txEnd), strand)
+                TITLE = "Gene: %s\nFrom %2.3f to %2.3f Mb (%s)" % (
+                    geneSymbol, float(txStart), float(txEnd), strand)
                 # NL: 06-02-2011 Rob required to change this link for gene related
                 HREF = geneNCBILink % geneSymbol
             else:
@@ -1347,7 +1417,8 @@ class DisplayMappingResults:
                 TITLE = "Gene: %s" % geneSymbol
 
             # Draw Genes
-            geneYLocation = yPaddingTop + (gIndex % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT * zoom
+            geneYLocation = yPaddingTop + \
+                (gIndex % self.NUM_GENE_ROWS) * self.EACH_GENE_HEIGHT * zoom
             if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
                 geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
             else:
@@ -1361,7 +1432,8 @@ class DisplayMappingResults:
                 # draw the line that runs the entire length of the gene
                 im_drawer.line(
                     xy=(
-                        (geneStartPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 * zoom),
+                        (geneStartPix, geneYLocation + \
+                         self.EACH_GENE_HEIGHT / 2 * zoom),
                         (geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 *zoom)),
                     fill=outlineColor, width=1)
 
@@ -1401,8 +1473,10 @@ class DisplayMappingResults:
 
                 # draw the blocks for the exon regions
                 for i in range(0, len(exonStarts)):
-                    exonStartPix = (exonStarts[i] - startMb) * plotXScale + xLeftOffset
-                    exonEndPix = (exonEnds[i] - startMb) * plotXScale + xLeftOffset
+                    exonStartPix = (
+                        exonStarts[i] - startMb) * plotXScale + xLeftOffset
+                    exonEndPix = (exonEnds[i] - startMb) * \
+                                  plotXScale + xLeftOffset
                     if (exonStartPix < xLeftOffset):
                         exonStartPix = xLeftOffset
                     if (exonEndPix < xLeftOffset):
@@ -1418,7 +1492,8 @@ class DisplayMappingResults:
 
                 # draw gray blocks for 3' and 5' UTR blocks
                 if cdsStart and cdsEnd:
-                    utrStartPix = (txStart - startMb) * plotXScale + xLeftOffset
+                    utrStartPix = (txStart - startMb) * \
+                                   plotXScale + xLeftOffset
                     utrEndPix = (cdsStart - startMb) * plotXScale + xLeftOffset
                     if (utrStartPix < xLeftOffset):
                         utrStartPix = xLeftOffset
@@ -1436,7 +1511,8 @@ class DisplayMappingResults:
                             labelText = "5'"
                         im_drawer.text(
                             text=labelText,
-                            xy=(utrStartPix - 9, geneYLocation + self.EACH_GENE_HEIGHT),
+                            xy=(utrStartPix - 9, geneYLocation + \
+                                self.EACH_GENE_HEIGHT),
                             font=ImageFont.truetype(font=ARIAL_FILE, size=2))
 
                     # the second UTR region
@@ -1459,7 +1535,8 @@ class DisplayMappingResults:
                             labelText = "3'"
                             im_drawer.text(
                                 text=labelText,
-                                xy=(utrEndPix + 2, geneYLocation + self.EACH_GENE_HEIGHT),
+                                xy=(utrEndPix + 2, geneYLocation + \
+                                    self.EACH_GENE_HEIGHT),
                                 font=ImageFont.truetype(font=ARIAL_FILE, size=2))
 
             # draw the genes as rectangles
@@ -1469,7 +1546,8 @@ class DisplayMappingResults:
                         (geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT * zoom))),
                     outline=outlineColor, fill=fillColor)
 
-            COORDS = "%d, %d, %d, %d" % (geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
+            COORDS = "%d, %d, %d, %d" % (
+                geneStartPix, geneYLocation, geneEndPix, (geneYLocation + self.EACH_GENE_HEIGHT))
             # NL: 06-02-2011 Rob required to display NCBI info in a new window
             gifmap.append(
                 HtmlGenWrapper.create_area_tag(
@@ -1496,7 +1574,8 @@ class DisplayMappingResults:
         smd = []
         for sample in self.sample_vals_dict.keys():
             if self.sample_vals_dict[sample] != "x" and sample in samplelist:
-                temp = GeneralObject(name=sample, value=float(self.sample_vals_dict[sample]))
+                temp = GeneralObject(name=sample, value=float(
+                    self.sample_vals_dict[sample]))
                 smd.append(temp)
             else:
                 continue
@@ -1517,8 +1596,10 @@ class DisplayMappingResults:
                     txStart = _chr[i].Mb
                     txEnd = _chr[i].Mb
 
-                    geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb) - 0
-                    geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb) - 0
+                    geneStartPix = xLeftOffset + plotXScale * \
+                        (float(txStart) - startMb) - 0
+                    geneEndPix = xLeftOffset + plotXScale * \
+                        (float(txEnd) - startMb) - 0
 
                     drawit = 1
                     if (geneStartPix < xLeftOffset):
@@ -1546,8 +1627,10 @@ class DisplayMappingResults:
                     txStart = _chr[j].Mb
                     txEnd = _chr[j].Mb
 
-                    geneStartPix = xLeftOffset + plotXScale * (float(txStart) - startMb) - 0
-                    geneEndPix = xLeftOffset + plotXScale * (float(txEnd) - startMb)  + 0
+                    geneStartPix = xLeftOffset + plotXScale * \
+                        (float(txStart) - startMb) - 0
+                    geneEndPix = xLeftOffset + plotXScale * \
+                        (float(txEnd) - startMb)  + 0
 
                     if oldgeneEndPix >= xLeftOffset:
                         drawStart = oldgeneEndPix + 4
@@ -1585,7 +1668,8 @@ class DisplayMappingResults:
 
                         # Draw Genes
 
-                        geneYLocation = yPaddingTop + self.NUM_GENE_ROWS * (self.EACH_GENE_HEIGHT) * zoom
+                        geneYLocation = yPaddingTop + self.NUM_GENE_ROWS * \
+                            (self.EACH_GENE_HEIGHT) * zoom
                         if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
                             geneYLocation += 4 * self.BAND_HEIGHT + 4 * self.BAND_SPACING
                         else:
@@ -1606,7 +1690,8 @@ class DisplayMappingResults:
                                 if (plotbxd == 1):
                                     ind = 0
                                     if samplelist[k] in [item.name for item in smd]:
-                                        ind = [item.name for item in smd].index(samplelist[k])
+                                        ind = [item.name for item in smd].index(
+                                            samplelist[k])
 
                                     maxind = max(ind, maxind)
 
@@ -1637,8 +1722,10 @@ class DisplayMappingResults:
                                                  geneYLocation + 2 *ind*self.EACH_GENE_HEIGHT + 2*self.EACH_GENE_HEIGHT*zoom)),
                                             outline=outlineColor, fill=fillColor)
 
-                                    COORDS = "%d, %d, %d, %d" % (geneStartPix, geneYLocation + ind * self.EACH_GENE_HEIGHT, geneEndPix + 1, (geneYLocation + ind * self.EACH_GENE_HEIGHT))
-                                    TITLE = "Strain: %s, marker (%s) \n Position  %2.3f Mb." % (samplelist[k], _chr[j].name, float(txStart))
+                                    COORDS = "%d, %d, %d, %d" % (
+                                        geneStartPix, geneYLocation + ind * self.EACH_GENE_HEIGHT, geneEndPix + 1, (geneYLocation + ind * self.EACH_GENE_HEIGHT))
+                                    TITLE = "Strain: %s, marker (%s) \n Position  %2.3f Mb." % (
+                                        samplelist[k], _chr[j].name, float(txStart))
                                     HREF = ''
                                     gifmap.append(
                                         HtmlGenWrapper.create_area_tag(
@@ -1683,7 +1770,8 @@ class DisplayMappingResults:
                         plotbxd = 1
 
                     if (plotbxd == 1):
-                        ind = [item.name for item in smd].index(samplelist[j]) - 1
+                        ind = [item.name for item in smd].index(
+                            samplelist[j]) - 1
                         expr = smd[ind].value
 
                         # Place where font is hardcoded
@@ -1691,13 +1779,15 @@ class DisplayMappingResults:
                             text="%s" % (samplelist[j]),
                             xy=((xLeftOffset + plotWidth + 10),
                                 geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
-                            font=ImageFont.truetype(font=VERDANA_FILE, size=12),
+                            font=ImageFont.truetype(
+                                font=VERDANA_FILE, size=12),
                             fill=BLACK)
                         im_drawer.text(
                             text="%2.2f" % (expr),
                             xy=((xLeftOffset + plotWidth + 60),
                                 geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
-                            font=ImageFont.truetype(font=VERDANA_FILE, size=12),
+                            font=ImageFont.truetype(
+                                font=VERDANA_FILE, size=12),
                             fill=BLACK)
 
 # END HaplotypeAnalyst
@@ -1719,12 +1809,16 @@ class DisplayMappingResults:
         # but it makes the HTML huge, and takes forever to render the page in the first place)
         # Draw the bands that you can click on to go to UCSC / Ensembl
         MAX_CLICKABLE_REGION_DIVISIONS = 100
-        clickableRegionLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=9)
-        pixelStep = max(5, int(float(plotWidth) / MAX_CLICKABLE_REGION_DIVISIONS))
+        clickableRegionLabelFont = ImageFont.truetype(
+            font=VERDANA_FILE, size=9)
+        pixelStep = max(
+            5, int(float(plotWidth) / MAX_CLICKABLE_REGION_DIVISIONS))
         # pixelStep: every N pixels, we make a new clickable area for the user to go to that area of the genome.
 
-        numBasesCurrentlyOnScreen = self.kONE_MILLION * abs(startMb - endMb)  # Number of bases on screen now
-        flankingWidthInBases = int (min((float(numBasesCurrentlyOnScreen) / 2.0), (5*self.kONE_MILLION)))
+        numBasesCurrentlyOnScreen = self.kONE_MILLION * \
+            abs(startMb - endMb)  # Number of bases on screen now
+        flankingWidthInBases = int (
+            min((float(numBasesCurrentlyOnScreen) / 2.0), (5*self.kONE_MILLION)))
         webqtlZoomWidth = numBasesCurrentlyOnScreen / 16.0
         # Flanking width should be such that we either zoom in to a 10 million base region, or we show the clicked region at the same scale as we are currently seeing.
 
@@ -1733,23 +1827,33 @@ class DisplayMappingResults:
 
         paddingTop = yTopOffset
         if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-            phenogenPaddingTop = paddingTop + (self.BAND_HEIGHT + self.BAND_SPACING)
-            ucscPaddingTop = paddingTop + 2 * (self.BAND_HEIGHT + self.BAND_SPACING)
-            ensemblPaddingTop = paddingTop + 3 * (self.BAND_HEIGHT + self.BAND_SPACING)
+            phenogenPaddingTop = paddingTop + \
+                (self.BAND_HEIGHT + self.BAND_SPACING)
+            ucscPaddingTop = paddingTop + 2 * \
+                (self.BAND_HEIGHT + self.BAND_SPACING)
+            ensemblPaddingTop = paddingTop + 3 * \
+                (self.BAND_HEIGHT + self.BAND_SPACING)
         else:
-            ucscPaddingTop = paddingTop + (self.BAND_HEIGHT + self.BAND_SPACING)
-            ensemblPaddingTop = paddingTop + 2 * (self.BAND_HEIGHT + self.BAND_SPACING)
+            ucscPaddingTop = paddingTop + \
+                (self.BAND_HEIGHT + self.BAND_SPACING)
+            ensemblPaddingTop = paddingTop + 2 * \
+                (self.BAND_HEIGHT + self.BAND_SPACING)
 
         if zoom == 1:
             for pixel in range(xLeftOffset, xLeftOffset + plotWidth, pixelStep):
 
-                calBase = self.kONE_MILLION * (startMb + (endMb - startMb) * (pixel - xLeftOffset - 0.0) / plotWidth)
+                calBase = self.kONE_MILLION * \
+                    (startMb + (endMb - startMb) * \
+                     (pixel - xLeftOffset - 0.0) / plotWidth)
 
                 xBrowse1 = pixel
-                xBrowse2 = min(xLeftOffset + plotWidth, (pixel + pixelStep - 1))
+                xBrowse2 = min(xLeftOffset + plotWidth,
+                               (pixel + pixelStep - 1))
 
-                WEBQTL_COORDS = "%d, %d, %d, %d" % (xBrowse1, paddingTop, xBrowse2, (paddingTop + self.BAND_HEIGHT))
-                WEBQTL_HREF = "javascript:rangeView('%s', %f, %f)" % (self.selectedChr - 1, max(0, (calBase - webqtlZoomWidth)) / 1000000.0, (calBase + webqtlZoomWidth) / 1000000.0)
+                WEBQTL_COORDS = "%d, %d, %d, %d" % (
+                    xBrowse1, paddingTop, xBrowse2, (paddingTop + self.BAND_HEIGHT))
+                WEBQTL_HREF = "javascript:rangeView('%s', %f, %f)" % (self.selectedChr - 1, max(
+                    0, (calBase - webqtlZoomWidth)) / 1000000.0, (calBase + webqtlZoomWidth) / 1000000.0)
 
                 WEBQTL_TITLE = "Click to view this section of the genome in WebQTL"
                 gifmap.append(
@@ -1764,15 +1868,19 @@ class DisplayMappingResults:
                     outline=self.CLICKABLE_WEBQTL_REGION_COLOR,
                     fill=self.CLICKABLE_WEBQTL_REGION_COLOR)
                 im_drawer.line(
-                    xy=((xBrowse1, paddingTop), (xBrowse1, (paddingTop + self.BAND_HEIGHT))),
+                    xy=((xBrowse1, paddingTop), (xBrowse1,
+                        (paddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_WEBQTL_REGION_OUTLINE_COLOR)
 
                 if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
-                    PHENOGEN_COORDS = "%d, %d, %d, %d" % (xBrowse1, phenogenPaddingTop, xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))
+                    PHENOGEN_COORDS = "%d, %d, %d, %d" % (
+                        xBrowse1, phenogenPaddingTop, xBrowse2, (phenogenPaddingTop + self.BAND_HEIGHT))
                     if self.dataset.group.species == "mouse":
-                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
+                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (
+                            self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                     else:
-                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
+                        PHENOGEN_HREF = "https://phenogen.org/gene.jsp?speciesCB=Mm&auto=Y&geneTxt=chr%s:%d-%d&genomeVer=mm10" % (
+                            self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                     PHENOGEN_TITLE = "Click to view this section of the genome in PhenoGen"
                     gifmap.append(
                         HtmlGenWrapper.create_area_tag(
@@ -1786,14 +1894,18 @@ class DisplayMappingResults:
                         outline=self.CLICKABLE_PHENOGEN_REGION_COLOR,
                         fill=self.CLICKABLE_PHENOGEN_REGION_COLOR)
                     im_drawer.line(
-                        xy=((xBrowse1, phenogenPaddingTop), (xBrowse1, (phenogenPaddingTop + self.BAND_HEIGHT))),
+                        xy=((xBrowse1, phenogenPaddingTop), (xBrowse1,
+                            (phenogenPaddingTop + self.BAND_HEIGHT))),
                         fill=self.CLICKABLE_PHENOGEN_REGION_OUTLINE_COLOR)
 
-                UCSC_COORDS = "%d, %d, %d, %d" % (xBrowse1, ucscPaddingTop, xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))
+                UCSC_COORDS = "%d, %d, %d, %d" % (
+                    xBrowse1, ucscPaddingTop, xBrowse2, (ucscPaddingTop + self.BAND_HEIGHT))
                 if self.dataset.group.species == "mouse":
-                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d&hgt.customText=%s/snp/chr%s" % (self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases, webqtlConfig.PORTADDR, self.selectedChr)
+                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d&hgt.customText=%s/snp/chr%s" % (
+                        self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases, webqtlConfig.PORTADDR, self.selectedChr)
                 else:
-                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d" % (self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
+                    UCSC_HREF = "http://genome.ucsc.edu/cgi-bin/hgTracks?db=%s&position=chr%s:%d-%d" % (
+                        self._ucscDb, self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 UCSC_TITLE = "Click to view this section of the genome in the UCSC Genome Browser"
                 gifmap.append(
                     HtmlGenWrapper.create_area_tag(
@@ -1811,11 +1923,14 @@ class DisplayMappingResults:
                         (xBrowse1, (ucscPaddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_UCSC_REGION_OUTLINE_COLOR)
 
-                ENSEMBL_COORDS = "%d, %d, %d, %d" % (xBrowse1, ensemblPaddingTop, xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))
+                ENSEMBL_COORDS = "%d, %d, %d, %d" % (
+                    xBrowse1, ensemblPaddingTop, xBrowse2, (ensemblPaddingTop + self.BAND_HEIGHT))
                 if self.dataset.group.species == "mouse":
-                    ENSEMBL_HREF = "http://www.ensembl.org/Mus_musculus/contigview?highlight=&chr=%s&vc_start=%d&vc_end=%d&x=35&y=12" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
+                    ENSEMBL_HREF = "http://www.ensembl.org/Mus_musculus/contigview?highlight=&chr=%s&vc_start=%d&vc_end=%d&x=35&y=12" % (
+                        self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 else:
-                    ENSEMBL_HREF = "http://www.ensembl.org/Rattus_norvegicus/contigview?chr=%s&start=%d&end=%d" % (self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
+                    ENSEMBL_HREF = "http://www.ensembl.org/Rattus_norvegicus/contigview?chr=%s&start=%d&end=%d" % (
+                        self.selectedChr, max(0, calBase - flankingWidthInBases), calBase + flankingWidthInBases)
                 ENSEMBL_TITLE = "Click to view this section of the genome in the Ensembl Genome Browser"
                 gifmap.append(HtmlGenWrapper.create_area_tag(
                     shape='rect',
@@ -1841,19 +1956,23 @@ class DisplayMappingResults:
             if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
                 im_drawer.text(
                     text="Click to view the corresponding section of the genome in PhenoGen",
-                    xy=((xLeftOffset + 10), phenogenPaddingTop),  # + self.BAND_HEIGHT/2),
+                    # + self.BAND_HEIGHT/2),
+                    xy=((xLeftOffset + 10), phenogenPaddingTop),
                     font=clickableRegionLabelFont, fill=self.CLICKABLE_PHENOGEN_TEXT_COLOR)
             im_drawer.text(
                 text="Click to view the corresponding section of the genome in the UCSC Genome Browser",
-                xy=((xLeftOffset + 10), ucscPaddingTop),  # + self.BAND_HEIGHT/2),
+                # + self.BAND_HEIGHT/2),
+                xy=((xLeftOffset + 10), ucscPaddingTop),
                 font=clickableRegionLabelFont, fill=self.CLICKABLE_UCSC_TEXT_COLOR)
             im_drawer.text(
                 text="Click to view the corresponding section of the genome in the Ensembl Genome Browser",
-                xy=((xLeftOffset + 10), ensemblPaddingTop),  # + self.BAND_HEIGHT/2),
+                # + self.BAND_HEIGHT/2),
+                xy=((xLeftOffset + 10), ensemblPaddingTop),
                 font=clickableRegionLabelFont, fill=self.CLICKABLE_ENSEMBL_TEXT_COLOR)
 
             # draw the gray text
-            chrFont = ImageFont.truetype(font=VERDANA_BOLD_FILE, size=26 * zoom)
+            chrFont = ImageFont.truetype(
+                font=VERDANA_BOLD_FILE, size=26 * zoom)
             chrX = xLeftOffset + plotWidth - 2 - im_drawer.textsize(
                 "Chr %s" % self.ChrList[self.selectedChr][0], font=chrFont)[0]
             im_drawer.text(
@@ -1922,8 +2041,10 @@ class DisplayMappingResults:
                                            (Xc, yZero + xMajorTickHeight)),
                                        fill=xAxisTickMarkColor,
                                        width=X_MAJOR_TICK_THICKNESS)  # Draw the MAJOR tick mark
-                        labelStr = str(formatStr % _Mb)  # What Mbase location to put on the label
-                        strWidth, strHeight = im_drawer.textsize(labelStr, font=MBLabelFont)
+                        # What Mbase location to put on the label
+                        labelStr = str(formatStr % _Mb)
+                        strWidth, strHeight = im_drawer.textsize(
+                            labelStr, font=MBLabelFont)
                         drawStringXc = (Xc - (strWidth / 2.0))
                         im_drawer.text(xy=(drawStringXc, strYLoc),
                                        text=labelStr, font=MBLabelFont,
@@ -1956,9 +2077,11 @@ class DisplayMappingResults:
                                 canvas, text=str(tickdists), font=MBLabelFont,
                                 xy=(startPosX + tickdists * plotXScale,
                                     yZero + 10 * zoom), fill=BLACK, angle=270)
-                    startPosX += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
+                    startPosX += (self.ChrLengthDistList[i] + \
+                                  self.GraphInterval) * plotXScale
 
-            megabaseLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
+            megabaseLabelFont = ImageFont.truetype(
+                font=VERDANA_FILE, size=int(18 * zoom * 1.5))
             im_drawer.text(
                 text="Megabases",
                 xy=(
@@ -1984,7 +2107,8 @@ class DisplayMappingResults:
                                 if _locus.cM != preLpos:
                                     distinctCount += 1
                                 preLpos = _locus.cM
-                                thisChr.append([_locus.name, _locus.cM - Locus0CM])
+                                thisChr.append(
+                                    [_locus.name, _locus.cM - Locus0CM])
                     else:
                         for j in (0, nLoci / 4, nLoci / 2, nLoci*3/4, -1):
                             while _chr[j].name == ' - ':
@@ -1992,7 +2116,8 @@ class DisplayMappingResults:
                             if _chr[j].cM != preLpos:
                                 distinctCount += 1
                             preLpos = _chr[j].cM
-                            thisChr.append([_chr[j].name, _chr[j].cM - Locus0CM])
+                            thisChr.append(
+                                [_chr[j].name, _chr[j].cM - Locus0CM])
                     ChrAInfo.append(thisChr)
             else:
                 for i, _chr in enumerate(self.genotype):
@@ -2004,7 +2129,8 @@ class DisplayMappingResults:
                                 if _locus.cM != preLpos:
                                     distinctCount += 1
                                 preLpos = _locus.cM
-                                thisChr.append([_locus.name, _locus.cM - Locus0CM])
+                                thisChr.append(
+                                    [_locus.name, _locus.cM - Locus0CM])
                         ChrAInfo.append(thisChr)
 
             stepA = (plotWidth + 0.0) / distinctCount
@@ -2053,7 +2179,8 @@ class DisplayMappingResults:
                         outline=rectColor, fill=rectColor, width=0)
                     COORDS = "%d,%d,%d,%d" % (xLeftOffset+offsetA-LRectHeight, yZero+40+Zorder*(LRectWidth+3),\
                             xLeftOffset + offsetA, yZero +40+Zorder*(LRectWidth+3)+LRectWidth)
-                    HREF = "/show_trait?trait_id=%s&dataset=%s" % (Lname, self.dataset.group.name + "Geno")
+                    HREF = "/show_trait?trait_id=%s&dataset=%s" % (
+                        Lname, self.dataset.group.name + "Geno")
                     #HREF="javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm,fd.RISet+"Geno", Lname)
                     Areas = HtmlGenWrapper.create_area_tag(
                         shape='rect',
@@ -2067,9 +2194,11 @@ class DisplayMappingResults:
                     im_drawer.line(
                         xy=((startPosX, yZero), (startPosX, yZero + 40)),
                         fill=lineColor)
-                startPosX += (self.ChrLengthDistList[j] + self.GraphInterval) * plotXScale
+                startPosX += (self.ChrLengthDistList[j] + \
+                              self.GraphInterval) * plotXScale
 
-            centimorganLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
+            centimorganLabelFont = ImageFont.truetype(
+                font=VERDANA_FILE, size=int(18 * zoom * 1.5))
             im_drawer.text(
                 text="Centimorgans",
                 xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
@@ -2100,29 +2229,39 @@ class DisplayMappingResults:
         # ZS: This is a mess, but I don't know a better way to account for different mapping methods returning results in different formats + the option to change between LRS and LOD
         if self.lrsMax <= 0:  # sliding scale
             if "lrs_value" in self.qtlresults[0]:
-                LRS_LOD_Max = max([result['lrs_value'] for result in self.qtlresults])
+                LRS_LOD_Max = max([result['lrs_value']
+                                  for result in self.qtlresults])
                 if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
                     LRS_LOD_Max = LRS_LOD_Max / self.LODFACTOR
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
-                        self.significant = min(self.significant / self.LODFACTOR, webqtlConfig.MAXLRS)
-                        self.suggestive = min(self.suggestive / self.LODFACTOR, webqtlConfig.MAXLRS)
+                        self.significant = min(
+                            self.significant / self.LODFACTOR, webqtlConfig.MAXLRS)
+                        self.suggestive = min(
+                            self.suggestive / self.LODFACTOR, webqtlConfig.MAXLRS)
                 else:
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
-                        self.significant = min(self.significant, webqtlConfig.MAXLRS)
-                        self.suggestive = min(self.suggestive, webqtlConfig.MAXLRS)
+                        self.significant = min(
+                            self.significant, webqtlConfig.MAXLRS)
+                        self.suggestive = min(
+                            self.suggestive, webqtlConfig.MAXLRS)
                     else:
                         pass
             else:
-                LRS_LOD_Max = max([result['lod_score'] for result in self.qtlresults])
+                LRS_LOD_Max = max([result['lod_score']
+                                  for result in self.qtlresults])
                 if self.LRS_LOD == "LRS":
                     LRS_LOD_Max = LRS_LOD_Max * self.LODFACTOR
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
-                        self.significant = min(self.significant * self.LODFACTOR, webqtlConfig.MAXLRS)
-                        self.suggestive = min(self.suggestive * self.LODFACTOR, webqtlConfig.MAXLRS)
+                        self.significant = min(
+                            self.significant * self.LODFACTOR, webqtlConfig.MAXLRS)
+                        self.suggestive = min(
+                            self.suggestive * self.LODFACTOR, webqtlConfig.MAXLRS)
                 else:
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
-                        self.significant = min(self.significant, webqtlConfig.MAXLRS)
-                        self.suggestive = min(self.suggestive, webqtlConfig.MAXLRS)
+                        self.significant = min(
+                            self.significant, webqtlConfig.MAXLRS)
+                        self.suggestive = min(
+                            self.suggestive, webqtlConfig.MAXLRS)
                     else:
                         pass
 
@@ -2143,7 +2282,8 @@ class DisplayMappingResults:
         self.js_data = json.dumps(js_data)
 
         LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
-        LRSLODFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
+        LRSLODFont = ImageFont.truetype(
+            font=VERDANA_FILE, size=int(18 * zoom * 1.5))
 
         yZero = yTopOffset + plotHeight
         # LRSHeightThresh = drawAreaHeight
@@ -2188,7 +2328,8 @@ class DisplayMappingResults:
 
         # draw the "LRS" or "LOD" string to the left of the axis
         LRSScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
-        LRSLODFont = ImageFont.truetype(font=VERDANA_FILE, size=int(18 * zoom * 1.5))
+        LRSLODFont = ImageFont.truetype(
+            font=VERDANA_FILE, size=int(18 * zoom * 1.5))
         yZero = yTopOffset + plotHeight
 
         # TEXT_X_DISPLACEMENT = -20
@@ -2239,7 +2380,8 @@ class DisplayMappingResults:
 
             # ZS: I don't know if what I did here with this inner function is clever or overly complicated, but it's the only way I could think of to avoid duplicating the code inside this function
             def add_suggestive_significant_lines_and_legend(start_pos_x, chr_length_dist):
-                rightEdge = int(start_pos_x + chr_length_dist * plotXScale - self.SUGGESTIVE_WIDTH / 1.5)
+                rightEdge = int(start_pos_x + chr_length_dist * \
+                                plotXScale - self.SUGGESTIVE_WIDTH / 1.5)
                 im_drawer.line(
                     xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, suggestiveY),
                         (rightEdge, suggestiveY)),
@@ -2253,15 +2395,19 @@ class DisplayMappingResults:
                     width=self.SIGNIFICANT_WIDTH * zoom
                     # , clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
                 )
-                sugg_coords = "%d, %d, %d, %d" % (start_pos_x, suggestiveY - 2, rightEdge + 2 * zoom, suggestiveY + 2)
-                sig_coords = "%d, %d, %d, %d" % (start_pos_x, significantY - 2, rightEdge + 2 * zoom, significantY + 2)
+                sugg_coords = "%d, %d, %d, %d" % (
+                    start_pos_x, suggestiveY - 2, rightEdge + 2 * zoom, suggestiveY + 2)
+                sig_coords = "%d, %d, %d, %d" % (
+                    start_pos_x, significantY - 2, rightEdge + 2 * zoom, significantY + 2)
 
                 if self.LRS_LOD == 'LRS':
                     sugg_title = "Suggestive LRS = %0.2f" % self.suggestive
                     sig_title = "Significant LRS = %0.2f" % self.significant
                 else:
-                    sugg_title = "Suggestive LOD = %0.2f" % (self.suggestive / 4.61)
-                    sig_title = "Significant LOD = %0.2f" % (self.significant / 4.61)
+                    sugg_title = "Suggestive LOD = %0.2f" % (
+                        self.suggestive / 4.61)
+                    sig_title = "Significant LOD = %0.2f" % (
+                        self.significant / 4.61)
                 Areas1 = HtmlGenWrapper.create_area_tag(
                     shape='rect',
                     coords=sugg_coords,
@@ -2273,24 +2419,28 @@ class DisplayMappingResults:
                 gifmap.append(Areas1)
                 gifmap.append(Areas2)
 
-                start_pos_x += (chr_length_dist + self.GraphInterval) * plotXScale
+                start_pos_x += (chr_length_dist + \
+                                self.GraphInterval) * plotXScale
                 return start_pos_x
 
             for i, _chr in enumerate(self.genotype):
                 if self.selectedChr != -1:
                     if _chr.name == self.ChrList[self.selectedChr][0]:
-                        startPosX = add_suggestive_significant_lines_and_legend(startPosX, self.ChrLengthDistList[0])
+                        startPosX = add_suggestive_significant_lines_and_legend(
+                            startPosX, self.ChrLengthDistList[0])
                         break
                     else:
                         continue
                 else:
-                    startPosX = add_suggestive_significant_lines_and_legend(startPosX, self.ChrLengthDistList[i])
+                    startPosX = add_suggestive_significant_lines_and_legend(
+                        startPosX, self.ChrLengthDistList[i])
 
         if self.multipleInterval:
             lrsEdgeWidth = 1
         else:
             if self.additiveChecked:
-                additiveMax = max([abs(X['additive']) for X in self.qtlresults])
+                additiveMax = max([abs(X['additive'])
+                                  for X in self.qtlresults])
             lrsEdgeWidth = 3
 
         if zoom == 2:
@@ -2300,7 +2450,8 @@ class DisplayMappingResults:
         AdditiveCoordXY = []
         DominanceCoordXY = []
 
-        symbolFont = ImageFont.truetype(font=FNT_BS_FILE, size=5)  # ZS: For Manhattan Plot
+        symbolFont = ImageFont.truetype(
+            font=FNT_BS_FILE, size=5)  # ZS: For Manhattan Plot
 
         previous_chr = 1
         previous_chr_as_int = 0
@@ -2332,7 +2483,8 @@ class DisplayMappingResults:
                                 if Xc == Xc0:  # genotype , locus distance is 0
                                     Xcm = Xc
                                 else:
-                                    Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                                    Xcm = (yZero - Yc0) / \
+                                           ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                                 if Yc0 < yZero:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2340,7 +2492,8 @@ class DisplayMappingResults:
                                         # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
                                     im_drawer.line(
-                                        xy=((Xcm, yZero), (Xc, yZero - (Yc - yZero))),
+                                        xy=((Xcm, yZero),
+                                            (Xc, yZero - (Yc - yZero))),
                                         fill=minusColor, width=lineWidth
                                         # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
@@ -2391,7 +2544,8 @@ class DisplayMappingResults:
                 AdditiveCoordXY = []
                 previous_chr = qtlresult['chr']
                 previous_chr_as_int += 1
-                newStartPosX = (self.ChrLengthDistList[previous_chr_as_int - 1] + self.GraphInterval) * plotXScale
+                newStartPosX = (
+                    self.ChrLengthDistList[previous_chr_as_int - 1] + self.GraphInterval) * plotXScale
                 if newStartPosX != oldStartPosX:
                     startPosX += newStartPosX
                     oldStartPosX = newStartPosX
@@ -2408,10 +2562,12 @@ class DisplayMappingResults:
                         if self.genotype.filler:
                             if self.selectedChr != -1:
                                 start_cm = self.genotype[self.selectedChr - 1][0].cM
-                                Xc = startPosX + (qtlresult['Mb'] - start_cm) * plotXScale
+                                Xc = startPosX + \
+                                    (qtlresult['Mb'] - start_cm) * plotXScale
                             else:
                                 start_cm = self.genotype[previous_chr_as_int][0].cM
-                                Xc = startPosX + ((qtlresult['Mb'] - start_cm - startMb) * plotXScale) * (((qtlresult['Mb'] - start_cm - startMb) * plotXScale) / ((qtlresult['Mb'] - start_cm - startMb + self.GraphInterval) * plotXScale))
+                                Xc = startPosX + ((qtlresult['Mb'] - start_cm - startMb) * plotXScale) * (
+                                    ((qtlresult['Mb'] - start_cm - startMb) * plotXScale) / ((qtlresult['Mb'] - start_cm - startMb + self.GraphInterval) * plotXScale))
                 else:
                     Xc = startPosX + (qtlresult['Mb'] - startMb) * plotXScale
 
@@ -2425,17 +2581,23 @@ class DisplayMappingResults:
                     if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
                         if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
-                            Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / (LRS_LOD_Max * self.LODFACTOR)
+                            Yc = yZero - webqtlConfig.MAXLRS * \
+                                LRSHeightThresh / \
+                                    (LRS_LOD_Max * self.LODFACTOR)
                         else:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
-                            Yc = yZero - qtlresult['lrs_value'] * LRSHeightThresh / (LRS_LOD_Max * self.LODFACTOR)
+                            Yc = yZero - \
+                                qtlresult['lrs_value'] * LRSHeightThresh / \
+                                    (LRS_LOD_Max * self.LODFACTOR)
                     else:
                         if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
                             Yc = yZero - webqtlConfig.MAXLRS * LRSHeightThresh / LRS_LOD_Max
                         else:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lrs_value'] * LRSHeightThresh / LRS_LOD_Max
+                            Yc = yZero - \
+                                qtlresult['lrs_value'] * \
+                                    LRSHeightThresh / LRS_LOD_Max
                 else:
                     if qtlresult['lod_score'] > 100 or qtlresult['lod_score'] == 'inf':
                         #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
@@ -2443,10 +2605,14 @@ class DisplayMappingResults:
                     else:
                         if self.LRS_LOD == "LRS":
                             #Yc = yZero - qtlresult['lod_score']*self.LODFACTOR*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lod_score'] * self.LODFACTOR * LRSHeightThresh / LRS_LOD_Max
+                            Yc = yZero - \
+                                qtlresult['lod_score'] * self.LODFACTOR * \
+                                    LRSHeightThresh / LRS_LOD_Max
                         else:
                             #Yc = yZero - qtlresult['lod_score']*LRSHeightThresh/LRSAxisList[-1]
-                            Yc = yZero - qtlresult['lod_score'] * LRSHeightThresh / LRS_LOD_Max
+                            Yc = yZero - \
+                                qtlresult['lod_score'] * \
+                                    LRSHeightThresh / LRS_LOD_Max
 
                 if self.manhattan_plot == True:
                     if self.color_scheme == "single":
@@ -2462,7 +2628,8 @@ class DisplayMappingResults:
                     im_drawer.text(
                         text="5",
                         xy=(
-                            Xc - im_drawer.textsize("5", font=symbolFont)[0] / 2 + 1,
+                            Xc - im_drawer.textsize("5",
+                                                    font=symbolFont)[0] / 2 + 1,
                             Yc - 4),
                         fill=point_color, font=symbolFont)
                 else:
@@ -2471,7 +2638,8 @@ class DisplayMappingResults:
                 if not self.multipleInterval and self.additiveChecked:
                    if additiveMax == 0.0:
                        additiveMax = 0.000001
-                   Yc = yZero - qtlresult['additive'] * AdditiveHeightThresh / additiveMax
+                   Yc = yZero - qtlresult['additive'] * \
+                       AdditiveHeightThresh / additiveMax
                    AdditiveCoordXY.append((Xc, Yc))
 
                 m += 1
@@ -2496,7 +2664,8 @@ class DisplayMappingResults:
                         if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
-                            Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                            Xcm = (yZero - Yc0) / \
+                                   ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2561,7 +2730,8 @@ class DisplayMappingResults:
                         if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
-                            Xcm = (yZero - Yc0) / ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                            Xcm = (yZero - Yc0) / \
+                                   ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2616,9 +2786,11 @@ class DisplayMappingResults:
 
         # draw additive scale
         if not self.multipleInterval and self.additiveChecked:
-            additiveScaleFont = ImageFont.truetype(font=VERDANA_FILE, size=16 * zoom)
+            additiveScaleFont = ImageFont.truetype(
+                font=VERDANA_FILE, size=16 * zoom)
             additiveScale = Plot.detScaleOld(0, additiveMax)
-            additiveStep = (additiveScale[1] - additiveScale[0]) / additiveScale[2]
+            additiveStep = (additiveScale[1] - \
+                            additiveScale[0]) / additiveScale[2]
             additiveAxisList = Plot.frange(0, additiveScale[1], additiveStep)
             addPlotScale = AdditiveHeightThresh / additiveMax
             TEXT_Y_DISPLACEMENT = -8
@@ -2633,7 +2805,8 @@ class DisplayMappingResults:
                 scaleStr = "%2.3f" % item
                 im_drawer.text(
                     text=scaleStr,
-                    xy= (xLeftOffset + plotWidth + 6, additiveY + TEXT_Y_DISPLACEMENT),
+                    xy= (xLeftOffset + plotWidth + 6,
+                         additiveY + TEXT_Y_DISPLACEMENT),
                     font=additiveScaleFont, fill=self.ADDITIVE_COLOR_POSITIVE)
 
             im_drawer.line(
@@ -2690,14 +2863,16 @@ class DisplayMappingResults:
                 plotXScale = plotWidth / drawRegionDistance
 
         else:  # multiple chromosome view
-            plotXScale = plotWidth / ((len(self.genotype) - 1) * self.GraphInterval + drawRegionDistance)
+            plotXScale = plotWidth / \
+                ((len(self.genotype) - 1) * self.GraphInterval + drawRegionDistance)
 
             startPosX = xLeftOffset
             if fontZoom == 1.5:
                 chrFontZoom = 2
             else:
                 chrFontZoom = 1
-            chrLabelFont = ImageFont.truetype(font=VERDANA_FILE, size=24 * chrFontZoom)
+            chrLabelFont = ImageFont.truetype(
+                font=VERDANA_FILE, size=24 * chrFontZoom)
 
             for i, _chr in enumerate(self.genotype):
                 if (i % 2 == 0):
@@ -2712,14 +2887,18 @@ class DisplayMappingResults:
                     outline=GAINSBORO,
                     fill=theBackColor)
 
-                chrNameWidth, chrNameHeight = im_drawer.textsize(_chr.name, font=chrLabelFont)
-                chrStartPix = startPosX + (self.ChrLengthDistList[i] * plotXScale - chrNameWidth) / 2
-                chrEndPix = startPosX + (self.ChrLengthDistList[i] * plotXScale + chrNameWidth) / 2
+                chrNameWidth, chrNameHeight = im_drawer.textsize(
+                    _chr.name, font=chrLabelFont)
+                chrStartPix = startPosX + \
+                    (self.ChrLengthDistList[i] * plotXScale - chrNameWidth) / 2
+                chrEndPix = startPosX + \
+                    (self.ChrLengthDistList[i] * plotXScale + chrNameWidth) / 2
 
                 TEXT_Y_DISPLACEMENT = 0
                 im_drawer.text(xy=(chrStartPix, yTopOffset + TEXT_Y_DISPLACEMENT),
                                text=_chr.name, font=chrLabelFont, fill=BLACK)
-                COORDS = "%d,%d,%d,%d" % (chrStartPix, yTopOffset, chrEndPix, yTopOffset + 20)
+                COORDS = "%d,%d,%d,%d" % (
+                    chrStartPix, yTopOffset, chrEndPix, yTopOffset + 20)
 
                 # add by NL 09-03-2010
                 HREF = "javascript:chrView(%d,%s);" % (i, self.ChrLengthMbList)
@@ -2729,7 +2908,8 @@ class DisplayMappingResults:
                     coords=COORDS,
                     href=HREF)
                 gifmap.append(Areas)
-                startPosX += (self.ChrLengthDistList[i] + self.GraphInterval) * plotXScale
+                startPosX += (self.ChrLengthDistList[i] + \
+                              self.GraphInterval) * plotXScale
 
         return plotXScale
 
@@ -2746,7 +2926,8 @@ class DisplayMappingResults:
             perm_output = self.perm_output
 
         filename = webqtlUtil.genRandStr("Reg_")
-        Plot.plotBar(myCanvas, perm_output, XLabel=self.LRS_LOD, YLabel='Frequency', title=' Histogram of Permutation Test')
+        Plot.plotBar(myCanvas, perm_output, XLabel=self.LRS_LOD,
+                     YLabel='Frequency', title=' Histogram of Permutation Test')
         myCanvas.save("{}.gif".format(GENERATED_IMAGE_DIR + filename),
                       format='gif')
 
@@ -2825,7 +3006,8 @@ class DisplayMappingResults:
                 txEnd = theGO["TxEnd"]
                 theGO["snpDensity"] = theGO["snpCount"] / geneLength
                 if self.ALEX_DEBUG_BOOL_PRINT_GENE_LIST:
-                    geneIdString = 'http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids=%s' % theGO["GeneID"]
+                    geneIdString = 'http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids=%s' % theGO[
+                        "GeneID"]
 
                     if theGO["snpCount"]:
                         snpString = HT.Link(
@@ -2842,7 +3024,9 @@ class DisplayMappingResults:
                     else:
                         snpString = 0
 
-                    mouseStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Mouse&db=mm9&position=chr" + theGO["Chromosome"] + "%3A" + str(int(theGO["TxStart"] * 1000000.0)) + "-" + str(int(theGO["TxEnd"] * 1000000.0)) + "&pix=620&Submit=submit"
+                    mouseStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Mouse&db=mm9&position=chr" + \
+                        theGO["Chromosome"] + "%3A" + str(int(theGO["TxStart"] * 1000000.0)) + "-" + str(
+                            int(theGO["TxEnd"] * 1000000.0)) + "&pix=620&Submit=submit"
 
                     # the chromosomes for human 1 are 1qXX.XX
                     if theGO['humanGene']:
@@ -2854,7 +3038,8 @@ class DisplayMappingResults:
                         humanChr = theGO['humanGene']["Chromosome"]
                         humanTxStart = theGO['humanGene']["TxStart"]
 
-                        humanStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Human&db=hg17&position=chr%s:%d-%d" % (humanChr, int(1000000 * theGO['humanGene']["TxStart"]), int(1000000 * theGO['humanGene']["TxEnd"]))
+                        humanStartString = "http://genome.ucsc.edu/cgi-bin/hgTracks?clade=vertebrate&org=Human&db=hg17&position=chr%s:%d-%d" % (
+                            humanChr, int(1000000 * theGO['humanGene']["TxStart"]), int(1000000 * theGO['humanGene']["TxEnd"]))
                     else:
                         humanStartString = humanChr = humanStartDisplay = "--"
 
@@ -2879,7 +3064,8 @@ class DisplayMappingResults:
                     else:
                         chr_as_int = int(theGO["Chromosome"]) - 1
                     if refGene:
-                        literatureCorrelationString = str(self.getLiteratureCorrelation(self.cursor, refGene, theGO['GeneID']) or "N/A")
+                        literatureCorrelationString = str(self.getLiteratureCorrelation(
+                            self.cursor, refGene, theGO['GeneID']) or "N/A")
 
                         this_row = [selectCheck.__str__(),
                                     str(tableIterationsCnt),
@@ -2947,7 +3133,8 @@ class DisplayMappingResults:
 
                 if theGO["GeneID"] != "":
                     geneSymbolNCBI = str(HtmlGenWrapper.create_link_tag(
-                        "http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids={}".format(theGO["GeneID"]),
+                        "http://www.ncbi.nlm.nih.gov/entrez/query.fcgi?db=gene&cmd=Retrieve&dopt=Graphics&list_uids={}".format(
+                            theGO["GeneID"]),
                         theGO["GeneSymbol"],
                         Class="normalsize",
                         target="_blank"))
@@ -2960,7 +3147,8 @@ class DisplayMappingResults:
                     chr_as_int = int(theGO["Chromosome"]) - 1
 
                 geneLength = (float(theGO["TxEnd"]) - float(theGO["TxStart"]))
-                geneLengthURL = "javascript:rangeView('%s', %f, %f)" % (theGO["Chromosome"], float(theGO["TxStart"]) - (geneLength * 0.1), float(theGO["TxEnd"]) + (geneLength * 0.1))
+                geneLengthURL = "javascript:rangeView('%s', %f, %f)" % (theGO["Chromosome"], float(
+                    theGO["TxStart"]) - (geneLength * 0.1), float(theGO["TxEnd"]) + (geneLength * 0.1))
 
                 avgExprVal = []
                 if avgExprVal != "" and avgExprVal:
diff --git a/wqflask/wqflask/marker_regression/gemma_mapping.py b/wqflask/wqflask/marker_regression/gemma_mapping.py
index 68689104..289f1d5c 100644
--- a/wqflask/wqflask/marker_regression/gemma_mapping.py
+++ b/wqflask/wqflask/marker_regression/gemma_mapping.py
@@ -149,7 +149,8 @@ def gen_covariates_file(this_dataset, covariates, samples):
         dataset_name = covariate.split(":")[1]
         if dataset_name == "Temp":
             temp_group = trait_name.split("_")[2]
-            dataset_ob = create_dataset(dataset_name="Temp", dataset_type="Temp", group_name = temp_group)
+            dataset_ob = create_dataset(
+                dataset_name="Temp", dataset_type="Temp", group_name = temp_group)
         else:
             dataset_ob = create_dataset(covariate.split(":")[1])
         trait_ob = create_trait(dataset=dataset_ob,
diff --git a/wqflask/wqflask/marker_regression/plink_mapping.py b/wqflask/wqflask/marker_regression/plink_mapping.py
index 22a50bb8..2fa80841 100644
--- a/wqflask/wqflask/marker_regression/plink_mapping.py
+++ b/wqflask/wqflask/marker_regression/plink_mapping.py
@@ -10,7 +10,8 @@ logger = utility.logger.getLogger(__name__)
 
 
 def run_plink(this_trait, dataset, species, vals, maf):
-    plink_output_filename = webqtlUtil.genRandStr(f"{dataset.group.name}_{this_trait.name}_")
+    plink_output_filename = webqtlUtil.genRandStr(
+        f"{dataset.group.name}_{this_trait.name}_")
     gen_pheno_txt_file(dataset, vals)
 
     plink_command = f"{PLINK_COMMAND}  --noweb --bfile {flat_files('mapping')}/{dataset.group.name} --no-pheno --no-fid --no-parents --no-sex --maf {maf} --out { TMPDIR}{plink_output_filename} --assoc "
@@ -41,7 +42,8 @@ def gen_pheno_txt_file(this_dataset, vals):
                 this_val = -9
             else:
                 this_val = vals[i]
-            outfile.write("0 " + line[1] + " " + line[2] + " " + line[3] + " " + line[4] + " " + str(this_val) + "\n")
+            outfile.write("0 " + line[1] + " " + line[2] + " " + \
+                          line[3] + " " + line[4] + " " + str(this_val) + "\n")
 
 
 def gen_pheno_txt_file_plink(this_trait, dataset, vals, pheno_filename=''):
@@ -162,7 +164,8 @@ def parse_plink_output(output_filename, species):
 
 
 def build_line_list(line=""):
-    line_list = line.strip().split(' ')  # irregular number of whitespaces between columns
+    # irregular number of whitespaces between columns
+    line_list = line.strip().split(' ')
     line_list = [item for item in line_list if item != '']
     line_list = [item.strip() for item in line_list]
 
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index b8fe2c37..f932498f 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -26,7 +26,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         gen_pheno_txt_file(samples, vals, trait_filename)
 
         output_filename = (f"{this_dataset.group.name}_GWA_" +
-            ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+            ''.join(random.choice(string.ascii_uppercase + string.digits)
+                    for _ in range(6))
             )
         bootstrap_filename = None
         permu_filename = None
@@ -34,19 +35,22 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         opt_list = []
         if boot_check and num_bootstrap > 0:
             bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_" + 
-                ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+                ''.join(random.choice(string.ascii_uppercase + string.digits)
+                        for _ in range(6))
                 )
 
             opt_list.append("-b")
             opt_list.append(f"--n_bootstrap {str(num_bootstrap)}")
-            opt_list.append(f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
+            opt_list.append(
+                f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
         if num_perm > 0:
             permu_filename = ("{this_dataset.group.name}_PERM_" + 
             ''.join(random.choice(string.ascii_uppercase + 
                 string.digits) for _ in range(6))
             )
             opt_list.append("-n " + str(num_perm))
-            opt_list.append("--permu_output " + webqtlConfig.GENERATED_IMAGE_DIR + permu_filename + ".txt")
+            opt_list.append(
+                "--permu_output " + webqtlConfig.GENERATED_IMAGE_DIR + permu_filename + ".txt")
         if control_marker != "" and do_control == "true":
             opt_list.append("-c " + control_marker)
         if manhattan_plot != True:
@@ -58,7 +62,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
                                                                               genofile_name,
                                                                               TEMPDIR,
                                                                               trait_filename,
-                                                                              " ".join(opt_list),
+                                                                              " ".join(
+                                                                                  opt_list),
                                                                               webqtlConfig.GENERATED_IMAGE_DIR,
                                                                             output_filename))
 
@@ -67,7 +72,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
     else:
         output_filename, permu_filename, bootstrap_filename = output_files
 
-    marker_obs, permu_vals, bootstrap_vals = parse_reaper_output(output_filename, permu_filename, bootstrap_filename)
+    marker_obs, permu_vals, bootstrap_vals = parse_reaper_output(
+        output_filename, permu_filename, bootstrap_filename)
 
     suggestive = 0
     significant = 0
@@ -193,7 +199,8 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         suggestive = 0
         significant = 0
     else:
-        perm_output = genotype.permutation(strains=trimmed_samples, trait=trimmed_values, nperm=num_perm)
+        perm_output = genotype.permutation(
+            strains=trimmed_samples, trait=trimmed_values, nperm=num_perm)
         suggestive = perm_output[int(num_perm * 0.37 - 1)]
         significant = perm_output[int(num_perm * 0.95 - 1)]
         # highly_significant = perm_output[int(num_perm*0.99-1)] #ZS: Currently not used, but leaving it here just in case
@@ -257,7 +264,8 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         json_data['markernames'].append(reaper_locus.name)
         # if self.additive:
         #    self.json_data['additive'].append(qtl.additive)
-        locus = {"name": reaper_locus.name, "chr": reaper_locus.chr, "cM": reaper_locus.cM, "Mb": reaper_locus.Mb}
+        locus = {"name": reaper_locus.name, "chr": reaper_locus.chr,
+            "cM": reaper_locus.cM, "Mb": reaper_locus.Mb}
         qtl = {"lrs_value": qtl.lrs, "chr": converted_chr, "Mb": reaper_locus.Mb,
                "cM": reaper_locus.cM, "name": reaper_locus.name, "additive": qtl.additive, "dominance": qtl.dominance}
         qtl_results.append(qtl)
@@ -270,5 +278,6 @@ def natural_sort(marker_list):
     Changed to return indices instead of values, though, since the same reordering needs to be applied to bootstrap results
     """
     convert = lambda text: int(text) if text.isdigit() else text.lower()
-    alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', str(marker_list[key]['chr']))]
+    alphanum_key = lambda key: [convert(c) for c in re.split(
+        '([0-9]+)', str(marker_list[key]['chr']))]
     return sorted(list(range(len(marker_list))), key=alphanum_key)
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index 588600f5..c2b165a4 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -51,7 +51,8 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
     # Get pointers to some R/qtl functions
     scanone = ro.r["scanone"]               # Map the scanone function
     scantwo = ro.r["scantwo"]               # Map the scantwo function
-    calc_genoprob = ro.r["calc.genoprob"]         # Map the calc.genoprob function
+    # Map the calc.genoprob function
+    calc_genoprob = ro.r["calc.genoprob"]
 
     crossname = dataset.group.name
     # try:
@@ -67,14 +68,16 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
         scale_units = "Mb"
 
     generate_cross_from_geno(dataset, scale_units)
-    GENOtoCSVR = ro.r["GENOtoCSVR"]            # Map the local GENOtoCSVR function
+    # Map the local GENOtoCSVR function
+    GENOtoCSVR = ro.r["GENOtoCSVR"]
     crossfilelocation = TMPDIR + crossname + ".cross"
     if dataset.group.genofile:
         genofilelocation = locate(dataset.group.genofile, "genotype")
     else:
         genofilelocation = locate(dataset.group.name + ".geno", "genotype")
     logger.info("Going to create a cross from geno");
-    cross_object = GENOtoCSVR(genofilelocation, crossfilelocation)      # TODO: Add the SEX if that is available
+    # TODO: Add the SEX if that is available
+    cross_object = GENOtoCSVR(genofilelocation, crossfilelocation)
     logger.info("before calc_genoprob");
     if manhattan_plot:
         cross_object = calc_genoprob(cross_object)
@@ -85,14 +88,19 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
     logger.info("phenostring done");
     names_string = sanitize_rqtl_names(samples)
     logger.info("sanitized pheno and names");
-    cross_object = add_phenotype(cross_object, pheno_string, "the_pheno")                 # Add the phenotype
-    cross_object = add_names(cross_object, names_string, "the_names")                 # Add the phenotype
+    # Add the phenotype
+    cross_object = add_phenotype(cross_object, pheno_string, "the_pheno")
+    # Add the phenotype
+    cross_object = add_names(cross_object, names_string, "the_names")
     logger.info("Added pheno and names");
-    marker_covars = create_marker_covariates(control_marker, cross_object)  # Create the additive covariate markers
+    # Create the additive covariate markers
+    marker_covars = create_marker_covariates(control_marker, cross_object)
     logger.info("Marker covars done");
     if cofactors != "":
         logger.info("Cofactors: " + cofactors);
-        cross_object, trait_covars = add_cofactors(cross_object, dataset, cofactors, samples)  # Create the covariates from selected traits
+        # Create the covariates from selected traits
+        cross_object, trait_covars = add_cofactors(
+            cross_object, dataset, cofactors, samples)
         ro.r('all_covars <- cbind(marker_covars, trait_covars)')
     else:
         ro.r('all_covars <- marker_covars')
@@ -100,9 +108,11 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
     # DEBUG to save the session object to file
     if pair_scan:
         if do_control == "true":
-            logger.info("Using covariate"); result_data_frame = scantwo(cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method, n_cluster = 16)
+            logger.info("Using covariate"); result_data_frame = scantwo(
+                cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method, n_cluster = 16)
         else:
-            logger.info("No covariates"); result_data_frame = scantwo(cross_object, pheno="the_pheno", model=model, method=method, n_cluster=16)
+            logger.info("No covariates"); result_data_frame = scantwo(
+                cross_object, pheno="the_pheno", model=model, method=method, n_cluster=16)
 
         pair_scan_filename = webqtlUtil.genRandStr("scantwo_") + ".png"
         png(file=TEMPDIR + pair_scan_filename)
@@ -112,25 +122,36 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
         return process_pair_scan_results(result_data_frame)
     else:
         if do_control == "true" or cofactors != "":
-            logger.info("Using covariate"); result_data_frame = scanone(cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method)
+            logger.info("Using covariate"); result_data_frame = scanone(
+                cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method)
             ro.r('save.image(file = "/home/zas1024/gn2-zach/itp_cofactor_test.RData")')
         else:
-            logger.info("No covariates"); result_data_frame = scanone(cross_object, pheno="the_pheno", model=model, method=method)
-
-        if num_perm > 0 and permCheck == "ON":                                                                   # Do permutation (if requested by user)
-            if len(perm_strata_list) > 0:  # ZS: The strata list would only be populated if "Stratified" was checked on before mapping
-                cross_object, strata_ob = add_perm_strata(cross_object, perm_strata_list)
+            logger.info("No covariates"); result_data_frame = scanone(
+                cross_object, pheno="the_pheno", model=model, method=method)
+
+        # Do permutation (if requested by user)
+        if num_perm > 0 and permCheck == "ON":
+            # ZS: The strata list would only be populated if "Stratified" was checked on before mapping
+            if len(perm_strata_list) > 0:
+                cross_object, strata_ob = add_perm_strata(
+                    cross_object, perm_strata_list)
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(num_perm), perm_strata = strata_ob, model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(
+                        num_perm), perm_strata = strata_ob, model=model, method=method)
                 else:
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", n_perm=num_perm, perm_strata = strata_ob, model=model, method=method)
+                    perm_data_frame = scanone(
+                        cross_object, pheno_col="the_pheno", n_perm=num_perm, perm_strata = strata_ob, model=model, method=method)
             else:
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(num_perm), model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(
+                        num_perm), model=model, method=method)
                 else:
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", n_perm=num_perm, model=model, method=method)
+                    perm_data_frame = scanone(
+                        cross_object, pheno_col="the_pheno", n_perm=num_perm, model=model, method=method)
 
-            perm_output, suggestive, significant = process_rqtl_perm_results(num_perm, perm_data_frame)          # Functions that sets the thresholds for the webinterface
+            # Functions that sets the thresholds for the webinterface
+            perm_output, suggestive, significant = process_rqtl_perm_results(
+                num_perm, perm_data_frame)
             return perm_output, suggestive, significant, process_rqtl_results(result_data_frame, dataset.group.species)
         else:
             return process_rqtl_results(result_data_frame, dataset.group.species)
@@ -147,7 +168,8 @@ def generate_cross_from_rdata(dataset):
     """ % (rdata_location))
 
 
-def generate_cross_from_geno(dataset, scale_units):        # TODO: Need to figure out why some genofiles have the wrong format and don't convert properly
+# TODO: Need to figure out why some genofiles have the wrong format and don't convert properly
+def generate_cross_from_geno(dataset, scale_units):
 
     ro.r("""
        trim <- function( x ) { gsub("(^[[:space:]]+|[[:space:]]+$)", "", x) }
@@ -246,7 +268,8 @@ def sanitize_rqtl_names(vals):
 def add_phenotype(cross, pheno_as_string, col_name):
     ro.globalenv["the_cross"] = cross
     ro.r('pheno <- data.frame(pull.pheno(the_cross))')
-    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = as.numeric(' + pheno_as_string + '))')
+    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + \
+         ' = as.numeric(' + pheno_as_string + '))')
     return ro.r["the_cross"]
 
 
@@ -270,7 +293,8 @@ def add_categorical_covar(cross, covar_as_string, i):
       #logger.info("loop" + str(x));
       col_name = "covar_" + str(i) + "_" + str(x)
       #logger.info("col_name" + col_name);
-      ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = newcovar[,' + str(x) + '])')
+      ro.r('the_cross$pheno <- cbind(pheno, ' + \
+           col_name + ' = newcovar[,' + str(x) + '])')
       col_names.append(col_name)
       #logger.info("loop" + str(x) + "done"); 
 
@@ -281,7 +305,8 @@ def add_categorical_covar(cross, covar_as_string, i):
 def add_names(cross, names_as_string, col_name):
     ro.globalenv["the_cross"] = cross
     ro.r('pheno <- data.frame(pull.pheno(the_cross))')
-    ro.r('the_cross$pheno <- cbind(pheno, ' + col_name + ' = ' + names_as_string + ')')
+    ro.r('the_cross$pheno <- cbind(pheno, ' + \
+         col_name + ' = ' + names_as_string + ')')
     return ro.r["the_cross"]
 
 
@@ -330,9 +355,11 @@ def add_cofactors(cross, this_dataset, covariates, samples):
         logger.info("Covariate: " + covariate + " is of type: " + datatype);
         if(datatype == "categorical"):  # Cat variable
             logger.info("call of add_categorical_covar");
-            cross, col_names = add_categorical_covar(cross, covar_as_string, i)  # Expand and add it to the cross
+            cross, col_names = add_categorical_covar(
+                cross, covar_as_string, i)  # Expand and add it to the cross
             logger.info("add_categorical_covar returned");
-            for z, col_name in enumerate(col_names):  # Go through the additional covar names
+            # Go through the additional covar names
+            for z, col_name in enumerate(col_names):
                 if i < (len(covariate_list) - 1):
                     covar_name_string += '"' + col_name + '", '
                 else:
@@ -355,18 +382,22 @@ def add_cofactors(cross, this_dataset, covariates, samples):
 
 def create_marker_covariates(control_marker, cross):
     ro.globalenv["the_cross"] = cross
-    ro.r('genotypes <- pull.geno(the_cross)')                             # Get the genotype matrix
-    userinput_sanitized = control_marker.replace(" ", "").split(",")               # TODO: sanitize user input, Never Ever trust a user
+    # Get the genotype matrix
+    ro.r('genotypes <- pull.geno(the_cross)')
+    # TODO: sanitize user input, Never Ever trust a user
+    userinput_sanitized = control_marker.replace(" ", "").split(",")
     logger.debug(userinput_sanitized)
     if len(userinput_sanitized) > 0:
-        covariate_names = ', '.join('"{0}"'.format(w) for w in userinput_sanitized)
+        covariate_names = ', '.join('"{0}"'.format(w)
+                                    for w in userinput_sanitized)
         ro.r('covnames <- c(' + covariate_names + ')')
     else:
         ro.r('covnames <- c()')
     ro.r('covInGeno <- which(covnames %in% colnames(genotypes))')
     ro.r('covnames <- covnames[covInGeno]')
     ro.r("cat('covnames (purged): ', covnames,'\n')")
-    ro.r('marker_covars <- genotypes[,covnames]')                            # Get the covariate matrix by using the marker name as index to the genotype file
+    # Get the covariate matrix by using the marker name as index to the genotype file
+    ro.r('marker_covars <- genotypes[,covnames]')
     # TODO: Create a design matrix from the marker covars for the markers in case of an F2, 4way, etc
     return ro.r["marker_covars"]
 
@@ -375,7 +406,8 @@ def process_pair_scan_results(result):
     pair_scan_results = []
 
     result = result[1]
-    output = [tuple([result[j][i] for j in range(result.ncol)]) for i in range(result.nrow)]
+    output = [tuple([result[j][i] for j in range(result.ncol)])
+                    for i in range(result.nrow)]
 
     for i, line in enumerate(result.iter_row()):
         marker = {}
@@ -401,14 +433,17 @@ def process_rqtl_perm_results(num_perm, results):
     return perm_output, suggestive, significant
 
 
-def process_rqtl_results(result, species_name):        # TODO: how to make this a one liner and not copy the stuff in a loop
+# TODO: how to make this a one liner and not copy the stuff in a loop
+def process_rqtl_results(result, species_name):
     qtl_results = []
-    output = [tuple([result[j][i] for j in range(result.ncol)]) for i in range(result.nrow)]
+    output = [tuple([result[j][i] for j in range(result.ncol)])
+                    for i in range(result.nrow)]
 
     for i, line in enumerate(result.iter_row()):
         marker = {}
         marker['name'] = result.rownames[i]
-        if species_name == "mouse" and output[i][0] == 20:  # ZS: This is awkward, but I'm not sure how to change the 20s to Xs in the RData file
+        # ZS: This is awkward, but I'm not sure how to change the 20s to Xs in the RData file
+        if species_name == "mouse" and output[i][0] == 20:
             marker['chr'] = "X"
         else:
             marker['chr'] = output[i][0]
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index 31c58083..d9b28fba 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -51,7 +51,8 @@ class RunMapping:
     def __init__(self, start_vars, temp_uuid):
         helper_functions.get_species_dataset_trait(self, start_vars)
 
-        self.temp_uuid = temp_uuid  # needed to pass temp_uuid to gn1 mapping code (marker_regression_gn1.py)
+        # needed to pass temp_uuid to gn1 mapping code (marker_regression_gn1.py)
+        self.temp_uuid = temp_uuid
 
         # ZS: Needed to zoom in or remap temp traits like PCA traits
         if "temp_trait" in start_vars and start_vars['temp_trait'] != "False":
@@ -102,8 +103,11 @@ class RunMapping:
         if "results_path" in start_vars:
             self.mapping_results_path = start_vars['results_path']
         else:
-            mapping_results_filename = self.dataset.group.name + "_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
-            self.mapping_results_path = "{}{}.csv".format(webqtlConfig.GENERATED_IMAGE_DIR, mapping_results_filename)
+            mapping_results_filename = self.dataset.group.name + "_" + \
+                ''.join(random.choice(string.ascii_uppercase + string.digits)
+                        for _ in range(6))
+            self.mapping_results_path = "{}{}.csv".format(
+                webqtlConfig.GENERATED_IMAGE_DIR, mapping_results_filename)
 
         self.manhattan_plot = False
         if 'manhattan_plot' in start_vars:
@@ -122,7 +126,8 @@ class RunMapping:
             self.use_loco = None
         self.suggestive = ""
         self.significant = ""
-        self.pair_scan = False  # Initializing this since it is checked in views to determine which template to use
+        # Initializing this since it is checked in views to determine which template to use
+        self.pair_scan = False
         if 'transform' in start_vars:
             self.transform = start_vars['transform']
         else:
@@ -140,7 +145,8 @@ class RunMapping:
         # ZS: This is passed to GN1 code for single chr mapping
         self.selected_chr = -1
         if "selected_chr" in start_vars:
-            if int(start_vars['selected_chr']) != -1:  # ZS: Needs to be -1 if showing full map; there's probably a better way to fix this
+            # ZS: Needs to be -1 if showing full map; there's probably a better way to fix this
+            if int(start_vars['selected_chr']) != -1:
                 self.selected_chr = int(start_vars['selected_chr']) + 1
             else:
                 self.selected_chr = int(start_vars['selected_chr'])
@@ -198,28 +204,33 @@ class RunMapping:
             self.output_files = None
             if 'output_files' in start_vars:
                 self.output_files = start_vars['output_files']
-            if 'first_run' in start_vars:  # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+            # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+            if 'first_run' in start_vars:
                 self.first_run = False
             self.score_type = "-logP"
             self.manhattan_plot = True
             with Bench("Running GEMMA"):
                 if self.use_loco == "True":
-                    marker_obs, self.output_files = gemma_mapping.run_gemma(self.this_trait, self.dataset, self.samples, self.vals, self.covariates, self.use_loco, self.maf, self.first_run, self.output_files)
+                    marker_obs, self.output_files = gemma_mapping.run_gemma(
+                        self.this_trait, self.dataset, self.samples, self.vals, self.covariates, self.use_loco, self.maf, self.first_run, self.output_files)
                 else:
-                    marker_obs, self.output_files = gemma_mapping.run_gemma(self.this_trait, self.dataset, self.samples, self.vals, self.covariates, self.use_loco, self.maf, self.first_run, self.output_files)
+                    marker_obs, self.output_files = gemma_mapping.run_gemma(
+                        self.this_trait, self.dataset, self.samples, self.vals, self.covariates, self.use_loco, self.maf, self.first_run, self.output_files)
             results = marker_obs
         elif self.mapping_method == "rqtl_plink":
             results = self.run_rqtl_plink()
         elif self.mapping_method == "rqtl_geno":
             perm_strata = []
             if "perm_strata" in start_vars and "categorical_vars" in start_vars:
-                self.categorical_vars = start_vars["categorical_vars"].split(",")
+                self.categorical_vars = start_vars["categorical_vars"].split(
+                    ",")
                 if len(self.categorical_vars) and start_vars["perm_strata"] == "True":
                     primary_samples = SampleList(dataset=self.dataset,
                                                  sample_names=self.samples,
                                                  this_trait=self.this_trait)
 
-                    perm_strata = get_perm_strata(self.this_trait, primary_samples, self.categorical_vars, self.samples)
+                    perm_strata = get_perm_strata(
+                        self.this_trait, primary_samples, self.categorical_vars, self.samples)
             self.score_type = "LOD"
             self.control_marker = start_vars['control_marker']
             self.do_control = start_vars['do_control']
@@ -231,9 +242,11 @@ class RunMapping:
             # if start_vars['pair_scan'] == "true":
             #    self.pair_scan = True
             if self.permCheck and self.num_perm > 0:
-                self.perm_output, self.suggestive, self.significant, results = rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
+                self.perm_output, self.suggestive, self.significant, results = rqtl_mapping.run_rqtl_geno(
+                    self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
             else:
-                results = rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck, self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
+                results = rqtl_mapping.run_rqtl_geno(self.vals, self.samples, self.dataset, self.mapping_scale, self.method, self.model, self.permCheck,
+                                                     self.num_perm, perm_strata, self.do_control, self.control_marker, self.manhattan_plot, self.pair_scan, self.covariates)
         elif self.mapping_method == "reaper":
             if "startMb" in start_vars:  # ZS: Check if first time page loaded, so it can default to ON
                 if "additiveCheck" in start_vars:
@@ -268,10 +281,12 @@ class RunMapping:
             if self.reaper_version == "new":
                 self.first_run = True
                 self.output_files = None
-                if 'first_run' in start_vars:  # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+                # ZS: check if first run so existing result files can be used if it isn't (for example zooming on a chromosome, etc)
+                if 'first_run' in start_vars:
                     self.first_run = False
                     if 'output_files' in start_vars:
-                        self.output_files = start_vars['output_files'].split(",")
+                        self.output_files = start_vars['output_files'].split(
+                            ",")
 
                 results, self.perm_output, self.suggestive, self.significant, self.bootstrap_results, self.output_files = qtlreaper_mapping.run_reaper(self.this_trait,
                                                                                                                                     self.dataset,
@@ -301,7 +316,8 @@ class RunMapping:
         elif self.mapping_method == "plink":
             self.score_type = "-logP"
             self.manhattan_plot = True
-            results = plink_mapping.run_plink(self.this_trait, self.dataset, self.species, self.vals, self.maf)
+            results = plink_mapping.run_plink(
+                self.this_trait, self.dataset, self.species, self.vals, self.maf)
             #results = self.run_plink()
         else:
             logger.debug("RUNNING NOTHING")
@@ -353,7 +369,9 @@ class RunMapping:
                       chr=str(marker['chr']),
                       rs=marker['name'],
                       ps=this_ps,
-                      url="/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
+                      url="/show_trait?trait_id=" + \
+                          marker['name'] + "&dataset=" + \
+                              self.dataset.group.name + "Geno"
                   )
 
                   if self.geno_db_exists == "True":
@@ -362,7 +380,9 @@ class RunMapping:
                           chr=str(marker['chr']),
                           rs=marker['name'],
                           pos=this_ps,
-                          url="/show_trait?trait_id=" + marker['name'] + "&dataset=" + self.dataset.group.name + "Geno"
+                          url="/show_trait?trait_id=" + \
+                              marker['name'] + "&dataset=" + \
+                                  self.dataset.group.name + "Geno"
                       )
                   else:
                       annot_marker = dict(
@@ -373,7 +393,8 @@ class RunMapping:
                       )
 
                   if 'lrs_value' in marker and marker['lrs_value'] > 0:
-                      browser_marker['p_wald'] = 10**-(marker['lrs_value'] / 4.61)
+                      browser_marker['p_wald'] = 10**- \
+                          (marker['lrs_value'] / 4.61)
                   elif 'lod_score' in marker and marker['lod_score'] > 0:
                       browser_marker['p_wald'] = 10**-(marker['lod_score'])
                   else:
@@ -386,9 +407,13 @@ class RunMapping:
                           highest_chr = marker['chr']
                       if ('lod_score' in marker.keys()) or ('lrs_value' in marker.keys()):
                           if 'Mb' in marker.keys():
-                              marker['display_pos'] = "Chr" + str(marker['chr']) + ": " + "{:.6f}".format(marker['Mb'])
+                              marker['display_pos'] = "Chr" + \
+                                  str(marker['chr']) + ": " + \
+                                      "{:.6f}".format(marker['Mb'])
                           elif 'cM' in marker.keys():
-                              marker['display_pos'] = "Chr" + str(marker['chr']) + ": " + "{:.3f}".format(marker['cM'])
+                              marker['display_pos'] = "Chr" + \
+                                  str(marker['chr']) + ": " + \
+                                      "{:.3f}".format(marker['cM'])
                           else:
                               marker['display_pos'] = "N/A"
                           self.qtl_results.append(marker)
@@ -396,12 +421,15 @@ class RunMapping:
               total_markers = len(self.qtl_results)
 
               with Bench("Exporting Results"):
-                  export_mapping_results(self.dataset, self.this_trait, self.qtl_results, self.mapping_results_path, self.mapping_scale, self.score_type, self.transform, self.covariates, self.n_samples)
+                  export_mapping_results(self.dataset, self.this_trait, self.qtl_results, self.mapping_results_path,
+                                         self.mapping_scale, self.score_type, self.transform, self.covariates, self.n_samples)
 
               with Bench("Trimming Markers for Figure"):
                   if len(self.qtl_results) > 30000:
-                      self.qtl_results = trim_markers_for_figure(self.qtl_results)
-                      self.results_for_browser = trim_markers_for_figure(self.results_for_browser)
+                      self.qtl_results = trim_markers_for_figure(
+                          self.qtl_results)
+                      self.results_for_browser = trim_markers_for_figure(
+                          self.results_for_browser)
                       filtered_annotations = []
                       for marker in self.results_for_browser:
                           for annot_marker in self.annotations_for_browser:
@@ -409,14 +437,17 @@ class RunMapping:
                                   filtered_annotations.append(annot_marker)
                                   break
                       self.annotations_for_browser = filtered_annotations
-                      browser_files = write_input_for_browser(self.dataset, self.results_for_browser, self.annotations_for_browser)
+                      browser_files = write_input_for_browser(
+                          self.dataset, self.results_for_browser, self.annotations_for_browser)
                   else:
-                      browser_files = write_input_for_browser(self.dataset, self.results_for_browser, self.annotations_for_browser)
+                      browser_files = write_input_for_browser(
+                          self.dataset, self.results_for_browser, self.annotations_for_browser)
 
               with Bench("Trimming Markers for Table"):
                   self.trimmed_markers = trim_markers_for_table(results)
 
-              chr_lengths = get_chr_lengths(self.mapping_scale, self.mapping_method, self.dataset, self.qtl_results)
+              chr_lengths = get_chr_lengths(
+                  self.mapping_scale, self.mapping_method, self.dataset, self.qtl_results)
 
               # ZS: For zooming into genome browser, need to pass chromosome name instead of number
               if self.dataset.group.species == "mouse":
@@ -472,11 +503,14 @@ class RunMapping:
     def run_rqtl_plink(self):
         # os.chdir("") never do this inside a webserver!!
 
-        output_filename = webqtlUtil.genRandStr("%s_%s_" % (self.dataset.group.name, self.this_trait.name))
+        output_filename = webqtlUtil.genRandStr("%s_%s_" % (
+            self.dataset.group.name, self.this_trait.name))
 
-        plink_mapping.gen_pheno_txt_file_plink(self.this_trait, self.dataset, self.vals, pheno_filename=output_filename)
+        plink_mapping.gen_pheno_txt_file_plink(
+            self.this_trait, self.dataset, self.vals, pheno_filename=output_filename)
 
-        rqtl_command = './plink --noweb --ped %s.ped --no-fid --no-parents --no-sex --no-pheno --map %s.map --pheno %s/%s.txt --pheno-name %s --maf %s --missing-phenotype -9999 --out %s%s --assoc ' % (self.dataset.group.name, self.dataset.group.name, TMPDIR, plink_output_filename, self.this_trait.name, self.maf, TMPDIR, plink_output_filename)
+        rqtl_command = './plink --noweb --ped %s.ped --no-fid --no-parents --no-sex --no-pheno --map %s.map --pheno %s/%s.txt --pheno-name %s --maf %s --missing-phenotype -9999 --out %s%s --assoc ' % (
+            self.dataset.group.name, self.dataset.group.name, TMPDIR, plink_output_filename, self.this_trait.name, self.maf, TMPDIR, plink_output_filename)
 
         os.system(rqtl_command)
 
@@ -508,8 +542,10 @@ class RunMapping:
 
 def export_mapping_results(dataset, trait, markers, results_path, mapping_scale, score_type, transform, covariates, n_samples):
     with open(results_path, "w+") as output_file:
-        output_file.write("Time/Date: " + datetime.datetime.now().strftime("%x / %X") + "\n")
-        output_file.write("Population: " + dataset.group.species.title() + " " + dataset.group.name + "\n")
+        output_file.write(
+            "Time/Date: " + datetime.datetime.now().strftime("%x / %X") + "\n")
+        output_file.write(
+            "Population: " + dataset.group.species.title() + " " + dataset.group.name + "\n")
         output_file.write("Data Set: " + dataset.fullname + "\n")
         output_file.write("N Samples: " + str(n_samples) + "\n")
         if len(transform) > 0:
@@ -529,7 +565,8 @@ def export_mapping_results(dataset, trait, markers, results_path, mapping_scale,
             output_file.write(transform_text + "\n")
         if dataset.type == "ProbeSet":
             output_file.write("Gene Symbol: " + trait.symbol + "\n")
-            output_file.write("Location: " + str(trait.chr) + " @ " + str(trait.mb) + " Mb\n")
+            output_file.write("Location: " + str(trait.chr) + \
+                              " @ " + str(trait.mb) + " Mb\n")
         if len(covariates) > 0:
             output_file.write("Cofactors (dataset - trait):\n")
             for covariate in covariates.split(","):
@@ -630,9 +667,11 @@ def trim_markers_for_figure(markers):
 
 def trim_markers_for_table(markers):
     if 'lod_score' in list(markers[0].keys()):
-        sorted_markers = sorted(markers, key=lambda k: k['lod_score'], reverse=True)
+        sorted_markers = sorted(
+            markers, key=lambda k: k['lod_score'], reverse=True)
     else:
-        sorted_markers = sorted(markers, key=lambda k: k['lrs_value'], reverse=True)
+        sorted_markers = sorted(
+            markers, key=lambda k: k['lrs_value'], reverse=True)
 
     # ZS: So we end up with a list of just 2000 markers
     if len(sorted_markers) >= 2000:
@@ -643,7 +682,9 @@ def trim_markers_for_table(markers):
 
 
 def write_input_for_browser(this_dataset, gwas_results, annotations):
-    file_base = this_dataset.group.name + "_" + ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(6))
+    file_base = this_dataset.group.name + "_" + \
+        ''.join(random.choice(string.ascii_uppercase + string.digits)
+                for _ in range(6))
     gwas_filename = file_base + "_GWAS"
     annot_filename = file_base + "_ANNOT"
     gwas_path = "{}/gn2/".format(TEMPDIR) + gwas_filename
@@ -659,7 +700,8 @@ def write_input_for_browser(this_dataset, gwas_results, annotations):
 def geno_db_exists(this_dataset):
     geno_db_name = this_dataset.group.name + "Geno"
     try:
-        geno_db = data_set.create_dataset(dataset_name=geno_db_name, get_samplelist=False)
+        geno_db = data_set.create_dataset(
+            dataset_name=geno_db_name, get_samplelist=False)
         return "True"
     except:
         return "False"
@@ -689,9 +731,11 @@ def get_chr_lengths(mapping_scale, mapping_method, dataset, qtl_results):
                         highest_pos = float(result['cM']) * 1000000
                     else:
                         highest_pos = float(result['Mb']) * 1000000
-                    chr_lengths.append({"chr": str(this_chr), "size": str(highest_pos)})
+                    chr_lengths.append(
+                        {"chr": str(this_chr), "size": str(highest_pos)})
                 else:
-                    chr_lengths.append({"chr": str(this_chr), "size": str(highest_pos)})
+                    chr_lengths.append(
+                        {"chr": str(this_chr), "size": str(highest_pos)})
                     this_chr = chr_as_num
             else:
                 if mapping_method == "reaper":
@@ -722,7 +766,8 @@ def get_perm_strata(this_trait, sample_list, categorical_vars, used_samples):
             combined_string = ""
             for var in categorical_vars:
                 if var in list(sample_list.sample_attribute_values[sample].keys()):
-                    combined_string += str(sample_list.sample_attribute_values[sample][var])
+                    combined_string += str(
+                        sample_list.sample_attribute_values[sample][var])
                 else:
                     combined_string += "NA"
         else:
@@ -730,7 +775,8 @@ def get_perm_strata(this_trait, sample_list, categorical_vars, used_samples):
 
         perm_strata_strings.append(combined_string)
 
-    d = dict([(y, x + 1) for x, y in enumerate(sorted(set(perm_strata_strings)))])
+    d = dict([(y, x + 1)
+             for x, y in enumerate(sorted(set(perm_strata_strings)))])
     list_to_numbers = [d[x] for x in perm_strata_strings]
     perm_strata = list_to_numbers
 
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index d7c9ef95..7b9ff8fe 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -17,7 +17,8 @@ from wqflask.database import Base, init_db
 
 class User(Base):
     __tablename__ = "user"
-    id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    id = Column(Unicode(36), primary_key=True,
+                default=lambda: str(uuid.uuid4()))
     email_address = Column(Unicode(50), unique=True, nullable=False)
 
     # Todo: Turn on strict mode for Mysql
@@ -28,11 +29,13 @@ class User(Base):
 
     active = Column(Boolean(), nullable=False, default=True)
 
-    registration_info = Column(Text)   # json detailing when they were registered, etc.
+    # json detailing when they were registered, etc.
+    registration_info = Column(Text)
 
     confirmed = Column(Text)  # json detailing when they confirmed, etc.
 
-    superuser = Column(Text)  # json detailing when they became a superuser, otherwise empty
+    # json detailing when they became a superuser, otherwise empty
+    superuser = Column(Text)
                              # if not superuser
 
     logins = relationship("Login",
@@ -66,7 +69,8 @@ class User(Base):
 
     def get_collection_by_name(self, collection_name):
         try:
-            collect = self.user_collections.filter_by(name=collection_name).first()
+            collect = self.user_collections.filter_by(
+                name=collection_name).first()
         except sqlalchemy.orm.exc.NoResultFound:
             collect = None
         return collect
@@ -118,12 +122,15 @@ class User(Base):
 
 class Login(Base):
     __tablename__ = "login"
-    id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    id = Column(Unicode(36), primary_key=True,
+                default=lambda: str(uuid.uuid4()))
     user = Column(Unicode(36), ForeignKey('user.id'))
     timestamp = Column(DateTime(), default=lambda: datetime.datetime.utcnow())
     ip_address = Column(Unicode(39))
-    successful = Column(Boolean(), nullable=False)  # False if wrong password was entered
-    session_id = Column(Text)  # Set only if successfully logged in, otherwise should be blank
+    # False if wrong password was entered
+    successful = Column(Boolean(), nullable=False)
+    # Set only if successfully logged in, otherwise should be blank
+    session_id = Column(Text)
 
     # Set to user who assumes identity if this was a login for debugging purposes by a superuser
     assumed_by = Column(Unicode(36), ForeignKey('user.id'))
@@ -137,13 +144,16 @@ class Login(Base):
 
 class UserCollection(Base):
     __tablename__ = "user_collection"
-    id = Column(Unicode(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    id = Column(Unicode(36), primary_key=True,
+                default=lambda: str(uuid.uuid4()))
     user = Column(Unicode(36), ForeignKey('user.id'))
 
     # I'd prefer this to not have a length, but for the index below it needs one
     name = Column(Unicode(50))
-    created_timestamp = Column(DateTime(), default=lambda: datetime.datetime.utcnow())
-    changed_timestamp = Column(DateTime(), default=lambda: datetime.datetime.utcnow())
+    created_timestamp = Column(
+        DateTime(), default=lambda: datetime.datetime.utcnow())
+    changed_timestamp = Column(
+        DateTime(), default=lambda: datetime.datetime.utcnow())
     members = Column(Text)  # We're going to store them as a json list
 
     # This index ensures a user doesn't have more than one collection with the same name
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index 4591710c..36d4cd61 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -47,7 +47,8 @@ def search_for_user():
     params = request.form
     user_list = []
     user_list += get_users_like_unique_column("full_name", params['user_name'])
-    user_list += get_users_like_unique_column("email_address", params['user_email'])
+    user_list += get_users_like_unique_column(
+        "email_address", params['user_email'])
 
     return json.dumps(user_list)
 
@@ -61,7 +62,8 @@ def search_for_groups():
 
     user_list = []
     user_list += get_users_like_unique_column("full_name", params['user_name'])
-    user_list += get_users_like_unique_column("email_address", params['user_email'])
+    user_list += get_users_like_unique_column(
+        "email_address", params['user_email'])
     for user in user_list:
         group_list += get_groups_like_unique_column("admins", user['user_id'])
         group_list += get_groups_like_unique_column("members", user['user_id'])
@@ -124,7 +126,8 @@ def add_group_to_resource():
                 'admin': request.form['admin_privilege']
             }
             add_access_mask(resource_id, group_id, access_mask)
-            flash("Privileges have been added for group {}.".format(group_name), "alert-info")
+            flash("Privileges have been added for group {}.".format(
+                group_name), "alert-info")
             return redirect(url_for("manage_resource", resource_id=resource_id))
         else:
             return render_template("admin/search_for_groups.html", resource_id=resource_id)
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index ed5f9bad..273a97a4 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -52,7 +52,8 @@ class SearchResultPage:
         search = self.search_terms
         self.original_search_string = self.search_terms
         # check for dodgy search terms
-        rx = re.compile(r'.*\W(href|http|sql|select|update)\W.*', re.IGNORECASE)
+        rx = re.compile(
+            r'.*\W(href|http|sql|select|update)\W.*', re.IGNORECASE)
         if rx.match(search):
             logger.info("Regex failed search")
             self.search_term_exists = False
@@ -96,7 +97,8 @@ class SearchResultPage:
         trait_list = []
         json_trait_list = []
 
-        species = webqtlDatabaseFunction.retrieve_species(self.dataset.group.name)
+        species = webqtlDatabaseFunction.retrieve_species(
+            self.dataset.group.name)
         # result_set represents the results for each search term; a search of
         # "shh grin2b" would have two sets of results, one for each term
         logger.debug("self.results is:", pf(self.results))
@@ -109,7 +111,8 @@ class SearchResultPage:
 
             trait_dict = {}
             trait_id = result[0]
-            this_trait = create_trait(dataset=self.dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
+            this_trait = create_trait(
+                dataset=self.dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
             if this_trait:
                 trait_dict['index'] = index + 1
                 trait_dict['name'] = this_trait.name
@@ -118,7 +121,8 @@ class SearchResultPage:
                 else:
                     trait_dict['display_name'] = this_trait.name
                 trait_dict['dataset'] = this_trait.dataset.name
-                trait_dict['hmac'] = hmac.data_hmac('{}:{}'.format(this_trait.name, this_trait.dataset.name))
+                trait_dict['hmac'] = hmac.data_hmac(
+                    '{}:{}'.format(this_trait.name, this_trait.dataset.name))
                 if this_trait.dataset.type == "ProbeSet":
                     trait_dict['symbol'] = this_trait.symbol if this_trait.symbol else "N/A"
                     trait_dict['description'] = "N/A"
@@ -168,9 +172,11 @@ class SearchResultPage:
         self.trait_list = trait_list
 
         if self.dataset.type == "ProbeSet":
-            self.header_data_names = ['index', 'display_name', 'symbol', 'description', 'location', 'mean', 'lrs_score', 'lrs_location', 'additive']
+            self.header_data_names = ['index', 'display_name', 'symbol', 'description',
+                'location', 'mean', 'lrs_score', 'lrs_location', 'additive']
         elif self.dataset.type == "Publish":
-            self.header_data_names = ['index', 'display_name', 'description', 'mean', 'authors', 'pubmed_text', 'lrs_score', 'lrs_location', 'additive']
+            self.header_data_names = ['index', 'display_name', 'description', 'mean',
+                'authors', 'pubmed_text', 'lrs_score', 'lrs_location', 'additive']
         elif self.dataset.type == "Geno":
             self.header_data_names = ['index', 'display_name', 'location']
 
@@ -184,7 +190,8 @@ class SearchResultPage:
 
         combined_from_clause = ""
         combined_where_clause = ""
-        previous_from_clauses = []  # The same table can't be referenced twice in the from clause
+        # The same table can't be referenced twice in the from clause
+        previous_from_clauses = []
 
         logger.debug("len(search_terms)>1")
         symbol_list = []
@@ -198,7 +205,8 @@ class SearchResultPage:
             for i, a_search in enumerate(alias_terms):
                 the_search = self.get_search_ob(a_search)
                 if the_search != None:
-                    get_from_clause = getattr(the_search, "get_from_clause", None)
+                    get_from_clause = getattr(
+                        the_search, "get_from_clause", None)
                     if callable(get_from_clause):
                         from_clause = the_search.get_from_clause()
                         if from_clause in previous_from_clauses:
@@ -222,7 +230,8 @@ class SearchResultPage:
             else:
                 the_search = self.get_search_ob(a_search)
                 if the_search != None:
-                    get_from_clause = getattr(the_search, "get_from_clause", None)
+                    get_from_clause = getattr(
+                        the_search, "get_from_clause", None)
                     if callable(get_from_clause):
                         from_clause = the_search.get_from_clause()
                         if from_clause in previous_from_clauses:
@@ -241,7 +250,8 @@ class SearchResultPage:
                     self.search_term_exists = False
         if self.search_term_exists:
             combined_where_clause = "(" + combined_where_clause + ")"
-            final_query = the_search.compile_final_query(combined_from_clause, combined_where_clause)
+            final_query = the_search.compile_final_query(
+                combined_from_clause, combined_where_clause)
             results = the_search.execute(final_query)
             self.results.extend(results)
 
@@ -312,7 +322,8 @@ def get_aliases(symbol_list, species):
     symbols_string = ",".join(updated_symbols)
 
     filtered_aliases = []
-    response = requests.get(GN2_BASE_URL + "/gn3/gene/aliases2/" + symbols_string)
+    response = requests.get(
+        GN2_BASE_URL + "/gn3/gene/aliases2/" + symbols_string)
     if response:
         alias_lists = json.loads(response.content)
         seen = set()
diff --git a/wqflask/wqflask/show_trait/SampleList.py b/wqflask/wqflask/show_trait/SampleList.py
index 496dee57..6419335e 100644
--- a/wqflask/wqflask/show_trait/SampleList.py
+++ b/wqflask/wqflask/show_trait/SampleList.py
@@ -74,14 +74,20 @@ class SampleList:
                 if 'rrid' in sample.extra_attributes:
                     if self.dataset.group.species == "mouse":
                         if len(sample.extra_attributes['rrid'].split(":")) > 1:
-                            the_rrid = sample.extra_attributes['rrid'].split(":")[1]
-                            sample.extra_attributes['rrid'] = [sample.extra_attributes['rrid']]
-                            sample.extra_attributes['rrid'].append(webqtlConfig.RRID_MOUSE_URL % the_rrid)
+                            the_rrid = sample.extra_attributes['rrid'].split(":")[
+                                                                             1]
+                            sample.extra_attributes['rrid'] = [
+                                sample.extra_attributes['rrid']]
+                            sample.extra_attributes['rrid'].append(
+                                webqtlConfig.RRID_MOUSE_URL % the_rrid)
                     elif self.dataset.group.species == "rat":
                         if len(str(sample.extra_attributes['rrid'])):
-                            the_rrid = sample.extra_attributes['rrid'].split("_")[1]
-                            sample.extra_attributes['rrid'] = [sample.extra_attributes['rrid']]
-                            sample.extra_attributes['rrid'].append(webqtlConfig.RRID_RAT_URL % the_rrid)
+                            the_rrid = sample.extra_attributes['rrid'].split("_")[
+                                                                             1]
+                            sample.extra_attributes['rrid'] = [
+                                sample.extra_attributes['rrid']]
+                            sample.extra_attributes['rrid'].append(
+                                webqtlConfig.RRID_RAT_URL % the_rrid)
 
             self.sample_list.append(sample)
 
@@ -130,7 +136,8 @@ class SampleList:
             self.attributes[key].name = name
             self.attributes[key].distinct_values = [
                 item.Value for item in values]
-            self.attributes[key].distinct_values = natural_sort(self.attributes[key].distinct_values)
+            self.attributes[key].distinct_values = natural_sort(
+                self.attributes[key].distinct_values)
             all_numbers = True
             for value in self.attributes[key].distinct_values:
                 try:
@@ -170,7 +177,8 @@ class SampleList:
                     except ValueError:
                         pass
 
-                    attribute_values[self.attributes[item.Id].name.lower()] = attribute_value
+                    attribute_values[self.attributes[item.Id].name.lower(
+                    )] = attribute_value
                 self.sample_attribute_values[sample_name] = attribute_values
 
     def get_first_attr_col(self):
diff --git a/wqflask/wqflask/show_trait/export_trait_data.py b/wqflask/wqflask/show_trait/export_trait_data.py
index f0fcd27d..81e7903b 100644
--- a/wqflask/wqflask/show_trait/export_trait_data.py
+++ b/wqflask/wqflask/show_trait/export_trait_data.py
@@ -40,16 +40,23 @@ def get_export_metadata(trait_id, dataset_name):
     metadata = []
     if dataset.type == "Publish":
         metadata.append(["Phenotype ID: " + trait_id])
-        metadata.append(["Phenotype URL: " + "http://genenetwork.org/show_trait?trait_id=" + trait_id + "&dataset=" + dataset_name])
+        metadata.append(["Phenotype URL: " + "http://genenetwork.org/show_trait?trait_id=" + \
+                        trait_id + "&dataset=" + dataset_name])
         metadata.append(["Group: " + dataset.group.name])
-        metadata.append(["Phenotype: " + this_trait.description_display.replace(",", "\",\"")])
-        metadata.append(["Authors: " + (this_trait.authors if this_trait.authors else "N/A")])
-        metadata.append(["Title: " + (this_trait.title if this_trait.title else "N/A")])
-        metadata.append(["Journal: " + (this_trait.journal if this_trait.journal else "N/A")])
-        metadata.append(["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=" + dataset.name])
+        metadata.append(
+            ["Phenotype: " + this_trait.description_display.replace(",", "\",\"")])
+        metadata.append(
+            ["Authors: " + (this_trait.authors if this_trait.authors else "N/A")])
+        metadata.append(
+            ["Title: " + (this_trait.title if this_trait.title else "N/A")])
+        metadata.append(
+            ["Journal: " + (this_trait.journal if this_trait.journal else "N/A")])
+        metadata.append(
+            ["Dataset Link: http://gn1.genenetwork.org/webqtl/main.py?FormID=sharinginfo&InfoPageName=" + dataset.name])
     else:
         metadata.append(["Record ID: " + trait_id])
-        metadata.append(["Trait URL: " + "http://genenetwork.org/show_trait?trait_id=" + trait_id + "&dataset=" + dataset_name])
+        metadata.append(["Trait URL: " + "http://genenetwork.org/show_trait?trait_id=" + \
+                        trait_id + "&dataset=" + dataset_name])
         if this_trait.symbol:
             metadata.append(["Symbol: " + this_trait.symbol])
         metadata.append(["Dataset: " + dataset.name])
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index e5c67165..7fcbe984 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -27,9 +27,11 @@ class SnpBrowser:
                 self.table_rows = []
 
             if self.limit_strains == "true":
-                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type=self.variant_type, strains=self.chosen_strains, empty_columns = self.empty_columns)
+                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(
+                    variant_type=self.variant_type, strains=self.chosen_strains, empty_columns = self.empty_columns)
             else:
-                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(variant_type=self.variant_type, strains=self.strain_lists, species = self.species_name, empty_columns = self.empty_columns)
+                self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(
+                    variant_type=self.variant_type, strains=self.strain_lists, species = self.species_name, empty_columns = self.empty_columns)
 
     def initialize_parameters(self, start_vars):
         if 'first_run' in start_vars:
@@ -53,10 +55,12 @@ class SnpBrowser:
         self.rat_chr_list = []
         mouse_species_ob = species.TheSpecies(species_name="Mouse")
         for key in mouse_species_ob.chromosomes.chromosomes:
-            self.mouse_chr_list.append(mouse_species_ob.chromosomes.chromosomes[key].name)
+            self.mouse_chr_list.append(
+                mouse_species_ob.chromosomes.chromosomes[key].name)
         rat_species_ob = species.TheSpecies(species_name="Rat")
         for key in rat_species_ob.chromosomes.chromosomes:
-            self.rat_chr_list.append(rat_species_ob.chromosomes.chromosomes[key].name)
+            self.rat_chr_list.append(
+                rat_species_ob.chromosomes.chromosomes[key].name)
 
         if self.species_id == 1:
             self.this_chr_list = self.mouse_chr_list
@@ -109,9 +113,11 @@ class SnpBrowser:
                                      "CAST/EiJ"]
         self.chosen_strains_rat = ["BN", "F344", "WLI", "WMI"]
         if 'chosen_strains_mouse' in start_vars:
-            self.chosen_strains_mouse = start_vars['chosen_strains_mouse'].split(",")
+            self.chosen_strains_mouse = start_vars['chosen_strains_mouse'].split(
+                ",")
         if 'chosen_strains_rat' in start_vars:
-            self.chosen_strains_rat = start_vars['chosen_strains_rat'].split(",")
+            self.chosen_strains_rat = start_vars['chosen_strains_rat'].split(
+                ",")
 
         if self.species_id == 1:
             self.chosen_strains = self.chosen_strains_mouse
@@ -150,9 +156,11 @@ class SnpBrowser:
 
         if self.gene_name != "":
             if self.species_id != 0:
-                query = "SELECT geneSymbol, chromosome, txStart, txEnd FROM GeneList WHERE SpeciesId = %s AND geneSymbol = '%s'" % (self.species_id, self.gene_name)
+                query = "SELECT geneSymbol, chromosome, txStart, txEnd FROM GeneList WHERE SpeciesId = %s AND geneSymbol = '%s'" % (
+                    self.species_id, self.gene_name)
             else:
-                query = "SELECT geneSymbol, chromosome, txStart, txEnd FROM GeneList WHERE geneSymbol = '%s'" % (self.gene_name)
+                query = "SELECT geneSymbol, chromosome, txStart, txEnd FROM GeneList WHERE geneSymbol = '%s'" % (
+                    self.gene_name)
             result = g.db.execute(query).fetchone()
             if result:
                 self.gene_name, self.chr, self.start_mb, self.end_mb = result
@@ -163,9 +171,11 @@ class SnpBrowser:
                         query = "SELECT Id, Chromosome, Position, Position+0.000001 FROM SnpAll WHERE Rs = '%s'" % self.gene_name
                     else:
                         if self.species_id != 0:
-                            query = "SELECT Id, Chromosome, Position, Position+0.000001 FROM SnpAll where SpeciesId = %s AND SnpName = '%s'" % (self.species_id, self.gene_name)
+                            query = "SELECT Id, Chromosome, Position, Position+0.000001 FROM SnpAll where SpeciesId = %s AND SnpName = '%s'" % (
+                                self.species_id, self.gene_name)
                         else:
-                            query = "SELECT Id, Chromosome, Position, Position+0.000001 FROM SnpAll where SnpName = '%s'" % (self.gene_name)
+                            query = "SELECT Id, Chromosome, Position, Position+0.000001 FROM SnpAll where SnpName = '%s'" % (
+                                self.gene_name)
                     result_snp = g.db.execute(query).fetchall()
                     if result_snp:
                         self.snp_list = [item[0] for item in result_snp]
@@ -177,9 +187,11 @@ class SnpBrowser:
                 elif self.variant_type == "InDel":
                     if self.gene_name[0] == "I":
                         if self.species_id != 0:
-                            query = "SELECT Id, Chromosome, Mb_start, Mb_end FROM IndelAll WHERE SpeciesId = %s AND Name = '%s'" % (self.species_id, self.gene_name)
+                            query = "SELECT Id, Chromosome, Mb_start, Mb_end FROM IndelAll WHERE SpeciesId = %s AND Name = '%s'" % (
+                                self.species_id, self.gene_name)
                         else:
-                            query = "SELECT Id, Chromosome, Mb_start, Mb_end FROM IndelAll WHERE Name = '%s'" % (self.gene_name)
+                            query = "SELECT Id, Chromosome, Mb_start, Mb_end FROM IndelAll WHERE Name = '%s'" % (
+                                self.gene_name)
                         result_snp = g.db.execute(query).fetchall()
                     if result_snp:
                         self.snp_list = [item[0] for item in result_snp]
@@ -255,7 +267,8 @@ class SnpBrowser:
 
         if self.limit_strains == "true" and len(self.chosen_strains) > 0:
             for item in self.chosen_strains:
-                index = self.strain_lists[self.species_name.lower()].index(item)
+                index = self.strain_lists[self.species_name.lower()].index(
+                    item)
                 strain_index_list.append(index)
 
         for seq, result in enumerate(results):
@@ -263,7 +276,8 @@ class SnpBrowser:
 
             if self.variant_type == "SNP":
                 display_strains = []
-                snp_id, species_id, snp_name, rs, chr, mb, mb_2016, alleles, snp_source, conservation_score = result[:10]
+                snp_id, species_id, snp_name, rs, chr, mb, mb_2016, alleles, snp_source, conservation_score = result[
+                    :10]
                 effect_list = result[10:28]
                 if self.species_id == 1:
                     self.allele_list = result[30:]
@@ -279,7 +293,8 @@ class SnpBrowser:
                     self.allele_list = display_strains
 
                 effect_info_dict = get_effect_info(effect_list)
-                coding_domain_list = ['Start Gained', 'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
+                coding_domain_list = ['Start Gained', 'Start Lost',
+                    'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
                 intron_domain_list = ['Splice Site', 'Nonsplice Site']
 
                 for key in effect_info_dict:
@@ -296,19 +311,22 @@ class SnpBrowser:
 
                     if 'Intergenic' in domain:
                         if self.gene_name != "":
-                            gene_id = get_gene_id(self.species_id, self.gene_name)
+                            gene_id = get_gene_id(
+                                self.species_id, self.gene_name)
                             gene = [gene_id, self.gene_name]
                         else:
                             gene = check_if_in_gene(species_id, chr, mb)
                         transcript = exon = function = function_details = ''
                         if self.redundant == "false" or last_mb != mb:  # filter redundant
                             if self.include_record(domain, function, snp_source, conservation_score):
-                                info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain, function, function_details, snp_source, conservation_score, snp_id]
+                                info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain,
+                                    function, function_details, snp_source, conservation_score, snp_id]
                                 info_list.extend(self.allele_list)
                                 filtered_results.append(info_list)
                         last_mb = mb
                     else:
-                        gene_list, transcript_list, exon_list, function_list, function_details_list = effect_info_dict[key]
+                        gene_list, transcript_list, exon_list, function_list, function_details_list = effect_info_dict[
+                            key]
                         for index, item in enumerate(gene_list):
                             gene = item
                             transcript = transcript_list[index]
@@ -325,13 +343,15 @@ class SnpBrowser:
                                 function = ""
 
                             if function_details_list:
-                                function_details = "Biotype: " + function_details_list[index]
+                                function_details = "Biotype: " + \
+                                    function_details_list[index]
                             else:
                                 function_details = ""
 
                             if self.redundant == "false" or last_mb != mb:
                                 if self.include_record(domain, function, snp_source, conservation_score):
-                                    info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain, function, function_details, snp_source, conservation_score, snp_id]
+                                    info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain,
+                                        function, function_details, snp_source, conservation_score, snp_id]
                                     info_list.extend(self.allele_list)
                                     filtered_results.append(info_list)
                             last_mb = mb
@@ -345,7 +365,8 @@ class SnpBrowser:
                     gene = "No Gene"
                     domain = conservation_score = snp_id = snp_name = rs = flank_3 = flank_5 = ncbi = function = ""
                     if self.include_record(domain, function, source_name, conservation_score):
-                        filtered_results.append([indel_name, indel_chr, indel_mb_start, indel_mb_end, indel_strand, indel_type, indel_size, indel_sequence, source_name])
+                        filtered_results.append([indel_name, indel_chr, indel_mb_start, indel_mb_end,
+                                                indel_strand, indel_type, indel_size, indel_sequence, source_name])
                 last_mb = indel_mb_start
 
             else:
@@ -365,7 +386,8 @@ class SnpBrowser:
                     if gene_name and (gene_name not in gene_name_list):
                         gene_name_list.append(gene_name)
             if len(gene_name_list) > 0:
-                gene_id_name_dict = get_gene_id_name_dict(self.species_id, gene_name_list)
+                gene_id_name_dict = get_gene_id_name_dict(
+                    self.species_id, gene_name_list)
 
         # ZS: list of booleans representing which columns are entirely empty, so they aren't displayed on the page; only including ones that are sometimes empty (since there's always a location, etc)
         self.empty_columns = {
@@ -383,7 +405,8 @@ class SnpBrowser:
         for i, result in enumerate(self.filtered_results):
             this_row = {}
             if self.variant_type == "SNP":
-                snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain, function, function_details, snp_source, conservation_score, snp_id = result[:14]
+                snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain, function, function_details, snp_source, conservation_score, snp_id = result[
+                    :14]
                 allele_value_list = result[14:]
                 if rs:
                     snp_url = webqtlConfig.DBSNP % (rs)
@@ -394,9 +417,11 @@ class SnpBrowser:
                     end_bp = int(mb * 1000000 + 100)
                     position_info = "chr%s:%d-%d" % (chr, start_bp, end_bp)
                     if self.species_id == 2:
-                        snp_url = webqtlConfig.GENOMEBROWSER_URL % ("rn6", position_info)
+                        snp_url = webqtlConfig.GENOMEBROWSER_URL % (
+                            "rn6", position_info)
                     else:
-                        snp_url = webqtlConfig.GENOMEBROWSER_URL % ("mm10", position_info)
+                        snp_url = webqtlConfig.GENOMEBROWSER_URL % (
+                            "mm10", position_info)
 
                 mb = float(mb)
                 mb_formatted = "%2.6f" % mb
@@ -429,7 +454,8 @@ class SnpBrowser:
                     gene_link = ""
 
                 if transcript:
-                    transcript_link = webqtlConfig.ENSEMBLETRANSCRIPT_URL % (transcript)
+                    transcript_link = webqtlConfig.ENSEMBLETRANSCRIPT_URL % (
+                        transcript)
                     self.empty_columns['transcript'] = "true"
                 else:
                     transcript_link = ""
@@ -460,7 +486,8 @@ class SnpBrowser:
                     function_list = function_details.strip().split(",")
                     function_list = [item.strip() for item in function_list]
                     function_list[0] = function_list[0].title()
-                    function_details = ", ".join(item for item in function_list)
+                    function_details = ", ".join(
+                        item for item in function_list)
                     function_details = function_details.replace("_", " ")
                     function_details = function_details.replace("/", " -> ")
                     if function_details == "Biotype: Protein Coding":
@@ -675,8 +702,10 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
     header_fields = []
     header_data_names = []
     if variant_type == "SNP":
-        header_fields.append(['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'Source', 'ConScore', 'Gene', 'Transcript', 'Exon', 'Domain 1', 'Domain 2', 'Function', 'Details'])
-        header_data_names = ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles', 'snp_source', 'conservation_score', 'gene_name', 'transcript', 'exon', 'domain_1', 'domain_2', 'function', 'function_details']
+        header_fields.append(['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'Source', 'ConScore',
+                             'Gene', 'Transcript', 'Exon', 'Domain 1', 'Domain 2', 'Function', 'Details'])
+        header_data_names = ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles', 'snp_source', 'conservation_score',
+            'gene_name', 'transcript', 'exon', 'domain_1', 'domain_2', 'function', 'function_details']
 
         header_fields.append(strain_list)
         header_data_names += strain_list
@@ -712,8 +741,10 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
                 header_data_names.remove(col)
 
     elif variant_type == "InDel":
-        header_fields = ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source']
-        header_data_names = ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s', 'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name']
+        header_fields = ['Index', 'ID', 'Type', 'InDel Chr',
+            'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source']
+        header_data_names = ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
+            'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name']
 
     return header_fields, empty_field_count, header_data_names
 
@@ -726,10 +757,13 @@ def get_effect_details_by_category(effect_name=None, effect_value=None):
     function_detail_list = []
     tmp_list = []
 
-    gene_group_list = ['Upstream', 'Downstream', 'Splice Site', 'Nonsplice Site', '3\' UTR']
-    biotype_group_list = ['Unknown Effect In Exon', 'Start Gained', 'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
+    gene_group_list = ['Upstream', 'Downstream',
+        'Splice Site', 'Nonsplice Site', '3\' UTR']
+    biotype_group_list = ['Unknown Effect In Exon', 'Start Gained',
+        'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
     new_codon_group_list = ['Start Gained']
-    codon_effect_group_list = ['Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
+    codon_effect_group_list = [
+        'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
 
     effect_detail_list = effect_value.strip().split('|')
     effect_detail_list = [item.strip() for item in effect_detail_list]
@@ -773,8 +807,10 @@ def get_effect_info(effect_list):
     effect_detail_list = []
     effect_info_dict = {}
 
-    prime3_utr, prime5_utr, upstream, downstream, intron, nonsplice_site, splice_site, intergenic = effect_list[:8]
-    exon, non_synonymous_coding, synonymous_coding, start_gained, start_lost, stop_gained, stop_lost, unknown_effect_in_exon = effect_list[8:16]
+    prime3_utr, prime5_utr, upstream, downstream, intron, nonsplice_site, splice_site, intergenic = effect_list[
+        :8]
+    exon, non_synonymous_coding, synonymous_coding, start_gained, start_lost, stop_gained, stop_lost, unknown_effect_in_exon = effect_list[
+        8:16]
 
     if intergenic:
         domain = "Intergenic"
@@ -783,59 +819,72 @@ def get_effect_info(effect_list):
         # if not exon, get gene list/transcript list info
         if upstream:
             domain = "Upstream"
-            effect_detail_list = get_effect_details_by_category(effect_name='Upstream', effect_value=upstream)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Upstream', effect_value=upstream)
             effect_info_dict[domain] = effect_detail_list
         if downstream:
             domain = "Downstream"
-            effect_detail_list = get_effect_details_by_category(effect_name='Downstream', effect_value=downstream)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Downstream', effect_value=downstream)
             effect_info_dict[domain] = effect_detail_list
         if intron:
             if splice_site:
                 domain = "Splice Site"
-                effect_detail_list = get_effect_details_by_category(effect_name='Splice Site', effect_value=splice_site)
+                effect_detail_list = get_effect_details_by_category(
+                    effect_name='Splice Site', effect_value=splice_site)
                 effect_info_dict[domain] = effect_detail_list
             if nonsplice_site:
                 domain = "Nonsplice Site"
-                effect_detail_list = get_effect_details_by_category(effect_name='Nonsplice Site', effect_value=nonsplice_site)
+                effect_detail_list = get_effect_details_by_category(
+                    effect_name='Nonsplice Site', effect_value=nonsplice_site)
                 effect_info_dict[domain] = effect_detail_list
         # get gene, transcript_list, and exon info
         if prime3_utr:
             domain = "3\' UTR"
-            effect_detail_list = get_effect_details_by_category(effect_name='3\' UTR', effect_value=prime3_utr)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='3\' UTR', effect_value=prime3_utr)
             effect_info_dict[domain] = effect_detail_list
         if prime5_utr:
             domain = "5\' UTR"
-            effect_detail_list = get_effect_details_by_category(effect_name='5\' UTR', effect_value=prime5_utr)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='5\' UTR', effect_value=prime5_utr)
             effect_info_dict[domain] = effect_detail_list
 
         if start_gained:
             domain = "Start Gained"
-            effect_detail_list = get_effect_details_by_category(effect_name='Start Gained', effect_value=start_gained)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Start Gained', effect_value=start_gained)
             effect_info_dict[domain] = effect_detail_list
         if unknown_effect_in_exon:
             domain = "Unknown Effect In Exon"
-            effect_detail_list = get_effect_details_by_category(effect_name='Unknown Effect In Exon', effect_value=unknown_effect_in_exon)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Unknown Effect In Exon', effect_value=unknown_effect_in_exon)
             effect_info_dict[domain] = effect_detail_list
         if start_lost:
             domain = "Start Lost"
-            effect_detail_list = get_effect_details_by_category(effect_name='Start Lost', effect_value=start_lost)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Start Lost', effect_value=start_lost)
             effect_info_dict[domain] = effect_detail_list
         if stop_gained:
             domain = "Stop Gained"
-            effect_detail_list = get_effect_details_by_category(effect_name='Stop Gained', effect_value=stop_gained)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Stop Gained', effect_value=stop_gained)
             effect_info_dict[domain] = effect_detail_list
         if stop_lost:
             domain = "Stop Lost"
-            effect_detail_list = get_effect_details_by_category(effect_name='Stop Lost', effect_value=stop_lost)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Stop Lost', effect_value=stop_lost)
             effect_info_dict[domain] = effect_detail_list
 
         if non_synonymous_coding:
             domain = "Nonsynonymous"
-            effect_detail_list = get_effect_details_by_category(effect_name='Nonsynonymous', effect_value=non_synonymous_coding)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Nonsynonymous', effect_value=non_synonymous_coding)
             effect_info_dict[domain] = effect_detail_list
         if synonymous_coding:
             domain = "Synonymous"
-            effect_detail_list = get_effect_details_by_category(effect_name='Synonymous', effect_value=synonymous_coding)
+            effect_detail_list = get_effect_details_by_category(
+                effect_name='Synonymous', effect_value=synonymous_coding)
             effect_info_dict[domain] = effect_detail_list
 
     return effect_info_dict
@@ -863,7 +912,8 @@ def get_gene_id_name_dict(species_id, gene_name_list):
     gene_id_name_dict = {}
     if len(gene_name_list) == 0:
         return ""
-    gene_name_str_list = ["'" + gene_name + "'" for gene_name in gene_name_list]
+    gene_name_str_list = ["'" + gene_name + \
+        "'" for gene_name in gene_name_list]
     gene_name_str = ",".join(gene_name_str_list)
 
     query = """
diff --git a/wqflask/wqflask/update_search_results.py b/wqflask/wqflask/update_search_results.py
index 07073d6a..2e467dc8 100644
--- a/wqflask/wqflask/update_search_results.py
+++ b/wqflask/wqflask/update_search_results.py
@@ -52,10 +52,12 @@ class GSearch:
             self.trait_list = []
             with Bench("Creating trait objects"):
                 for line in re:
-                    dataset = create_dataset(line[3], "ProbeSet", get_samplelist=False)
+                    dataset = create_dataset(
+                        line[3], "ProbeSet", get_samplelist=False)
                     trait_id = line[4]
                     # with Bench("Building trait object"):
-                    this_trait = GeneralTrait(dataset=dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
+                    this_trait = GeneralTrait(
+                        dataset=dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
                     self.trait_list.append(this_trait)
 
         elif self.type == "phenotype":
@@ -97,7 +99,8 @@ class GSearch:
                 for line in re:
                     dataset = create_dataset(line[2], "Publish")
                     trait_id = line[3]
-                    this_trait = GeneralTrait(dataset=dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
+                    this_trait = GeneralTrait(
+                        dataset=dataset, name=trait_id, get_qtl_info=True, get_sample_info=False)
                     self.trait_list.append(this_trait)
 
         self.results = self.convert_to_json()
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index 2a2f8484..708d43d2 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -70,7 +70,8 @@ def set_password(password):
 
     assert len(password) >= 6, "Password shouldn't be shorter than 6 characters"
 
-    encoded_password = encode_password(pass_gen_fields, pass_gen_fields['unencrypted_password'])
+    encoded_password = encode_password(
+        pass_gen_fields, pass_gen_fields['unencrypted_password'])
 
     return encoded_password
 
@@ -161,12 +162,16 @@ def verify_email():
             # As long as they have access to the email account
             # We might as well log them in
             session_id_signed = get_signed_session_id(user_details)
-            flash("Thank you for logging in {}.".format(user_details['full_name']), "alert-success")
-            response = make_response(redirect(url_for('index_page', import_collections=import_col, anon_id=anon_id)))
-            response.set_cookie(UserSession.user_cookie_name, session_id_signed, max_age=None)
+            flash("Thank you for logging in {}.".format(
+                user_details['full_name']), "alert-success")
+            response = make_response(redirect(
+                url_for('index_page', import_collections=import_col, anon_id=anon_id)))
+            response.set_cookie(UserSession.user_cookie_name,
+                                session_id_signed, max_age=None)
             return response
         else:
-            flash("Invalid code: Password reset code does not exist or might have expired!", "error")
+            flash(
+                "Invalid code: Password reset code does not exist or might have expired!", "error")
 
 
 @app.route("/n/login", methods=('GET', 'POST'))
@@ -195,23 +200,28 @@ def login():
                     display_id = user_details['orcid']
                 else:
                     display_id = ""
-                flash("Thank you for logging in {}.".format(display_id), "alert-success")
+                flash("Thank you for logging in {}.".format(
+                    display_id), "alert-success")
                 response = make_response(redirect(url_for('index_page')))
-                response.set_cookie(UserSession.user_cookie_name, session_id_signed, max_age=None)
+                response.set_cookie(
+                    UserSession.user_cookie_name, session_id_signed, max_age=None)
             else:
                 flash("Something went unexpectedly wrong.", "alert-danger")
                 response = make_response(redirect(url_for('index_page')))  
             return response
         else:
-            user_details = get_user_by_unique_column("email_address", params['email_address'])
+            user_details = get_user_by_unique_column(
+                "email_address", params['email_address'])
             password_match = False
             if user_details:
                 submitted_password = params['password']
                 pwfields = user_details['password']
                 if isinstance(pwfields, str):
                     pwfields = json.loads(pwfields)
-                encrypted_pass_fields = encode_password(pwfields, submitted_password)
-                password_match = pbkdf2.safe_str_cmp(encrypted_pass_fields['password'], pwfields['password'])
+                encrypted_pass_fields = encode_password(
+                    pwfields, submitted_password)
+                password_match = pbkdf2.safe_str_cmp(
+                    encrypted_pass_fields['password'], pwfields['password'])
 
             else:  # Invalid e-mail
                 flash("Invalid e-mail address. Please try again.", "alert-danger")
@@ -227,12 +237,16 @@ def login():
                         anon_id = params['anon_id']
 
                     session_id_signed = get_signed_session_id(user_details)
-                    flash("Thank you for logging in {}.".format(user_details['full_name']), "alert-success")
-                    response = make_response(redirect(url_for('index_page', import_collections=import_col, anon_id=anon_id)))
-                    response.set_cookie(UserSession.user_cookie_name, session_id_signed, max_age=None)
+                    flash("Thank you for logging in {}.".format(
+                        user_details['full_name']), "alert-success")
+                    response = make_response(redirect(
+                        url_for('index_page', import_collections=import_col, anon_id=anon_id)))
+                    response.set_cookie(
+                        UserSession.user_cookie_name, session_id_signed, max_age=None)
                     return response
                 else:
-                    email_ob = send_verification_email(user_details, template_name="email/user_verification.txt")
+                    email_ob = send_verification_email(
+                        user_details, template_name="email/user_verification.txt")
                     return render_template("newsecurity/verification_still_needed.html", subject=email_ob['subject'])
             else:  # Incorrect password
                 # ZS: It previously seemed to store that there was an incorrect log-in attempt here, but it did so in the MySQL DB so this might need to be reproduced with Redis
@@ -252,8 +266,10 @@ def github_oauth2():
         "code": code
     }
 
-    result = requests.post("https://github.com/login/oauth/access_token", json=data)
-    result_dict = {arr[0]: arr[1] for arr in [tok.split("=") for tok in result.text.split("&")]}
+    result = requests.post(
+        "https://github.com/login/oauth/access_token", json=data)
+    result_dict = {arr[0]: arr[1]
+        for arr in [tok.split("=") for tok in result.text.split("&")]}
 
     github_user = get_github_user_details(result_dict["access_token"])
 
@@ -277,7 +293,8 @@ def github_oauth2():
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
+    result = requests.get(GITHUB_API_URL, headers={
+                          'Authorization': 'token ' + access_token}).content
 
     return json.loads(result)
 
@@ -323,7 +340,8 @@ def orcid_oauth2():
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, headers={'Authorization': 'token ' + access_token}).content
+    result = requests.get(GITHUB_API_URL, headers={
+                          'Authorization': 'token ' + access_token}).content
 
     return json.loads(result)
 
@@ -389,13 +407,16 @@ def forgot_password_submit():
     next_page = None
     if email_address != "":
         logger.debug("Wants to send password E-mail to ", email_address)
-        user_details = get_user_by_unique_column("email_address", email_address)
+        user_details = get_user_by_unique_column(
+            "email_address", email_address)
         if user_details:
-            email_subject = send_forgot_password_email(user_details["email_address"])
+            email_subject = send_forgot_password_email(
+                user_details["email_address"])
             return render_template("new_security/forgot_password_step2.html",
                                    subject=email_subject)
         else:
-            flash("The e-mail entered is not associated with an account.", "alert-danger")
+            flash("The e-mail entered is not associated with an account.",
+                  "alert-danger")
             return redirect(url_for("forgot_password"))
 
     else:
@@ -417,7 +438,8 @@ def password_reset():
             return render_template(
                 "new_security/password_reset.html", user_encode=user_details["email_address"])
         else:
-            flash("Invalid code: Password reset code does not exist or might have expired!", "error")
+            flash(
+                "Invalid code: Password reset code does not exist or might have expired!", "error")
             return redirect(url_for("login"))
     else:
         return redirect(url_for("login"))
@@ -446,21 +468,27 @@ def register_user(params):
         errors = []
         user_details = {}
 
-        user_details['email_address'] = params.get('email_address', '').encode("utf-8").strip()
+        user_details['email_address'] = params.get(
+            'email_address', '').encode("utf-8").strip()
         if not (5 <= len(user_details['email_address']) <= 50):
-            errors.append('Email Address needs to be between 5 and 50 characters.')
+            errors.append(
+                'Email Address needs to be between 5 and 50 characters.')
         else:
-            email_exists = get_user_by_unique_column("email_address", user_details['email_address'])
+            email_exists = get_user_by_unique_column(
+                "email_address", user_details['email_address'])
             if email_exists:
                 errors.append('User already exists with that email')
 
-        user_details['full_name'] = params.get('full_name', '').encode("utf-8").strip()
+        user_details['full_name'] = params.get(
+            'full_name', '').encode("utf-8").strip()
         if not (5 <= len(user_details['full_name']) <= 50):
             errors.append('Full Name needs to be between 5 and 50 characters.')
 
-        user_details['organization'] = params.get('organization', '').encode("utf-8").strip()
+        user_details['organization'] = params.get(
+            'organization', '').encode("utf-8").strip()
         if user_details['organization'] and not (5 <= len(user_details['organization']) <= 50):
-            errors.append('Organization needs to be empty or between 5 and 50 characters.')
+            errors.append(
+                'Organization needs to be empty or between 5 and 50 characters.')
 
         password = str(params.get('password', ''))
         if not (6 <= len(password)):
@@ -493,7 +521,8 @@ def register():
         errors = register_user(params)
 
         if len(errors) == 0:
-            flash("Registration successful. You may login with your new account", "alert-info")
+            flash(
+                "Registration successful. You may login with your new account", "alert-info")
             return redirect(url_for("login"))
 
     return render_template("new_security/register_user.html", values=params, errors=errors)
diff --git a/wqflask/wqflask/user_manager.py b/wqflask/wqflask/user_manager.py
index a9bd65e6..5610833b 100644
--- a/wqflask/wqflask/user_manager.py
+++ b/wqflask/wqflask/user_manager.py
@@ -93,8 +93,10 @@ class AnonUser:
                 this_collection = {}
                 this_collection['id'] = collection['id']
                 this_collection['name'] = collection['name']
-                this_collection['created_timestamp'] = collection['created_timestamp'].strftime('%b %d %Y %I:%M%p')
-                this_collection['changed_timestamp'] = collection['changed_timestamp'].strftime('%b %d %Y %I:%M%p')
+                this_collection['created_timestamp'] = collection['created_timestamp'].strftime(
+                    '%b %d %Y %I:%M%p')
+                this_collection['changed_timestamp'] = collection['changed_timestamp'].strftime(
+                    '%b %d %Y %I:%M%p')
                 this_collection['num_members'] = collection['num_members']
                 this_collection['members'] = collection['members']
                 updated_collections.append(this_collection)
@@ -108,21 +110,26 @@ class AnonUser:
         else:
             collections = json.loads(json_collections)
             for collection in collections:
-                collection['created_timestamp'] = datetime.datetime.strptime(collection['created_timestamp'], '%b %d %Y %I:%M%p')
-                collection['changed_timestamp'] = datetime.datetime.strptime(collection['changed_timestamp'], '%b %d %Y %I:%M%p')
+                collection['created_timestamp'] = datetime.datetime.strptime(
+                    collection['created_timestamp'], '%b %d %Y %I:%M%p')
+                collection['changed_timestamp'] = datetime.datetime.strptime(
+                    collection['changed_timestamp'], '%b %d %Y %I:%M%p')
 
-            collections = sorted(collections, key=lambda i: i['changed_timestamp'], reverse=True)
+            collections = sorted(
+                collections, key=lambda i: i['changed_timestamp'], reverse=True)
             return collections
 
     def import_traits_to_user(self):
         result = Redis.get(self.key)
         collections_list = json.loads(result if result else "[]")
         for collection in collections_list:
-            collection_exists = g.user_session.get_collection_by_name(collection['name'])
+            collection_exists = g.user_session.get_collection_by_name(
+                collection['name'])
             if collection_exists:
                 continue
             else:
-                g.user_session.add_collection(collection['name'], collection['members'])
+                g.user_session.add_collection(
+                    collection['name'], collection['members'])
 
     def display_num_collections(self):
         """
@@ -148,7 +155,8 @@ def verify_cookie(cookie):
     the_uuid, separator, the_signature = cookie.partition(':')
     assert len(the_uuid) == 36, "Is session_id a uuid?"
     assert separator == ":", "Expected a : here"
-    assert the_signature == actual_hmac_creation(the_uuid), "Uh-oh, someone tampering with the cookie?"
+    assert the_signature == actual_hmac_creation(
+        the_uuid), "Uh-oh, someone tampering with the cookie?"
     return the_uuid
 
 
@@ -282,7 +290,8 @@ class UserSession:
 
         updated_collection['members'] = updated_traits
         updated_collection['num_members'] = len(updated_traits)
-        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p')
+        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime(
+            '%b %d %Y %I:%M%p')
 
         updated_collections = []
         for collection in self.user_collections:
@@ -308,7 +317,8 @@ class UserSession:
 
         updated_collection['members'] = updated_traits
         updated_collection['num_members'] = len(updated_traits)
-        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p')
+        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime(
+            '%b %d %Y %I:%M%p')
 
         updated_collections = []
         for collection in self.user_collections:
@@ -355,7 +365,8 @@ def get_cookie():
 
 def set_cookie(response):
     if not request.cookies.get(g.cookie_session.cookie_name):
-        response.set_cookie(g.cookie_session.cookie_name, g.cookie_session.cookie)
+        response.set_cookie(g.cookie_session.cookie_name,
+                            g.cookie_session.cookie)
     return response
 
 
@@ -390,22 +401,28 @@ class RegisterUser:
         self.errors = []
         self.user = Bunch()
 
-        self.user.email_address = kw.get('email_address', '').encode("utf-8").strip()
+        self.user.email_address = kw.get(
+            'email_address', '').encode("utf-8").strip()
         if not (5 <= len(self.user.email_address) <= 50):
-            self.errors.append('Email Address needs to be between 5 and 50 characters.')
+            self.errors.append(
+                'Email Address needs to be between 5 and 50 characters.')
         else:
-            email_exists = get_user_by_unique_column("email_address", self.user.email_address)
+            email_exists = get_user_by_unique_column(
+                "email_address", self.user.email_address)
             #email_exists = get_user_by_unique_column(es, "email_address", self.user.email_address)
             if email_exists:
                 self.errors.append('User already exists with that email')
 
         self.user.full_name = kw.get('full_name', '').encode("utf-8").strip()
         if not (5 <= len(self.user.full_name) <= 50):
-            self.errors.append('Full Name needs to be between 5 and 50 characters.')
+            self.errors.append(
+                'Full Name needs to be between 5 and 50 characters.')
 
-        self.user.organization = kw.get('organization', '').encode("utf-8").strip()
+        self.user.organization = kw.get(
+            'organization', '').encode("utf-8").strip()
         if self.user.organization and not (5 <= len(self.user.organization) <= 50):
-            self.errors.append('Organization needs to be empty or between 5 and 50 characters.')
+            self.errors.append(
+                'Organization needs to be empty or between 5 and 50 characters.')
 
         password = str(kw.get('password', ''))
         if not (6 <= len(password)):
@@ -568,14 +585,16 @@ def password_reset():
     if verification_code:
         user_email = check_verification_code(verification_code)
         if user_email:
-            user_details = get_user_by_unique_column('email_address', user_email)
+            user_details = get_user_by_unique_column(
+                'email_address', user_email)
             if user_details:
                 return render_template(
                     "new_security/password_reset.html", user_encode=user_details["user_id"])
             else:
                 flash("Invalid code: User no longer exists!", "error")
         else:
-            flash("Invalid code: Password reset code does not exist or might have expired!", "error")
+            flash(
+                "Invalid code: Password reset code does not exist or might have expired!", "error")
     else:
         return redirect(url_for("login"))
 
@@ -648,8 +667,10 @@ def github_oauth2():
         "client_secret": GITHUB_CLIENT_SECRET,
         "code": code
     }
-    result = requests.post("https://github.com/login/oauth/access_token", json=data)
-    result_dict = {arr[0]: arr[1] for arr in [tok.split("=") for tok in [token.encode("utf-8") for token in result.text.split("&")]]}
+    result = requests.post(
+        "https://github.com/login/oauth/access_token", json=data)
+    result_dict = {arr[0]: arr[1] for arr in [tok.split(
+        "=") for tok in [token.encode("utf-8") for token in result.text.split("&")]]}
 
     github_user = get_github_user_details(result_dict["access_token"])
 
@@ -696,7 +717,8 @@ def orcid_oauth2():
 
 def get_github_user_details(access_token):
     from utility.tools import GITHUB_API_URL
-    result = requests.get(GITHUB_API_URL, params={"access_token": access_token})
+    result = requests.get(GITHUB_API_URL, params={
+                          "access_token": access_token})
     return result.json()
 
 
@@ -737,7 +759,8 @@ class LoginUser:
             return render_template(
                 "new_security/login_user.html", external_login=external_login, redis_is_available=is_redis_available())
         else:
-            user_details = get_user_by_unique_column("email_address", params["email_address"])
+            user_details = get_user_by_unique_column(
+                "email_address", params["email_address"])
             #user_details = get_user_by_unique_column(es, "email_address", params["email_address"])
             user = None
             valid = None
@@ -755,8 +778,10 @@ class LoginUser:
                     pwfields.iterations,
                     pwfields.keylength,
                     pwfields.hashfunc)
-                logger.debug("\n\nComparing:\n{}\n{}\n".format(encrypted.password, pwfields.password))
-                valid = pbkdf2.safe_str_cmp(encrypted.password, pwfields.password)
+                logger.debug("\n\nComparing:\n{}\n{}\n".format(
+                    encrypted.password, pwfields.password))
+                valid = pbkdf2.safe_str_cmp(
+                    encrypted.password, pwfields.password)
                 logger.debug("valid is:", valid)
 
         if valid and not user.confirmed:
@@ -782,7 +807,8 @@ class LoginUser:
         else:
             if user:
                 self.unsuccessful_login(user)
-            flash("Invalid email-address or password. Please try again.", "alert-danger")
+            flash("Invalid email-address or password. Please try again.",
+                  "alert-danger")
             response = make_response(redirect(url_for('login')))
 
             return response
@@ -790,14 +816,17 @@ class LoginUser:
     def actual_login(self, user, assumed_by=None, import_collections=None):
         """The meat of the logging in process"""
         session_id_signed = self.successful_login(user, assumed_by)
-        flash("Thank you for logging in {}.".format(user.full_name), "alert-success")
-        response = make_response(redirect(url_for('index_page', import_collections=import_collections)))
+        flash("Thank you for logging in {}.".format(
+            user.full_name), "alert-success")
+        response = make_response(
+            redirect(url_for('index_page', import_collections=import_collections)))
         if self.remember_me:
             max_age = self.remember_time
         else:
             max_age = None
 
-        response.set_cookie(UserSession.cookie_name, session_id_signed, max_age=max_age)
+        response.set_cookie(UserSession.cookie_name,
+                            session_id_signed, max_age=max_age)
         return response
 
     def successful_login(self, user, assumed_by=None):
@@ -866,13 +895,15 @@ def forgot_password_submit():
     next_page = None
     if email_address != "":
         logger.debug("Wants to send password E-mail to ", email_address)
-        user_details = get_user_by_unique_column("email_address", email_address)
+        user_details = get_user_by_unique_column(
+            "email_address", email_address)
         if user_details:
             ForgotPasswordEmail(user_details["email_address"])
             return render_template("new_security/forgot_password_step2.html",
                                    subject=ForgotPasswordEmail.subject)
         else:
-            flash("The e-mail entered is not associated with an account.", "alert-danger")
+            flash("The e-mail entered is not associated with an account.",
+                  "alert-danger")
             return redirect(url_for("forgot_password"))
 
     else:
@@ -959,7 +990,8 @@ def register():
         errors = result.errors
 
         if len(errors) == 0:
-            flash("Registration successful. You may login with your new account", "alert-info")
+            flash(
+                "Registration successful. You may login with your new account", "alert-info")
             return redirect(url_for("login"))
 
     return render_template("new_security/register_user.html", values=params, errors=errors)
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index f0f0d60c..6ccb2e80 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -36,7 +36,8 @@ def get_user_session():
 def set_user_session(response):
     if hasattr(g, 'user_session'):
         if not request.cookies.get(g.user_session.cookie_name):
-            response.set_cookie(g.user_session.cookie_name, g.user_session.cookie)
+            response.set_cookie(g.user_session.cookie_name,
+                                g.user_session.cookie)
     return response
 
 
@@ -44,7 +45,8 @@ def verify_cookie(cookie):
     the_uuid, separator, the_signature = cookie.partition(':')
     assert len(the_uuid) == 36, "Is session_id a uuid?"
     assert separator == ":", "Expected a : here"
-    assert the_signature == hmac.hmac_creation(the_uuid), "Uh-oh, someone tampering with the cookie?"
+    assert the_signature == hmac.hmac_creation(
+        the_uuid), "Uh-oh, someone tampering with the cookie?"
     return the_uuid
 
 
@@ -60,9 +62,11 @@ def create_signed_cookie():
 def manage_user():
     params = request.form if request.form else request.args
     if 'new_full_name' in params:
-        set_user_attribute(g.user_session.user_id, 'full_name', params['new_full_name'])
+        set_user_attribute(g.user_session.user_id,
+                           'full_name', params['new_full_name'])
     if 'new_organization' in params:
-        set_user_attribute(g.user_session.user_id, 'organization', params['new_organization'])
+        set_user_attribute(g.user_session.user_id,
+                           'organization', params['new_organization'])
 
     user_details = get_user_by_unique_column("user_id", g.user_session.user_id)
 
@@ -108,7 +112,8 @@ class UserSession:
 
                 # Grrr...this won't work because of the way flask handles cookies
                 # Delete the cookie
-                flash("Due to inactivity your session has expired. If you'd like please login again.")
+                flash(
+                    "Due to inactivity your session has expired. If you'd like please login again.")
                 return None
             else:
                 self.record = dict(login_time=time.time(),
@@ -178,7 +183,9 @@ class UserSession:
 
         # ZS: Get user's collections if they exist
         collections = get_user_collections(self.user_id)
-        collections = [item for item in collections if item['name'] != "Your Default Collection"] + [item for item in collections if item['name'] == "Your Default Collection"]  # ZS: Ensure Default Collection is last in list
+        collections = [item for item in collections if item['name'] != "Your Default Collection"] + \
+            [item for item in collections if item['name'] ==
+                "Your Default Collection"]  # ZS: Ensure Default Collection is last in list
         return collections
 
     @property
@@ -234,12 +241,14 @@ class UserSession:
         this_collection = self.get_collection_by_id(collection_id)
 
         updated_collection = this_collection
-        current_members_minus_new = [member for member in this_collection['members'] if member not in traits_to_add]
+        current_members_minus_new = [
+            member for member in this_collection['members'] if member not in traits_to_add]
         updated_traits = traits_to_add + current_members_minus_new
 
         updated_collection['members'] = updated_traits
         updated_collection['num_members'] = len(updated_traits)
-        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p')
+        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime(
+            '%b %d %Y %I:%M%p')
 
         updated_collections = []
         for collection in self.user_collections:
@@ -265,7 +274,8 @@ class UserSession:
 
         updated_collection['members'] = updated_traits
         updated_collection['num_members'] = len(updated_traits)
-        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p')
+        updated_collection['changed_timestamp'] = datetime.datetime.utcnow().strftime(
+            '%b %d %Y %I:%M%p')
 
         updated_collections = []
         for collection in self.user_collections:
-- 
cgit v1.2.3


From bd702e59d7a426fe351d34367bf824683c655696 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 12:52:55 +0300
Subject: autopep8: Fix W291, W292, W293, W391

---
 wqflask/base/mrna_assay_tissue_data.py             |  2 +-
 wqflask/maintenance/convert_dryad_to_bimbam.py     |  2 +-
 wqflask/maintenance/convert_geno_to_bimbam.py      |  4 +--
 .../maintenance/generate_kinship_from_bimbam.py    |  8 ++---
 wqflask/maintenance/geno_to_json.py                | 34 +++++++++---------
 wqflask/tests/unit/wqflask/api/test_correlation.py |  4 +--
 .../correlation/test_correlation_functions.py      |  2 +-
 .../marker_regression/test_qtlreaper_mapping.py    |  4 +--
 .../wqflask/marker_regression/test_rqtl_mapping.py |  7 ----
 .../unit/wqflask/snp_browser/test_snp_browser.py   |  8 ++---
 wqflask/tests/unit/wqflask/test_server_side.py     |  4 +--
 wqflask/utility/__init__.py                        |  2 --
 wqflask/utility/genofile_parser.py                 |  1 -
 wqflask/wqflask/__init__.py                        |  2 +-
 wqflask/wqflask/api/mapping.py                     |  2 --
 wqflask/wqflask/api/router.py                      | 14 ++++----
 wqflask/wqflask/collect.py                         |  1 -
 .../comparison_bar_chart/comparison_bar_chart.py   |  7 ++--
 wqflask/wqflask/correlation/corr_scatter_plot.py   |  4 +--
 wqflask/wqflask/correlation/show_corr_results.py   |  1 -
 .../wqflask/correlation_matrix/show_corr_matrix.py |  2 +-
 wqflask/wqflask/ctl/ctl_analysis.py                |  3 +-
 wqflask/wqflask/db_info.py                         |  2 --
 wqflask/wqflask/docs.py                            |  2 +-
 wqflask/wqflask/export_traits.py                   |  4 +--
 .../wqflask/external_tools/send_to_webgestalt.py   |  2 +-
 wqflask/wqflask/heatmap/heatmap.py                 |  2 +-
 wqflask/wqflask/interval_analyst/GeneUtil.py       | 24 ++++++-------
 .../wqflask/marker_regression/qtlreaper_mapping.py | 10 +++---
 wqflask/wqflask/marker_regression/rqtl_mapping.py  |  2 +-
 wqflask/wqflask/resource_manager.py                |  2 +-
 wqflask/wqflask/search_results.py                  |  1 -
 wqflask/wqflask/server_side.py                     |  2 +-
 wqflask/wqflask/snp_browser/snp_browser.py         |  7 ++--
 wqflask/wqflask/user_login.py                      | 42 +++++++++++-----------
 wqflask/wqflask/user_session.py                    |  2 --
 36 files changed, 98 insertions(+), 124 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/mrna_assay_tissue_data.py b/wqflask/base/mrna_assay_tissue_data.py
index 9bb29664..882ae911 100644
--- a/wqflask/base/mrna_assay_tissue_data.py
+++ b/wqflask/base/mrna_assay_tissue_data.py
@@ -74,7 +74,7 @@ class MrnaAssayTissueData:
 
     def get_symbol_values_pairs(self):
         id_list = [self.data[symbol].data_id for symbol in self.data]
-        
+
         symbol_values_dict = {}
 
         if len(id_list) > 0:
diff --git a/wqflask/maintenance/convert_dryad_to_bimbam.py b/wqflask/maintenance/convert_dryad_to_bimbam.py
index e417c280..18fbb8a1 100644
--- a/wqflask/maintenance/convert_dryad_to_bimbam.py
+++ b/wqflask/maintenance/convert_dryad_to_bimbam.py
@@ -52,7 +52,7 @@ def read_dryad_file(filename):
     #                this_row.append(line.split(" ")[i+2])
     #        print("row: " + str(i))
     #        geno_rows.append(this_row)
-    #            
+    #
     # return geno_rows
 
 
diff --git a/wqflask/maintenance/convert_geno_to_bimbam.py b/wqflask/maintenance/convert_geno_to_bimbam.py
index a2ede1f9..c5af1ca6 100644
--- a/wqflask/maintenance/convert_geno_to_bimbam.py
+++ b/wqflask/maintenance/convert_geno_to_bimbam.py
@@ -91,7 +91,7 @@ class ConvertGenoFile:
 
             self.markers.append(this_marker.__dict__)
 
-        self.write_to_bimbam()    
+        self.write_to_bimbam()
 
     def write_to_bimbam(self):
         with open(self.output_files[0], "w") as geno_fh:
@@ -126,7 +126,7 @@ class ConvertGenoFile:
                 self.sample_list = row_contents[3:]
             else:
                 self.sample_list = row_contents[2:]
-    
+
     def process_rows(self):
         for self.latest_row_pos, row in enumerate(self.input_fh):
             self.latest_row_value = row
diff --git a/wqflask/maintenance/generate_kinship_from_bimbam.py b/wqflask/maintenance/generate_kinship_from_bimbam.py
index bed634fa..cd39fceb 100644
--- a/wqflask/maintenance/generate_kinship_from_bimbam.py
+++ b/wqflask/maintenance/generate_kinship_from_bimbam.py
@@ -19,7 +19,7 @@ class GenerateKinshipMatrices:
         self.group_name = group_name
         self.geno_file = geno_file
         self.pheno_file = pheno_file
-    
+
     def generate_kinship(self):
         gemma_command = "/gnu/store/xhzgjr0jvakxv6h3blj8z496xjig69b0-profile/bin/gemma -g " + self.geno_file + \
             " -p " + self.pheno_file + \
@@ -56,11 +56,11 @@ class GenerateKinshipMatrices:
                 print("    Column is:", convertob.latest_col_value)
                 print("    Row is:", convertob.latest_row_value)
                 break
-    
-    
+
+
 if __name__ == "__main__":
     Geno_Directory = """/export/local/home/zas1024/genotype_files/genotype/"""
     Bimbam_Directory = """/export/local/home/zas1024/genotype_files/genotype/bimbam/"""
     GenerateKinshipMatrices.process_all(Geno_Directory, Bimbam_Directory)
-    
+
     # ./gemma -g /home/zas1024/genotype_files/genotype/bimbam/BXD_geno.txt -p /home/zas1024/genotype_files/genotype/bimbam/BXD_pheno.txt -gk 1 -o BXD
diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index 76a0fc98..27eb6553 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -29,7 +29,7 @@ from pprint import pformat as pf
 class EmptyConfigurations(Exception):
     pass
 
-        
+
 class Marker:
     def __init__(self):
         self.name = None
@@ -42,20 +42,20 @@ class Marker:
 class ConvertGenoFile:
 
     def __init__(self, input_file, output_file):
-        
+
         self.input_file = input_file
         self.output_file = output_file
-        
+
         self.mb_exists = False
         self.cm_exists = False
         self.markers = []
-        
+
         self.latest_row_pos = None
         self.latest_col_pos = None
-        
+
         self.latest_row_value = None
         self.latest_col_value = None
-        
+
     def convert(self):
 
         self.haplotype_notation = {
@@ -64,16 +64,16 @@ class ConvertGenoFile:
             '@het': "0.5",
             '@unk': "NA"
             }
-        
+
         self.configurations = {}
         #self.skipped_cols = 3
-        
+
         # if self.input_file.endswith(".geno.gz"):
         #    print("self.input_file: ", self.input_file)
         #    self.input_fh = gzip.open(self.input_file)
         # else:
         self.input_fh = open(self.input_file)
-        
+
         with open(self.output_file, "w") as self.output_fh:
             # if self.file_type == "geno":
             self.process_csv()
@@ -105,22 +105,22 @@ class ConvertGenoFile:
                         self.configurations[genotype.upper()])
                 else:
                     this_marker.genotypes.append("NA")
-                
-            #print("this_marker is:", pf(this_marker.__dict__))   
+
+            #print("this_marker is:", pf(this_marker.__dict__))
             # if this_marker.chr == "14":
             self.markers.append(this_marker.__dict__)
 
         with open(self.output_file, 'w') as fh:
             json.dump(self.markers, fh, indent="   ", sort_keys=True)
-                
+
                 # print('configurations:', str(configurations))
                 #self.latest_col_pos = item_count + self.skipped_cols
                 #self.latest_col_value = item
-                
+
                 # if item_count != 0:
                 #    self.output_fh.write(" ")
                 # self.output_fh.write(self.configurations[item.upper()])
-                    
+
             # self.output_fh.write("\n")
 
     def process_rows(self):
@@ -176,12 +176,12 @@ class ConvertGenoFile:
                 print("    Column is:", convertob.latest_col_value)
                 print("    Row is:", convertob.latest_row_value)
                 break
-            
+
     # def process_snps_file(cls, snps_file, new_directory):
     #    output_file = os.path.join(new_directory, "mouse_families.json")
     #    print("%s -> %s" % (snps_file, output_file))
     #    convertob = ConvertGenoFile(input_file, output_file)
-        
+
 
 if __name__ == "__main__":
     Old_Geno_Directory = """/export/local/home/zas1024/gn2-zach/genotype_files/genotype"""
@@ -192,5 +192,5 @@ if __name__ == "__main__":
     # convertob.convert()
     ConvertGenoFile.process_all(Old_Geno_Directory, New_Geno_Directory)
     # ConvertGenoFiles(Geno_Directory)
-    
+
     #process_csv(Input_File, Output_File)
diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index bd99838d..34ffa9ef 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -105,9 +105,9 @@ class TestCorrelations(unittest.TestCase):
         target_dataset = AttributeSetter({"group": group})
 
         target_vals = [3.4, 6.2, 4.1, 3.4, 1.2, 5.6]
-        trait_data = {"S1": AttributeSetter({"value": 2.3}), "S2": AttributeSetter({"value": 1.1}), 
+        trait_data = {"S1": AttributeSetter({"value": 2.3}), "S2": AttributeSetter({"value": 1.1}),
         "S3": AttributeSetter(
-            {"value": 6.3}), "S4": AttributeSetter({"value": 3.6}), "S5": AttributeSetter({"value": 4.1}), 
+            {"value": 6.3}), "S4": AttributeSetter({"value": 3.6}), "S5": AttributeSetter({"value": 4.1}),
         "S6": AttributeSetter({"value": 5.0})}
         this_trait = AttributeSetter({"data": trait_data})
         mock_normalize.return_value = ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
index 44d2e0fc..2bbeab1f 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -5,7 +5,7 @@ from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_ti
 
 
 class TestCorrelationFunctions(unittest.TestCase):
-    
+
     @mock.patch("wqflask.correlation.correlation_functions.MrnaAssayTissueData")
     def test_get_trait_symbol_and_tissue_values(self, mock_class):
         """test for getting trait symbol and tissue_values"""
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index c762982b..1198740d 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -8,7 +8,7 @@ from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file
 
 class TestQtlReaperMapping(unittest.TestCase):
 	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
-	def test_gen_pheno_txt_file(self):                   
+	def test_gen_pheno_txt_file(self):
 		vals = ["V1", "x", "V4", "V3","x"]
 		samples = ["S1", "S2", "S3", "S4","S5"]
 		trait_filename = "trait_file"
@@ -21,5 +21,3 @@ class TestQtlReaperMapping(unittest.TestCase):
 				'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
 
 			filehandler.write.assert_has_calls(write_calls)
-
-	                                                                                                                    
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 6996c275..d69a20d3 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -40,10 +40,3 @@ class TestRqtlMapping(unittest.TestCase):
 		expected_sanitized_name = "c('f',NA,'r',NA,NA)"
 		results = sanitize_rqtl_names(vals)
 		self.assertEqual(expected_sanitized_name, results)
-
-
-		
-		
-
-
-
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index ce3e7b83..8823e1fc 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -21,9 +21,9 @@ class TestSnpBrowser(unittest.TestCase):
                          "transcript": "false", "exon": "false", "domain_2": "true", "function": "false", "function_details": "true"}
         strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []}
         expected_results = ([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore',
-                              'Domain 1', 'Domain 2', 'Details'], 
-                              ['S1', 'S2', 'S3', 'S4', 'S5']], 5, 
-                              ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles', 
+                              'Domain 1', 'Domain 2', 'Details'],
+                              ['S1', 'S2', 'S3', 'S4', 'S5']], 5,
+                              ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles',
                               'conservation_score', 'domain_1', 'domain_2',
                               'function_details', 'S1', 'S2', 'S3', 'S4', 'S5'])
 
@@ -33,7 +33,7 @@ class TestSnpBrowser(unittest.TestCase):
             variant_type="InDel", strains=strains, species="rat", empty_columns=[])
         expected_results_with_indel = (
             ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start',
-             'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0, 
+             'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0,
              ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
             'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name'])
 
diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
index 69977146..9d988aea 100644
--- a/wqflask/tests/unit/wqflask/test_server_side.py
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -17,8 +17,8 @@ class TestServerSideTableTests(unittest.TestCase):
     def test_get_page(self):
         rows_count = 3
         table_rows = [
-            {'first': 'd', 'second': 4, 'third': 'zz'}, 
-            {'first': 'b', 'second': 2, 'third': 'aa'}, 
+            {'first': 'd', 'second': 4, 'third': 'zz'},
+            {'first': 'b', 'second': 2, 'third': 'aa'},
             {'first': 'c', 'second': 1, 'third': 'ss'},
         ]
         headers = ['first', 'second', 'third']
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index d540c96e..816bc4df 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -33,5 +33,3 @@ class Struct:
     def __repr__(self):
         return '{%s}' % str(', '.join('%s : %s' % (k, repr(v)) for
             (k, v) in list(self.__dict__.items())))
-
-
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index 09100bd9..c0629b5d 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -98,4 +98,3 @@ class ConvertGenoFile:
           print("WARNING:", genotype.upper())
           this_marker.genotypes.append("NA")
       self.markers.append(this_marker.__dict__)
-
diff --git a/wqflask/wqflask/__init__.py b/wqflask/wqflask/__init__.py
index 712517a3..a2bf3085 100644
--- a/wqflask/wqflask/__init__.py
+++ b/wqflask/wqflask/__init__.py
@@ -50,4 +50,4 @@ from wqflask import db_info
 from wqflask import user_login
 from wqflask import user_session
 
-import wqflask.views 
+import wqflask.views
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index c22b44a9..e4a3fb77 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -140,5 +140,3 @@ def initialize_parameters(start_vars, dataset, this_trait):
             mapping_params['perm_check'] = False
 
     return mapping_params
-
-
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index e7dfa4e0..f7d52ca3 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -59,13 +59,13 @@ def get_species_info(species_name, file_format="json"):
                               WHERE (Name="{0}" OR FullName="{0}" OR SpeciesName="{0}");""".format(species_name))
 
     the_species = results.fetchone()
-    species_dict = { 
+    species_dict = {
       "Id": the_species[0],
       "Name": the_species[1],
       "FullName": the_species[2],
       "TaxonomyId": the_species[3]
     }
-    
+
     return flask.jsonify(species_dict)
 
 
@@ -639,7 +639,7 @@ def trait_sample_data(dataset_name, trait_name, file_format="json"):
 
             return flask.jsonify(sample_list)
         else:
-            return return_error(code=204, source=request.url_rule.rule, title="No Results", details="") 
+            return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
 
 
 @app.route("/api/v_{}/trait/<path:dataset_name>/<path:trait_name>".format(version))
@@ -685,7 +685,7 @@ def get_trait_info(dataset_name, trait_name, file_format="json"):
         # ZS: Check if the user input the dataset_name as BXDPublish, etc (which is always going to be the group name + "Publish"
         if "Publish" in dataset_name:
             dataset_name = dataset_name.replace("Publish", "")
-        
+
         group_id = get_group_id(dataset_name)
         pheno_query = """
                          SELECT
@@ -898,7 +898,7 @@ def get_dataset_trait_ids(dataset_name, start_vars):
         data_type = "Publish"
         dataset_name = dataset_name.replace("Publish", "")
         dataset_id = get_group_id(dataset_name)
-        
+
         query = """
                          SELECT
                              PublishXRef.PhenotypeId, PublishXRef.Id, InbredSet.InbredSetCode
@@ -949,9 +949,9 @@ def get_samplelist(dataset_name):
                WHERE StrainXRef.StrainId = Strain.Id AND
                      StrainXRef.InbredSetId = {}
             """.format(group_id)
-    
+
     results = g.db.execute(query).fetchall()
-    
+
     samplelist = [result[0] for result in results]
 
     return samplelist
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 1fcf15f0..9fd89524 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -239,4 +239,3 @@ def change_collection_name():
     g.user_session.change_collection_name(collection_id, new_name)
 
     return new_name
-
diff --git a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
index 0fabb833..d86c8e16 100644
--- a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
+++ b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
@@ -45,7 +45,7 @@ class ComparisonBarChart:
         # ZS: Getting initial group name before verifying all traits are in the same group in the following loop
         this_group = self.trait_list[0][1].group.name
         for trait_db in self.trait_list:
-            
+
             if trait_db[1].group.name != this_group:
                 self.insufficient_shared_samples = True
                 break
@@ -53,7 +53,7 @@ class ComparisonBarChart:
                 this_group = trait_db[1].group.name
             this_trait = trait_db[0]
             self.traits.append(this_trait)
-            
+
             this_sample_data = this_trait.data
 
             for sample in this_sample_data:
@@ -79,7 +79,7 @@ class ComparisonBarChart:
             self.js_data = dict(traits=[trait.name for trait in self.traits],
                                 samples=self.all_sample_list,
                                 sample_data=self.sample_data,)
-        
+
     def get_trait_db_obs(self, trait_db_list):
 
         self.trait_list = []
@@ -95,4 +95,3 @@ class ComparisonBarChart:
             self.trait_list.append((trait_ob, dataset_ob))
 
         #print("trait_list:", self.trait_list)
-
diff --git a/wqflask/wqflask/correlation/corr_scatter_plot.py b/wqflask/wqflask/correlation/corr_scatter_plot.py
index f9a0ea11..4f756f58 100644
--- a/wqflask/wqflask/correlation/corr_scatter_plot.py
+++ b/wqflask/wqflask/correlation/corr_scatter_plot.py
@@ -68,7 +68,7 @@ class CorrScatterPlot:
             slope_string = '%.3E' % slope
         else:
             slope_string = '%.3f' % slope
-        
+
         x_buffer = (max(vals_1) - min(vals_1)) * 0.1
         y_buffer = (max(vals_2) - min(vals_2)) * 0.1
 
@@ -82,7 +82,7 @@ class CorrScatterPlot:
         ry = stats.rankdata(vals_2)
         self.rdata = []
         self.rdata.append(rx.tolist())
-        self.rdata.append(ry.tolist())        
+        self.rdata.append(ry.tolist())
         srslope, srintercept, srr_value, srp_value, srstd_err = stats.linregress(
             rx, ry)
 
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index e75c4a85..8ee24246 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -680,4 +680,3 @@ def get_header_fields(data_type, corr_method):
                                 'Sample p(r)']
 
     return header_fields
-
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index aefb4453..59469428 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -324,7 +324,7 @@ def sortEigenVectors(vector):
             A.append(item[0])
             B.append(item[1])
         sum = reduce(lambda x, y: x + y, A, 0.0)
-        A = [x * 100.0 / sum for x in A] 
+        A = [x * 100.0 / sum for x in A]
         return [A, B]
     except:
         return []
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index 48a82435..f4eafbe7 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -66,7 +66,7 @@ class CTL:
 
     def addNode(self, gt):
         node_dict = {'data': {'id': str(gt.name) + ":" + str(gt.dataset.name),
-                                'sid': str(gt.name), 
+                                'sid': str(gt.name),
                                 'dataset': str(gt.dataset.name),
                                 'label': gt.name,
                                 'symbol': gt.symbol,
@@ -238,4 +238,3 @@ class CTL:
         self.render_image(self.results)
         sys.stdout.flush()
         return(dict(template_vars))
-
diff --git a/wqflask/wqflask/db_info.py b/wqflask/wqflask/db_info.py
index c7558ed8..8d28fef0 100644
--- a/wqflask/wqflask/db_info.py
+++ b/wqflask/wqflask/db_info.py
@@ -135,5 +135,3 @@ def process_query_results(results):
     }
 
     return info_ob
-
-
diff --git a/wqflask/wqflask/docs.py b/wqflask/wqflask/docs.py
index fc93248a..0a1a597d 100644
--- a/wqflask/wqflask/docs.py
+++ b/wqflask/wqflask/docs.py
@@ -20,7 +20,7 @@ class Docs:
             self.title = self.entry.capitalize()
             self.content = ""
         else:
-            
+
             self.title = result[0]
             self.content = result[1].decode("utf-8")
 
diff --git a/wqflask/wqflask/export_traits.py b/wqflask/wqflask/export_traits.py
index 5bd54f9d..2c180d49 100644
--- a/wqflask/wqflask/export_traits.py
+++ b/wqflask/wqflask/export_traits.py
@@ -1,6 +1,6 @@
 import csv
 import xlsxwriter
-import io 
+import io
 import datetime
 import itertools
 
@@ -20,7 +20,7 @@ def export_search_results_csv(targs):
 
     table_data = json.loads(targs['export_data'])
     table_rows = table_data['rows']
-    
+
     now = datetime.datetime.now()
     time_str = now.strftime('%H:%M_%d%B%Y')
     if 'file_name' in targs:
diff --git a/wqflask/wqflask/external_tools/send_to_webgestalt.py b/wqflask/wqflask/external_tools/send_to_webgestalt.py
index fd12562f..fcd943ba 100644
--- a/wqflask/wqflask/external_tools/send_to_webgestalt.py
+++ b/wqflask/wqflask/external_tools/send_to_webgestalt.py
@@ -48,7 +48,7 @@ class SendToWebGestalt:
 
             id_type = "entrezgene"
 
-            self.hidden_vars = { 
+            self.hidden_vars = {
                              'gene_list': "\n".join(gene_id_list),
                              'id_type': "entrezgene",
                              'ref_set': "genome",
diff --git a/wqflask/wqflask/heatmap/heatmap.py b/wqflask/wqflask/heatmap/heatmap.py
index aa11caa8..02eb66e5 100644
--- a/wqflask/wqflask/heatmap/heatmap.py
+++ b/wqflask/wqflask/heatmap/heatmap.py
@@ -125,7 +125,7 @@ class Heatmap:
                                                                                                                     webqtlConfig.GENERATED_IMAGE_DIR,
                                                                                                                     output_filename)
 
-            os.system(reaper_command)                                                                                                        
+            os.system(reaper_command)
 
             reaper_results = parse_reaper_output(output_filename)
 
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index cadff080..e624a146 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -10,7 +10,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 	fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
 	'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
 	'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
-	
+
 	# List All Species in the Gene Table
 	speciesDict = {}
 	results = g.db.execute("""
@@ -21,7 +21,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 
 	for item in results:
 		speciesDict[item[0]] = item[1]
-	
+
 	# List current Species and other Species
 	speciesId = speciesDict[species]
 	otherSpecies = [[X, speciesDict[X]] for X in list(speciesDict.keys())]
@@ -45,7 +45,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 			newdict = {}
 			for j, item in enumerate(fetchFields):
 				newdict[item] = result[j]
-			# count SNPs if possible	
+			# count SNPs if possible
 			if diffCol and species == 'mouse':
 				newdict["snpCount"] = g.db.execute("""
                                         SELECT count(*)
@@ -58,17 +58,17 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 					(newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
 			else:
 				newdict["snpDensity"] = newdict["snpCount"] = 0
-			
+
 			try:
 				newdict['GeneLength'] = 1000.0 * (newdict['TxEnd'] - newdict['TxStart'])
 			except:
 				pass
-			
+
 			# load gene from other Species by the same name
 			for item in otherSpecies:
 				othSpec, othSpecId = item
 				newdict2 = {}
-				
+
 				resultsOther = g.db.execute("SELECT %s FROM GeneList WHERE SpeciesId = %d AND geneSymbol= '%s' LIMIT 1" % (", ".join(fetchFields),
                                                                                                                            othSpecId,
                                                                                                                            newdict["GeneSymbol"])).fetchone()
@@ -76,8 +76,8 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 				if resultsOther:
 					for j, item in enumerate(fetchFields):
 						newdict2[item] = resultsOther[j]
-							
-					# count SNPs if possible, could be a separate function	
+
+					# count SNPs if possible, could be a separate function
 					if diffCol and othSpec == 'mouse':
 						newdict2["snpCount"] = g.db.execute("""
                                                     SELECT count(*)
@@ -91,17 +91,15 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 							(newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
 					else:
 						newdict2["snpDensity"] = newdict2["snpCount"] = 0
-						
+
 					try:
 						newdict2['GeneLength'] = 1000.0 * \
 							(newdict2['TxEnd'] - newdict2['TxStart'])
 					except:
 						pass
-						
+
 				newdict['%sGene' % othSpec] = newdict2
-				
+
 			GeneList.append(newdict)
 
 	return GeneList
-
-
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index f932498f..c51b7a9a 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -34,7 +34,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
 
         opt_list = []
         if boot_check and num_bootstrap > 0:
-            bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_" + 
+            bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_" +
                 ''.join(random.choice(string.ascii_uppercase + string.digits)
                         for _ in range(6))
                 )
@@ -44,8 +44,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             opt_list.append(
                 f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
         if num_perm > 0:
-            permu_filename = ("{this_dataset.group.name}_PERM_" + 
-            ''.join(random.choice(string.ascii_uppercase + 
+            permu_filename = ("{this_dataset.group.name}_PERM_" +
+            ''.join(random.choice(string.ascii_uppercase +
                 string.digits) for _ in range(6))
             )
             opt_list.append("-n " + str(num_perm))
@@ -56,7 +56,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         if manhattan_plot != True:
             opt_list.append("--interval 1")
 
-        reaper_command = (REAPER_COMMAND + 
+        reaper_command = (REAPER_COMMAND +
         ' --geno {0}/{1}.geno --traits {2}/gn2/{3}.txt {4} -o {5}{6}.txt'.format(flat_files('genotype'),
 
                                                                               genofile_name,
@@ -81,7 +81,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         suggestive = permu_vals[int(num_perm * 0.37 - 1)]
         significant = permu_vals[int(num_perm * 0.95 - 1)]
 
-    return (marker_obs, permu_vals, suggestive, significant, bootstrap_vals, 
+    return (marker_obs, permu_vals, suggestive, significant, bootstrap_vals,
         [output_filename, permu_filename, bootstrap_filename])
 
 
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index 741d6c23..b3c9fddf 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -300,7 +300,7 @@ def add_categorical_covar(cross, covar_as_string, i):
       ro.r('the_cross$pheno <- cbind(pheno, ' + \
            col_name + ' = newcovar[,' + str(x) + '])')
       col_names.append(col_name)
-      #logger.info("loop" + str(x) + "done"); 
+      #logger.info("loop" + str(x) + "done");
 
     logger.info("returning from add_categorical_covar")
     return ro.r["the_cross"], col_names
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index 36d4cd61..61f3b202 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -142,5 +142,5 @@ def get_group_names(group_masks):
         group_name = get_group_info(group_id)['name']
         this_mask['name'] = group_name
         group_masks_with_names[group_id] = this_mask
-    
+
     return group_masks_with_names
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index 273a97a4..0d2fb2f8 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -343,4 +343,3 @@ def get_aliases(symbol_list, species):
         search_terms.append(the_search_term)
 
     return search_terms
-
diff --git a/wqflask/wqflask/server_side.py b/wqflask/wqflask/server_side.py
index 8b3a4faa..8ca3a9eb 100644
--- a/wqflask/wqflask/server_side.py
+++ b/wqflask/wqflask/server_side.py
@@ -30,7 +30,7 @@ class ServerSideTable:
         self.rows_count = rows_count
         self.table_rows = table_rows
         self.header_data_names = header_data_names
-        
+
         self.sort_rows()
         self.paginate_rows()
 
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index e98cfb71..5b7a663c 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -494,10 +494,10 @@ class SnpBrowser:
                         function_details = function_details + ", Coding Region Unknown"
 
                     self.empty_columns['function_details'] = "true"
-                    
+
                 #[snp_href, chr, mb_formatted, alleles, snp_source_cell, conservation_score, gene_name_cell, transcript_href, exon, domain_1, domain_2, function, function_details]
 
-                base_color_dict = {"A": "#C33232", "C": "#1569C7", "T": "#CFCF32", "G": "#32C332", 
+                base_color_dict = {"A": "#C33232", "C": "#1569C7", "T": "#CFCF32", "G": "#32C332",
                                    "t": "#FF6", "c": "#5CB3FF", "a": "#F66", "g": "#CF9", ":": "#FFFFFF", "-": "#FFFFFF", "?": "#FFFFFF"}
 
                 the_bases = []
@@ -735,7 +735,7 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
             if empty_columns['function_details'] == "false":
                 empty_field_count += 1
                 header_fields[0].remove('Details')
-        
+
         for col in empty_columns.keys():
             if empty_columns[col] == "false":
                 header_data_names.remove(col)
@@ -952,4 +952,3 @@ def check_if_in_gene(species_id, chr, mb):
         return [result[0], result[1]]
     else:
         return ""
-
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index 708d43d2..bfaed9c2 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -45,10 +45,10 @@ def encode_password(pass_gen_fields, unencrypted_password):
         salt = pass_gen_fields['salt']
     else:
         salt = bytes(pass_gen_fields['salt'], "utf-8")
-    encrypted_password = pbkdf2.pbkdf2_hex(str(unencrypted_password), 
+    encrypted_password = pbkdf2.pbkdf2_hex(str(unencrypted_password),
                                            salt,
-                                           pass_gen_fields['iterations'], 
-                                           pass_gen_fields['keylength'], 
+                                           pass_gen_fields['iterations'],
+                                           pass_gen_fields['keylength'],
                                            pass_gen_fields['hashfunc'])
 
     pass_gen_fields.pop("unencrypted_password", None)
@@ -111,7 +111,7 @@ def get_signed_session_id(user):
     key = UserSession.user_cookie_name + ":" + session_id
     Redis.hmset(key, session)
     Redis.expire(key, THREE_DAYS)
-    
+
     return session_id_signed
 
 
@@ -207,7 +207,7 @@ def login():
                     UserSession.user_cookie_name, session_id_signed, max_age=None)
             else:
                 flash("Something went unexpectedly wrong.", "alert-danger")
-                response = make_response(redirect(url_for('index_page')))  
+                response = make_response(redirect(url_for('index_page')))
             return response
         else:
             user_details = get_user_by_unique_column(
@@ -276,13 +276,13 @@ def github_oauth2():
     user_details = get_user_by_unique_column("github_id", github_user["id"])
     if user_details == None:
         user_details = {
-            "user_id": str(uuid.uuid4()), 
-            "name": github_user["name"].encode("utf-8") if github_user["name"] else "None", 
+            "user_id": str(uuid.uuid4()),
+            "name": github_user["name"].encode("utf-8") if github_user["name"] else "None",
             "github_id": github_user["id"],
-            "user_url": github_user["html_url"].encode("utf-8"), 
-            "login_type": "github", 
-            "organization": "", 
-            "active": 1, 
+            "user_url": github_user["html_url"].encode("utf-8"),
+            "login_type": "github",
+            "organization": "",
+            "active": 1,
             "confirmed": 1
         }
         save_user(user_details, user_details["user_id"])
@@ -308,8 +308,8 @@ def orcid_oauth2():
     url = "/n/login"
     if code:
         data = {
-            "client_id": ORCID_CLIENT_ID, 
-            "client_secret": ORCID_CLIENT_SECRET, 
+            "client_id": ORCID_CLIENT_ID,
+            "client_secret": ORCID_CLIENT_SECRET,
             "grant_type": "authorization_code",
             "redirect_uri": GN2_BRANCH_URL + "n/login/orcid_oauth2",
             "code": code
@@ -321,13 +321,13 @@ def orcid_oauth2():
         user_details = get_user_by_unique_column("orcid", result_dict["orcid"])
         if user_details == None:
             user_details = {
-                "user_id": str(uuid4()), 
-                "name": result_dict["name"], 
-                "orcid": result_dict["orcid"], 
-                "user_url": "%s/%s" % ("/".join(ORCID_AUTH_URL.split("/")[:-2]), result_dict["orcid"]), 
-                "login_type": "orcid", 
-                "organization": "", 
-                "active": 1, 
+                "user_id": str(uuid4()),
+                "name": result_dict["name"],
+                "orcid": result_dict["orcid"],
+                "user_url": "%s/%s" % ("/".join(ORCID_AUTH_URL.split("/")[:-2]), result_dict["orcid"]),
+                "login_type": "orcid",
+                "organization": "",
+                "active": 1,
                 "confirmed": 1
             }
             save_user(user_details, user_details["user_id"])
@@ -374,7 +374,7 @@ def send_forgot_password_email(verification_email):
     key_prefix = "forgot_password_code"
     subject = "GeneNetwork password reset"
     fromaddr = "no-reply@genenetwork.org"
-    
+
     verification_code = str(uuid.uuid4())
     key = key_prefix + ":" + verification_code
 
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index 6ccb2e80..963288b3 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -318,5 +318,3 @@ class UserSession:
         # And more importantly delete the redis record
         Redis.delete(self.redis_key)
         self.logged_in = False
-
-
-- 
cgit v1.2.3


From 90ec57905c8afdbd5e9e8c44dcc369bd0e9c2d1b Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 13:01:02 +0300
Subject: autopep8: Fix W504

---
 wqflask/base/GeneralObject.py                      |  4 +-
 wqflask/base/data_set.py                           |  4 +-
 wqflask/base/trait.py                              | 10 ++--
 .../maintenance/generate_probesetfreeze_file.py    |  7 ++-
 wqflask/tests/unit/base/test_data_set.py           | 10 ++--
 wqflask/tests/unit/wqflask/api/test_gen_menu.py    | 68 +++++++++++-----------
 wqflask/utility/svg.py                             | 24 ++++----
 wqflask/wqflask/api/gen_menu.py                    | 10 ++--
 wqflask/wqflask/correlation/show_corr_results.py   | 10 ++--
 wqflask/wqflask/db_info.py                         | 34 +++++------
 wqflask/wqflask/do_search.py                       | 12 ++--
 .../wqflask/marker_regression/qtlreaper_mapping.py | 14 ++---
 wqflask/wqflask/show_trait/SampleList.py           |  4 +-
 wqflask/wqflask/show_trait/show_trait.py           |  4 +-
 wqflask/wqflask/user_session.py                    |  4 +-
 wqflask/wqflask/views.py                           | 12 ++--
 16 files changed, 116 insertions(+), 115 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/GeneralObject.py b/wqflask/base/GeneralObject.py
index 249195e2..ce8e60b8 100644
--- a/wqflask/base/GeneralObject.py
+++ b/wqflask/base/GeneralObject.py
@@ -62,5 +62,5 @@ class GeneralObject:
         return s
 
     def __eq__(self, other):
-        return (len(list(self.__dict__.keys())) ==
-                len(list(other.__dict__.keys())))
+        return (len(list(self.__dict__.keys()))
+                == len(list(other.__dict__.keys())))
diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 8ec0aaad..5eac695e 100644
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -1032,8 +1032,8 @@ class MrnaAssayDataSet(DataSet):
             else:
                 description_display = this_trait.symbol
 
-            if (len(description_display) > 1 and description_display != 'N/A' and
-                    len(target_string) > 1 and target_string != 'None'):
+            if (len(description_display) > 1 and description_display != 'N/A'
+                    and len(target_string) > 1 and target_string != 'None'):
                 description_display = description_display + '; ' + target_string.strip()
 
             # Save it for the jinja2 template
diff --git a/wqflask/base/trait.py b/wqflask/base/trait.py
index 5574128d..d09cfd40 100644
--- a/wqflask/base/trait.py
+++ b/wqflask/base/trait.py
@@ -479,9 +479,9 @@ def retrieve_trait_info(trait, dataset, get_qtl_info=False):
             else:
                 description_display = trait.symbol
 
-            if (str(description_display or "") != "" and
-                description_display != 'N/A' and
-                    str(target_string or "") != "" and target_string != 'None'):
+            if (str(description_display or "") != ""
+                and description_display != 'N/A'
+                    and str(target_string or "") != "" and target_string != 'None'):
                 description_display = description_display + '; ' + target_string.strip()
 
             # Save it for the jinja2 template
@@ -575,6 +575,6 @@ def retrieve_trait_info(trait, dataset, get_qtl_info=False):
                 if str(trait.lrs or "") != "":
                     trait.LRS_score_repr = LRS_score_repr = '%3.1f' % trait.lrs
     else:
-        raise KeyError(repr(trait.name) +
-                       ' information is not found in the database.')
+        raise KeyError(repr(trait.name)
+                       + ' information is not found in the database.')
     return trait
diff --git a/wqflask/maintenance/generate_probesetfreeze_file.py b/wqflask/maintenance/generate_probesetfreeze_file.py
index bd9c2ab4..e964c8ed 100644
--- a/wqflask/maintenance/generate_probesetfreeze_file.py
+++ b/wqflask/maintenance/generate_probesetfreeze_file.py
@@ -110,9 +110,10 @@ def write_data_matrix_file(strains, probeset_vals, filename):
 
 
 def main():
-    filename = os.path.expanduser("~/gene/wqflask/maintenance/" +
-                "ProbeSetFreezeId_210_FullName_Eye_AXBXA_Illumina_V6.2" +
-                "(Oct08)_RankInv_Beta.txt")
+    filename = os.path.expanduser(
+        "~/gene/wqflask/maintenance/"
+        "ProbeSetFreezeId_210_FullName_Eye_AXBXA_Illumina_V6.2"
+        "(Oct08)_RankInv_Beta.txt")
     dataset_name = "Eye_AXBXA_1008_RankInv"
 
     cursor = get_cursor()
diff --git a/wqflask/tests/unit/base/test_data_set.py b/wqflask/tests/unit/base/test_data_set.py
index ee5d6f06..66ad361d 100644
--- a/wqflask/tests/unit/base/test_data_set.py
+++ b/wqflask/tests/unit/base/test_data_set.py
@@ -88,8 +88,8 @@ class TestDataSetTypes(unittest.TestCase):
                  '"B139_K_1206_R": "ProbeSet", '
                  '"Test": "ProbeSet"}'))
             db_mock.db.execute.assert_called_once_with(
-                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze " +
-                 "WHERE ProbeSetFreeze.Name = \"Test\" ")
+                ("SELECT ProbeSetFreeze.Id FROM ProbeSetFreeze "
+                 + "WHERE ProbeSetFreeze.Name = \"Test\" ")
             )
 
     @mock.patch('base.data_set.g')
@@ -145,9 +145,9 @@ class TestDataSetTypes(unittest.TestCase):
                  '"Test": "Publish"}'))
 
             db_mock.db.execute.assert_called_with(
-                ("SELECT PublishFreeze.Name " +
-                 "FROM PublishFreeze, InbredSet " +
-                 "WHERE InbredSet.Name = 'Test' AND "
+                ("SELECT PublishFreeze.Name "
+                 + "FROM PublishFreeze, InbredSet "
+                 + "WHERE InbredSet.Name = 'Test' AND "
                  "PublishFreeze.InbredSetId = InbredSet.Id")
             )
 
diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index 57eb1650..fd0fe52e 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -105,13 +105,13 @@ class TestGenMenu(unittest.TestCase):
         for name in ["mouse", "human"]:
             db_mock.db.execute.assert_any_call(
                 ("SELECT InbredSet.Name, InbredSet.FullName, " +
-                 "IFNULL(InbredSet.Family, 'None') " +
-                 "FROM InbredSet, Species WHERE Species.Name " +
-                 "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by " +
-                 "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, " +
-                 "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, " +
-                 "InbredSet.FullName) ASC, InbredSet.FullName ASC, " +
-                 "InbredSet.MenuOrderId ASC").format(name)
+                 "IFNULL(InbredSet.Family, 'None') "
+                 + "FROM InbredSet, Species WHERE Species.Name "
+                 + "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by "
+                 + "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, "
+                 + "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, "
+                 + "InbredSet.FullName) ASC, InbredSet.FullName ASC, "
+                 + "InbredSet.MenuOrderId ASC").format(name)
             )
 
     @mock.patch('wqflask.api.gen_menu.g')
@@ -172,12 +172,12 @@ class TestGenMenu(unittest.TestCase):
         self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
                          [['602', "BXDPublish", "BXD Published Phenotypes"]])
         db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, " +
-            "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, " +
-            "InbredSet WHERE InbredSet.Name = 'BXD' AND " +
-            "PublishFreeze.InbredSetId = InbredSet.Id AND " +
-            "InfoFiles.InfoPageName = PublishFreeze.Name " +
-            "ORDER BY PublishFreeze.CreateTime ASC"
+            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, "
+            + "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, "
+            + "InbredSet WHERE InbredSet.Name = 'BXD' AND "
+            + "PublishFreeze.InbredSetId = InbredSet.Id AND "
+            + "InfoFiles.InfoPageName = PublishFreeze.Name "
+            + "ORDER BY PublishFreeze.CreateTime ASC"
         )
         self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
                          [['602', "BXDPublish", "Mouse Phenome Database"]])
@@ -221,8 +221,8 @@ class TestGenMenu(unittest.TestCase):
             "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
             "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
             "GenoFreeze.InbredSetId = InbredSet.Id AND "
-            "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
-            "ORDER BY GenoFreeze.CreateTime DESC"
+            "InfoFiles.InfoPageName = GenoFreeze.ShortName "
+            + "ORDER BY GenoFreeze.CreateTime DESC"
         )
         db_mock.db.execute.return_value.fetchone.return_value = ()
         self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
@@ -239,16 +239,16 @@ class TestGenMenu(unittest.TestCase):
             "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
         ]])
         db_mock.db.execute.assert_called_once_with(
-            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, " +
-            "ProbeSetFreeze.FullName FROM ProbeSetFreeze, " +
-            "ProbeFreeze, InbredSet, Tissue, Species WHERE " +
-            "Species.Name = 'Mouse' AND Species.Id = " +
-            "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND " +
-            "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = " +
-            "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND " +
-            "ProbeSetFreeze.public > 0 " +
-            "ORDER BY -ProbeSetFreeze.OrderList DESC, ProbeSetFreeze.CreateTime DESC")
+            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
+            + "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
+            + "ProbeFreeze, InbredSet, Tissue, Species WHERE "
+            + "Species.Name = 'Mouse' AND Species.Id = "
+            + "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND "
+            + "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND "
+            + "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = "
+            + "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND "
+            + "ProbeSetFreeze.public > 0 "
+            + "ORDER BY -ProbeSetFreeze.OrderList DESC, ProbeSetFreeze.CreateTime DESC")
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
     @mock.patch('wqflask.api.gen_menu.g')
@@ -266,15 +266,15 @@ class TestGenMenu(unittest.TestCase):
                           ['H', 'H', 'Molecular Traits'],
                           ['R', 'R', 'Molecular Traits']])
         db_mock.db.execute.assert_called_once_with(
-            "SELECT DISTINCT Tissue.Name " +
-            "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, " +
-            "Tissue, Species WHERE Species.Name = 'mouse' " +
-            "AND Species.Id = InbredSet.SpeciesId AND " +
-            "InbredSet.Name = 'random group' AND " +
-            "ProbeFreeze.TissueId = Tissue.Id AND " +
-            "ProbeFreeze.InbredSetId = InbredSet.Id AND " +
-            "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id " +
-            "ORDER BY Tissue.Name"
+            "SELECT DISTINCT Tissue.Name "
+            + "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, "
+            + "Tissue, Species WHERE Species.Name = 'mouse' "
+            + "AND Species.Id = InbredSet.SpeciesId AND "
+            + "InbredSet.Name = 'random group' AND "
+            + "ProbeFreeze.TissueId = Tissue.Id AND "
+            + "ProbeFreeze.InbredSetId = InbredSet.Id AND "
+            + "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
+            + "ORDER BY Tissue.Name"
         )
 
     @mock.patch('wqflask.api.gen_menu.build_types')
diff --git a/wqflask/utility/svg.py b/wqflask/utility/svg.py
index 8d2e13ab..bc3bc833 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -229,13 +229,13 @@ class pathdata:
 
     def bezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy absolut"""
-        self.path.append('C' + str(x1) + ','+str(y1)+' '+str(x2) +
-                         ',' + str(y2) + ' '+str(x)+','+str(y))
+        self.path.append('C' + str(x1) + ','+str(y1)+' '+str(x2)
+                         + ',' + str(y2) + ' '+str(x)+','+str(y))
 
     def relbezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy relative"""
-        self.path.append('c' + str(x1) + ','+str(y1)+' '+str(x2) +
-                         ',' + str(y2) + ' '+str(x)+','+str(y))
+        self.path.append('c' + str(x1) + ','+str(y1)+' '+str(x2)
+                         + ',' + str(y2) + ' '+str(x)+','+str(y))
 
     def smbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy absolut"""
@@ -267,13 +267,13 @@ class pathdata:
 
     def ellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy absolut"""
-        self.path.append('A' + str(rx) + ','+str(ry)+' '+str(xrot) +
-                         ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('A' + str(rx) + ','+str(ry)+' '+str(xrot)
+                         + ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
 
     def relellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy relative"""
-        self.path.append('a' + str(rx) + ','+str(ry)+' '+str(xrot) +
-                         ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('a' + str(rx) + ','+str(ry)+' '+str(xrot)
+                         + ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
 
     def __repr__(self):
         return ' '.join(self.path)
@@ -319,11 +319,11 @@ class SVGelement:
         f.write('\t' * level)
         f.write('<' + self.type)
         for attkey in list(self.attributes.keys()):
-            f.write(' ' + _escape(str(attkey)) + '=' +
-                    _quoteattr(str(self.attributes[attkey])))
+            f.write(' ' + _escape(str(attkey)) + '='
+                    + _quoteattr(str(self.attributes[attkey])))
         if self.namespace:
-            f.write(' xmlns="' + _escape(str(self.namespace)) +
-                    '" xmlns:xlink="http://www.w3.org/1999/xlink"')
+            f.write(' xmlns="' + _escape(str(self.namespace))
+                    + '" xmlns:xlink="http://www.w3.org/1999/xlink"')
         if self.elements or self.text or self.cdata:
             f.write('>')
         if self.elements:
diff --git a/wqflask/wqflask/api/gen_menu.py b/wqflask/wqflask/api/gen_menu.py
index a64524dd..e65b36e4 100644
--- a/wqflask/wqflask/api/gen_menu.py
+++ b/wqflask/wqflask/api/gen_menu.py
@@ -179,11 +179,11 @@ def build_datasets(species, group, type_name):
     elif type_name == "Genotypes":
         results = g.db.execute(
             ("SELECT InfoFiles.GN_AccesionId " +
-             "FROM InfoFiles, GenoFreeze, InbredSet " +
-             "WHERE InbredSet.Name = '{}' AND " +
-             "GenoFreeze.InbredSetId = InbredSet.Id AND " +
-             "InfoFiles.InfoPageName = GenoFreeze.ShortName " +
-             "ORDER BY GenoFreeze.CreateTime DESC").format(group)).fetchone()
+             "FROM InfoFiles, GenoFreeze, InbredSet "
+             + "WHERE InbredSet.Name = '{}' AND "
+             + "GenoFreeze.InbredSetId = InbredSet.Id AND "
+             + "InfoFiles.InfoPageName = GenoFreeze.ShortName "
+             + "ORDER BY GenoFreeze.CreateTime DESC").format(group)).fetchone()
 
         dataset_id = "None"
         if bool(results):
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index 8ee24246..e8b7b057 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -96,9 +96,9 @@ class CorrelationResults:
             self.p_range_lower = get_float(start_vars, 'p_range_lower', -1.0)
             self.p_range_upper = get_float(start_vars, 'p_range_upper', 1.0)
 
-            if ('loc_chr' in start_vars and
-                'min_loc_mb' in start_vars and
-                'max_loc_mb' in start_vars):
+            if ('loc_chr' in start_vars
+                and 'min_loc_mb' in start_vars
+                and 'max_loc_mb' in start_vars):
 
                 self.location_type = get_string(start_vars, 'location_type')
                 self.location_chr = get_string(start_vars, 'loc_chr')
@@ -200,8 +200,8 @@ class CorrelationResults:
                         if chr_info.name == trait_object.chr:
                             chr_as_int = order_id
 
-                if (float(self.correlation_data[trait][0]) >= self.p_range_lower and
-                    float(self.correlation_data[trait][0]) <= self.p_range_upper):
+                if (float(self.correlation_data[trait][0]) >= self.p_range_lower
+                    and float(self.correlation_data[trait][0]) <= self.p_range_upper):
 
                     if (self.target_dataset.type == "ProbeSet" or self.target_dataset.type == "Publish") and bool(trait_object.mean):
                         if (self.min_expr != None) and (float(trait_object.mean) < self.min_expr):
diff --git a/wqflask/wqflask/db_info.py b/wqflask/wqflask/db_info.py
index 8d28fef0..938c453e 100644
--- a/wqflask/wqflask/db_info.py
+++ b/wqflask/wqflask/db_info.py
@@ -23,23 +23,23 @@ class InfoPage:
 
     def get_info(self, create=False):
         query_base = ("SELECT InfoPageName, GN_AccesionId, Species.MenuName, Species.TaxonomyId, Tissue.Name, InbredSet.Name, " +
-                      "GeneChip.GeneChipName, GeneChip.GeoPlatform, AvgMethod.Name, Datasets.DatasetName, Datasets.GeoSeries, " +
-                      "Datasets.PublicationTitle, DatasetStatus.DatasetStatusName, Datasets.Summary, Datasets.AboutCases, " +
-                      "Datasets.AboutTissue, Datasets.AboutDataProcessing, Datasets.Acknowledgment, Datasets.ExperimentDesign, " +
-                      "Datasets.Contributors, Datasets.Citation, Datasets.Notes, Investigators.FirstName, Investigators.LastName, " +
-                      "Investigators.Address, Investigators.City, Investigators.State, Investigators.ZipCode, Investigators.Country, " +
-                      "Investigators.Phone, Investigators.Email, Investigators.Url, Organizations.OrganizationName, " +
-                      "InvestigatorId, DatasetId, DatasetStatusId, Datasets.AboutPlatform, InfoFileTitle, Specifics " +
-                      "FROM InfoFiles " +
-                      "LEFT JOIN Species USING (SpeciesId) " +
-                      "LEFT JOIN Tissue USING (TissueId) " +
-                      "LEFT JOIN InbredSet USING (InbredSetId) " +
-                      "LEFT JOIN GeneChip USING (GeneChipId) " +
-                      "LEFT JOIN AvgMethod USING (AvgMethodId) " +
-                      "LEFT JOIN Datasets USING (DatasetId) " +
-                      "LEFT JOIN Investigators USING (InvestigatorId) " +
-                      "LEFT JOIN Organizations USING (OrganizationId) " +
-                      "LEFT JOIN DatasetStatus USING (DatasetStatusId) WHERE ")
+                      "GeneChip.GeneChipName, GeneChip.GeoPlatform, AvgMethod.Name, Datasets.DatasetName, Datasets.GeoSeries, "
+                      + "Datasets.PublicationTitle, DatasetStatus.DatasetStatusName, Datasets.Summary, Datasets.AboutCases, "
+                      + "Datasets.AboutTissue, Datasets.AboutDataProcessing, Datasets.Acknowledgment, Datasets.ExperimentDesign, "
+                      + "Datasets.Contributors, Datasets.Citation, Datasets.Notes, Investigators.FirstName, Investigators.LastName, "
+                      + "Investigators.Address, Investigators.City, Investigators.State, Investigators.ZipCode, Investigators.Country, "
+                      + "Investigators.Phone, Investigators.Email, Investigators.Url, Organizations.OrganizationName, "
+                      + "InvestigatorId, DatasetId, DatasetStatusId, Datasets.AboutPlatform, InfoFileTitle, Specifics "
+                      + "FROM InfoFiles "
+                      + "LEFT JOIN Species USING (SpeciesId) "
+                      + "LEFT JOIN Tissue USING (TissueId) "
+                      + "LEFT JOIN InbredSet USING (InbredSetId) "
+                      + "LEFT JOIN GeneChip USING (GeneChipId) "
+                      + "LEFT JOIN AvgMethod USING (AvgMethodId) "
+                      + "LEFT JOIN Datasets USING (DatasetId) "
+                      + "LEFT JOIN Investigators USING (InvestigatorId) "
+                      + "LEFT JOIN Organizations USING (OrganizationId) "
+                      + "LEFT JOIN DatasetStatus USING (DatasetStatusId) WHERE ")
 
         if self.gn_accession_id:
             final_query = query_base + \
diff --git a/wqflask/wqflask/do_search.py b/wqflask/wqflask/do_search.py
index e50ff50b..48527785 100644
--- a/wqflask/wqflask/do_search.py
+++ b/wqflask/wqflask/do_search.py
@@ -111,8 +111,8 @@ class MrnaAssaySearch(DoSearch):
         else:
             match_clause = ""
 
-        where_clause = (match_clause +
-            """ProbeSet.Id = ProbeSetXRef.ProbeSetId
+        where_clause = (match_clause
+            + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
                and ProbeSetXRef.ProbeSetFreezeId = %s
                         """ % (escape(str(self.dataset.id))))
 
@@ -134,8 +134,8 @@ class MrnaAssaySearch(DoSearch):
         else:
             match_clause = ""
 
-        where_clause = (match_clause +
-            """ProbeSet.Id = ProbeSetXRef.ProbeSetId
+        where_clause = (match_clause
+            + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
                and ProbeSetXRef.ProbeSetFreezeId = %s
                         """ % (escape(str(self.dataset.id))))
 
@@ -348,8 +348,8 @@ class GenotypeSearch(DoSearch):
         from_clause = self.normalize_spaces(from_clause)
 
         if self.search_term[0] == "*":
-            query = (self.base_query +
-                    """WHERE Geno.Id = GenoXRef.GenoId
+            query = (self.base_query
+                    + """WHERE Geno.Id = GenoXRef.GenoId
                         and GenoXRef.GenoFreezeId = GenoFreeze.Id
                         and GenoFreeze.Id = %s""" % (escape(str(self.dataset.id))))
         else:
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index c51b7a9a..9f9591ad 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -25,8 +25,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         trait_filename = f"{str(this_trait.name)}_{str(this_dataset.name)}_pheno"
         gen_pheno_txt_file(samples, vals, trait_filename)
 
-        output_filename = (f"{this_dataset.group.name}_GWA_" +
-            ''.join(random.choice(string.ascii_uppercase + string.digits)
+        output_filename = (f"{this_dataset.group.name}_GWA_"
+            + ''.join(random.choice(string.ascii_uppercase + string.digits)
                     for _ in range(6))
             )
         bootstrap_filename = None
@@ -34,8 +34,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
 
         opt_list = []
         if boot_check and num_bootstrap > 0:
-            bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_" +
-                ''.join(random.choice(string.ascii_uppercase + string.digits)
+            bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_"
+                + ''.join(random.choice(string.ascii_uppercase + string.digits)
                         for _ in range(6))
                 )
 
@@ -44,9 +44,9 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             opt_list.append(
                 f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
         if num_perm > 0:
-            permu_filename = ("{this_dataset.group.name}_PERM_" +
-            ''.join(random.choice(string.ascii_uppercase +
-                string.digits) for _ in range(6))
+            permu_filename = ("{this_dataset.group.name}_PERM_"
+            + ''.join(random.choice(string.ascii_uppercase
+                + string.digits) for _ in range(6))
             )
             opt_list.append("-n " + str(num_perm))
             opt_list.append(
diff --git a/wqflask/wqflask/show_trait/SampleList.py b/wqflask/wqflask/show_trait/SampleList.py
index 6419335e..3a63c84e 100644
--- a/wqflask/wqflask/show_trait/SampleList.py
+++ b/wqflask/wqflask/show_trait/SampleList.py
@@ -57,8 +57,8 @@ class SampleList:
                     sample = webqtlCaseData.webqtlCaseData(name=sample_name)
 
             sample.extra_info = {}
-            if (self.dataset.group.name == 'AXBXA' and
-                    sample_name in ('AXB18/19/20', 'AXB13/14', 'BXA8/17')):
+            if (self.dataset.group.name == 'AXBXA'
+                    and sample_name in ('AXB18/19/20', 'AXB13/14', 'BXA8/17')):
                 sample.extra_info['url'] = "/mouseCross.html#AXB/BXA"
                 sample.extra_info['css_class'] = "fs12"
 
diff --git a/wqflask/wqflask/show_trait/show_trait.py b/wqflask/wqflask/show_trait/show_trait.py
index 18cadea4..fcebbc4d 100644
--- a/wqflask/wqflask/show_trait/show_trait.py
+++ b/wqflask/wqflask/show_trait/show_trait.py
@@ -452,8 +452,8 @@ class ShowTrait:
 
             for sample in list(self.this_trait.data.keys()):
                 if (self.this_trait.data[sample].name2 != self.this_trait.data[sample].name):
-                    if ((self.this_trait.data[sample].name2 in primary_sample_names) and
-                            (self.this_trait.data[sample].name not in primary_sample_names)):
+                    if ((self.this_trait.data[sample].name2 in primary_sample_names)
+                            and (self.this_trait.data[sample].name not in primary_sample_names)):
                         primary_sample_names.append(
                             self.this_trait.data[sample].name)
                         primary_sample_names.remove(
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index 963288b3..3e543445 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -184,8 +184,8 @@ class UserSession:
         # ZS: Get user's collections if they exist
         collections = get_user_collections(self.user_id)
         collections = [item for item in collections if item['name'] != "Your Default Collection"] + \
-            [item for item in collections if item['name'] ==
-                "Your Default Collection"]  # ZS: Ensure Default Collection is last in list
+            [item for item in collections if item['name']
+                == "Your Default Collection"]  # ZS: Ensure Default Collection is last in list
         return collections
 
     @property
diff --git a/wqflask/wqflask/views.py b/wqflask/wqflask/views.py
index 2c53012a..f75209ff 100644
--- a/wqflask/wqflask/views.py
+++ b/wqflask/wqflask/views.py
@@ -140,8 +140,8 @@ def handle_bad_request(e):
     logger.error(traceback.format_exc())
     now = datetime.datetime.utcnow()
     time_str = now.strftime('%l:%M%p UTC %b %d, %Y')
-    formatted_lines = [request.url +
-                       " (" + time_str + ")"]+traceback.format_exc().splitlines()
+    formatted_lines = [request.url
+                       + " (" + time_str + ")"]+traceback.format_exc().splitlines()
 
     # Handle random animations
     # Use a cookie to have one animation on refresh
@@ -518,10 +518,10 @@ def export_perm_data():
         ["#N_genotypes: " + str(perm_info['n_genotypes'])],
         ["#Genotype_file: " + perm_info['genofile']],
         ["#Units_linkage: " + perm_info['units_linkage']],
-        ["#Permutation_stratified_by: " +
-            ", ".join([str(cofactor) for cofactor in perm_info['strat_cofactors']])],
-        ["#RESULTS_1: Suggestive LRS(p=0.63) = " +
-         str(np.percentile(np.array(perm_info['perm_data']), 67))],
+        ["#Permutation_stratified_by: "
+            + ", ".join([str(cofactor) for cofactor in perm_info['strat_cofactors']])],
+        ["#RESULTS_1: Suggestive LRS(p=0.63) = "
+         + str(np.percentile(np.array(perm_info['perm_data']), 67))],
         ["#RESULTS_2: Significant LRS(p=0.05) = " + str(
             np.percentile(np.array(perm_info['perm_data']), 95))],
         ["#RESULTS_3: Highly Significant LRS(p=0.01) = " + str(
-- 
cgit v1.2.3


From 114e7d3395f28ddead0ff3a94c10d0bf534fb493 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 13:05:21 +0300
Subject: autopep8: Fix E101, E11

---
 wqflask/maintenance/geno_to_json.py                |  12 +-
 .../marker_regression/test_qtlreaper_mapping.py    |  26 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |  64 ++--
 wqflask/utility/Plot.py                            |  98 +++---
 wqflask/utility/__init__.py                        |   2 +-
 wqflask/utility/genofile_parser.py                 | 150 ++++-----
 wqflask/utility/tools.py                           |   2 +-
 wqflask/wqflask/collect.py                         |  12 +-
 .../wqflask/correlation_matrix/show_corr_matrix.py |   4 +-
 wqflask/wqflask/ctl/ctl_analysis.py                |  88 +++---
 wqflask/wqflask/group_manager.py                   | 238 +++++++-------
 wqflask/wqflask/gsearch.py                         |  14 +-
 wqflask/wqflask/interval_analyst/GeneUtil.py       | 130 ++++----
 .../marker_regression/display_mapping_results.py   |  44 +--
 wqflask/wqflask/marker_regression/rqtl_mapping.py  |  14 +-
 wqflask/wqflask/marker_regression/run_mapping.py   | 352 ++++++++++-----------
 wqflask/wqflask/model.py                           |   2 +-
 wqflask/wqflask/search_results.py                  |   2 +-
 wqflask/wqflask/user_login.py                      |  70 ++--
 19 files changed, 662 insertions(+), 662 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index 27eb6553..c74489a8 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -113,13 +113,13 @@ class ConvertGenoFile:
         with open(self.output_file, 'w') as fh:
             json.dump(self.markers, fh, indent="   ", sort_keys=True)
 
-                # print('configurations:', str(configurations))
-                #self.latest_col_pos = item_count + self.skipped_cols
-                #self.latest_col_value = item
+            # print('configurations:', str(configurations))
+            #self.latest_col_pos = item_count + self.skipped_cols
+            #self.latest_col_value = item
 
-                # if item_count != 0:
-                #    self.output_fh.write(" ")
-                # self.output_fh.write(self.configurations[item.upper()])
+            # if item_count != 0:
+            #    self.output_fh.write(" ")
+            # self.output_fh.write(self.configurations[item.upper()])
 
             # self.output_fh.write("\n")
 
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index 1198740d..47377873 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -7,17 +7,17 @@ from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file
 
 
 class TestQtlReaperMapping(unittest.TestCase):
-	@mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
-	def test_gen_pheno_txt_file(self):
-		vals = ["V1", "x", "V4", "V3","x"]
-		samples = ["S1", "S2", "S3", "S4","S5"]
-		trait_filename = "trait_file"
-		with mock.patch("builtins.open", mock.mock_open())as mock_open:
-			gen_pheno_txt_file(samples=samples, vals=vals,
-			                   trait_filename=trait_filename)
-			mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
-			filehandler = mock_open()
-			write_calls = [mock.call('Trait\t'), mock.call(
-				'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
+    @mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
+    def test_gen_pheno_txt_file(self):
+        vals = ["V1", "x", "V4", "V3","x"]
+        samples = ["S1", "S2", "S3", "S4","S5"]
+        trait_filename = "trait_file"
+        with mock.patch("builtins.open", mock.mock_open())as mock_open:
+            gen_pheno_txt_file(samples=samples, vals=vals,
+                               trait_filename=trait_filename)
+            mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
+            filehandler = mock_open()
+            write_calls = [mock.call('Trait\t'), mock.call(
+                    'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
 
-			filehandler.write.assert_has_calls(write_calls)
+            filehandler.write.assert_has_calls(write_calls)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index d69a20d3..e518ec22 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -8,35 +8,35 @@ from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
 
 class TestRqtlMapping(unittest.TestCase):
 
-	def setUp(self):
-		self.app_context = app.app_context()
-		self.app_context.push()
-
-	def tearDown(self):
-		self.app_context.pop()
-
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.g")
-	@mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-	def test_get_trait_data(self, mock_logger, mock_db):
-		"""test for getting trait data_type return True"""
-		query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-		mock_db.db.execute.return_value.fetchone.return_value = [
-			"""{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
-		results = get_trait_data_type("traid_id")
-		mock_db.db.execute.assert_called_with(query_value)
-		self.assertEqual(results, "fer434f")
-
-	def test_sanitize_rqtl_phenotype(self):
-		"""test for sanitizing rqtl phenotype"""
-		vals = ['f', "x", "r", "x","x"]
-		results = sanitize_rqtl_phenotype(vals)
-		expected_phenotype_string = 'c(f,NA,r,NA,NA)'
-
-		self.assertEqual(results, expected_phenotype_string)
-
-	def test_sanitize_rqtl_names(self):
-		"""test for sanitzing rqtl names"""
-		vals = ['f', "x", "r", "x","x"]
-		expected_sanitized_name = "c('f',NA,'r',NA,NA)"
-		results = sanitize_rqtl_names(vals)
-		self.assertEqual(expected_sanitized_name, results)
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.g")
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
+    def test_get_trait_data(self, mock_logger, mock_db):
+        """test for getting trait data_type return True"""
+        query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
+        mock_db.db.execute.return_value.fetchone.return_value = [
+                """{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+        results = get_trait_data_type("traid_id")
+        mock_db.db.execute.assert_called_with(query_value)
+        self.assertEqual(results, "fer434f")
+
+    def test_sanitize_rqtl_phenotype(self):
+        """test for sanitizing rqtl phenotype"""
+        vals = ['f', "x", "r", "x","x"]
+        results = sanitize_rqtl_phenotype(vals)
+        expected_phenotype_string = 'c(f,NA,r,NA,NA)'
+
+        self.assertEqual(results, expected_phenotype_string)
+
+    def test_sanitize_rqtl_names(self):
+        """test for sanitzing rqtl names"""
+        vals = ['f', "x", "r", "x","x"]
+        expected_sanitized_name = "c('f',NA,'r',NA,NA)"
+        results = sanitize_rqtl_names(vals)
+        self.assertEqual(expected_sanitized_name, results)
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index 00658d10..f61e3b88 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -79,7 +79,7 @@ def frange(start, end=None, inc=1.0):
         start += 0.0  # force it to be a float
     count = int((end - start) / inc)
     if start + count * inc != end:
-    # Need to adjust the count. AFAICT, it always comes up one short.
+        # Need to adjust the count. AFAICT, it always comes up one short.
         count += 1
     L = [start] * count
     for i in range(1, count):
@@ -131,16 +131,16 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
     plotHeight = canvas.size[1] - yTopOffset - yBottomOffset
     if plotHeight <= 0 or plotWidth <= 0:
-       return
+        return
 
     if len(data) < 2:
-       return
+        return
 
     max_D = max(data)
     min_D = min(data)
     # add by NL 06-20-2011: fix the error: when max_D is infinite, log function in detScale will go wrong
     if max_D == float('inf') or max_D > webqtlConfig.MAXLRS:
-       max_D = webqtlConfig.MAXLRS  # maximum LRS value
+        max_D = webqtlConfig.MAXLRS  # maximum LRS value
 
     xLow, xTop, stepX = detScale(min_D, max_D)
 
@@ -151,15 +151,15 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     dataXY = []
     Count = []
     while j <= xTop:
-       dataXY.append(j)
-       Count.append(0)
-       j += step
+        dataXY.append(j)
+        Count.append(0)
+        j += step
 
     for i, item in enumerate(data):
-       if item == float('inf') or item > webqtlConfig.MAXLRS:
-           item = webqtlConfig.MAXLRS  # maximum LRS value
-       j = int((item - xLow) / step)
-       Count[j] += 1
+        if item == float('inf') or item > webqtlConfig.MAXLRS:
+            item = webqtlConfig.MAXLRS  # maximum LRS value
+        j = int((item - xLow) / step)
+        Count[j] += 1
 
     yLow, yTop, stepY = detScale(0, max(Count))
 
@@ -169,12 +169,12 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     barWidth = xScale * step
 
     for i, count in enumerate(Count):
-       if count:
-           xc = (dataXY[i] - xLow) * xScale + xLeftOffset
-           yc = -(count - yLow) * yScale + yTopOffset + plotHeight
-           im_drawer.rectangle(
-               xy=((xc + 2, yc), (xc + barWidth - 2, yTopOffset + plotHeight)),
-               outline=barColor, fill=barColor)
+        if count:
+            xc = (dataXY[i] - xLow) * xScale + xLeftOffset
+            yc = -(count - yLow) * yScale + yTopOffset + plotHeight
+            im_drawer.rectangle(
+                xy=((xc + 2, yc), (xc + barWidth - 2, yTopOffset + plotHeight)),
+                outline=barColor, fill=barColor)
 
     # draw drawing region
     im_drawer.rectangle(
@@ -186,39 +186,39 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     scaleFont = ImageFont.truetype(font=COUR_FILE, size=11)
     x = xLow
     for i in range(int(stepX) + 1):
-       xc = xLeftOffset + (x - xLow) * xScale
-       im_drawer.line(
-           xy=((xc, yTopOffset + plotHeight), (xc, yTopOffset + plotHeight + 5)),
-           fill=axesColor)
-       strX = cformat(d=x, rank=0)
-       im_drawer.text(
-           text=strX,
-           xy=(xc - im_drawer.textsize(strX, font=scaleFont)[0] / 2,
-               yTopOffset + plotHeight + 14), font=scaleFont)
-       x += (xTop - xLow) / stepX
+        xc = xLeftOffset + (x - xLow) * xScale
+        im_drawer.line(
+            xy=((xc, yTopOffset + plotHeight), (xc, yTopOffset + plotHeight + 5)),
+            fill=axesColor)
+        strX = cformat(d=x, rank=0)
+        im_drawer.text(
+            text=strX,
+            xy=(xc - im_drawer.textsize(strX, font=scaleFont)[0] / 2,
+                yTopOffset + plotHeight + 14), font=scaleFont)
+        x += (xTop - xLow) / stepX
 
     y = yLow
     for i in range(int(stepY) + 1):
-       yc = yTopOffset + plotHeight - (y - yLow) * yScale
-       im_drawer.line(
-           xy=((xLeftOffset, yc), (xLeftOffset - 5, yc)), fill=axesColor)
-       strY = "%d" % y
-       im_drawer.text(
-           text=strY,
-           xy=(xLeftOffset - im_drawer.textsize(strY,
-               font=scaleFont)[0] - 6, yc + 5),
-           font=scaleFont)
-       y += (yTop - yLow) / stepY
+        yc = yTopOffset + plotHeight - (y - yLow) * yScale
+        im_drawer.line(
+            xy=((xLeftOffset, yc), (xLeftOffset - 5, yc)), fill=axesColor)
+        strY = "%d" % y
+        im_drawer.text(
+            text=strY,
+            xy=(xLeftOffset - im_drawer.textsize(strY,
+                font=scaleFont)[0] - 6, yc + 5),
+            font=scaleFont)
+        y += (yTop - yLow) / stepY
 
     # draw label
     labelFont = ImageFont.truetype(font=TAHOMA_FILE, size=17)
     if XLabel:
-       im_drawer.text(
-           text=XLabel,
-           xy=(xLeftOffset + (
-               plotWidth - im_drawer.textsize(XLabel, font=labelFont)[0]) / 2.0,
-               yTopOffset + plotHeight + yBottomOffset-10),
-           font=labelFont, fill=labelColor)
+        im_drawer.text(
+            text=XLabel,
+            xy=(xLeftOffset + (
+                plotWidth - im_drawer.textsize(XLabel, font=labelFont)[0]) / 2.0,
+                yTopOffset + plotHeight + yBottomOffset-10),
+            font=labelFont, fill=labelColor)
 
     if YLabel:
         draw_rotated_text(canvas, text=YLabel,
@@ -230,12 +230,12 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
 
     labelFont = ImageFont.truetype(font=VERDANA_FILE, size=16)
     if title:
-       im_drawer.text(
-           text=title,
-           xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
-               title, font=labelFont)[0]) / 2.0,
-               20),
-           font=labelFont, fill=labelColor)
+        im_drawer.text(
+            text=title,
+            xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
+                title, font=labelFont)[0]) / 2.0,
+                20),
+            font=labelFont, fill=labelColor)
 
 # This function determines the scale of the plot
 
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index 816bc4df..6c8cd546 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -7,7 +7,7 @@ class Bunch:
     """Like a dictionary but using object notation"""
 
     def __init__(self, **kw):
-            self.__dict__ = kw
+        self.__dict__ = kw
 
     def __repr__(self):
         return pf(self.__dict__)
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index c0629b5d..eb545478 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -14,87 +14,87 @@ from pprint import pformat as pf
 
 
 class Marker:
-  def __init__(self):
-    self.name = None
-    self.chr = None
-    self.cM = None
-    self.Mb = None
-    self.genotypes = []
+    def __init__(self):
+        self.name = None
+        self.chr = None
+        self.cM = None
+        self.Mb = None
+        self.genotypes = []
 
 
 class ConvertGenoFile:
 
-  def __init__(self, input_file):
-    self.mb_exists = False
-    self.cm_exists = False
-    self.markers = []
+    def __init__(self, input_file):
+        self.mb_exists = False
+        self.cm_exists = False
+        self.markers = []
 
-    self.latest_row_pos = None
-    self.latest_col_pos = None
+        self.latest_row_pos = None
+        self.latest_col_pos = None
 
-    self.latest_row_value = None
-    self.latest_col_value = None
-    self.input_fh = open(input_file)
-    print("!!!!!!!!!!!!!!!!PARSER!!!!!!!!!!!!!!!!!!")
-    self.haplotype_notation = {
-      '@mat': "1",
-      '@pat': "2",
-      '@het': "-999",
-      '@unk': "-999"
-    }
-    self.configurations = {}
+        self.latest_row_value = None
+        self.latest_col_value = None
+        self.input_fh = open(input_file)
+        print("!!!!!!!!!!!!!!!!PARSER!!!!!!!!!!!!!!!!!!")
+        self.haplotype_notation = {
+          '@mat': "1",
+          '@pat': "2",
+          '@het': "-999",
+          '@unk': "-999"
+        }
+        self.configurations = {}
 
-  def process_rows(self):
-    for self.latest_row_pos, row in enumerate(self.input_fh):
-        self.latest_row_value = row
-        # Take care of headers
-        if not row.strip():
-            continue
-        if row.startswith('#'):
-            continue
-        if row.startswith('Chr'):
-            if 'Mb' in row.split():
-                self.mb_exists = True
-            if 'cM' in row.split():
-                self.cm_exists = True
-            skip = 2 + self.cm_exists + self.mb_exists
-            self.individuals = row.split()[skip:]
-            continue
-        if row.startswith('@'):
-            key, _separater, value = row.partition(':')
-            key = key.strip()
-            value = value.strip()
-            if key in self.haplotype_notation:
-                self.configurations[value] = self.haplotype_notation[key]
-            continue
-        if not len(self.configurations):
-            raise EmptyConfigurations
-        yield row
+    def process_rows(self):
+        for self.latest_row_pos, row in enumerate(self.input_fh):
+            self.latest_row_value = row
+            # Take care of headers
+            if not row.strip():
+                continue
+            if row.startswith('#'):
+                continue
+            if row.startswith('Chr'):
+                if 'Mb' in row.split():
+                    self.mb_exists = True
+                if 'cM' in row.split():
+                    self.cm_exists = True
+                skip = 2 + self.cm_exists + self.mb_exists
+                self.individuals = row.split()[skip:]
+                continue
+            if row.startswith('@'):
+                key, _separater, value = row.partition(':')
+                key = key.strip()
+                value = value.strip()
+                if key in self.haplotype_notation:
+                    self.configurations[value] = self.haplotype_notation[key]
+                continue
+            if not len(self.configurations):
+                raise EmptyConfigurations
+            yield row
 
-  def process_csv(self):
-    for row in self.process_rows():
-      row_items = row.split("\t")
+    def process_csv(self):
+        for row in self.process_rows():
+            row_items = row.split("\t")
 
-      this_marker = Marker()
-      this_marker.name = row_items[1]
-      this_marker.chr = row_items[0]
-      if self.cm_exists and self.mb_exists:
-        this_marker.cM = row_items[2]
-        this_marker.Mb = row_items[3]
-        genotypes = row_items[4:]
-      elif self.cm_exists:
-          this_marker.cM = row_items[2]
-          genotypes = row_items[3:]
-      elif self.mb_exists:
-          this_marker.Mb = row_items[2]
-          genotypes = row_items[3:]
-      else:
-        genotypes = row_items[2:]
-      for item_count, genotype in enumerate(genotypes):
-        if genotype.upper().strip() in self.configurations:
-          this_marker.genotypes.append(
-            self.configurations[genotype.upper().strip()])
-        else:
-          print("WARNING:", genotype.upper())
-          this_marker.genotypes.append("NA")
-      self.markers.append(this_marker.__dict__)
+            this_marker = Marker()
+            this_marker.name = row_items[1]
+            this_marker.chr = row_items[0]
+            if self.cm_exists and self.mb_exists:
+                this_marker.cM = row_items[2]
+                this_marker.Mb = row_items[3]
+                genotypes = row_items[4:]
+            elif self.cm_exists:
+                this_marker.cM = row_items[2]
+                genotypes = row_items[3:]
+            elif self.mb_exists:
+                this_marker.Mb = row_items[2]
+                genotypes = row_items[3:]
+            else:
+                genotypes = row_items[2:]
+            for item_count, genotype in enumerate(genotypes):
+                if genotype.upper().strip() in self.configurations:
+                    this_marker.genotypes.append(
+                      self.configurations[genotype.upper().strip()])
+                else:
+                    print("WARNING:", genotype.upper())
+                    this_marker.genotypes.append("NA")
+            self.markers.append(this_marker.__dict__)
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index d82e478d..4f09176a 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -73,7 +73,7 @@ def get_setting(command_id, guess=None):
 def get_setting_bool(id):
     v = get_setting(id)
     if v not in [0, False, 'False', 'FALSE', None]:
-      return True
+        return True
     return False
 
 
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 9fd89524..b06d84ff 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -35,7 +35,7 @@ def process_traits(unprocessed_traits):
         data, _separator, the_hmac = trait.rpartition(':')
         data = data.strip()
         if g.user_session.logged_in:
-          assert the_hmac == hmac.hmac_creation(data), "Data tampering?"
+            assert the_hmac == hmac.hmac_creation(data), "Data tampering?"
         traits.add(str(data))
 
     return traits
@@ -52,14 +52,14 @@ def report_change(len_before, len_now):
 
 @app.route("/collections/store_trait_list", methods=('POST',))
 def store_traits_list():
-   params = request.form
+    params = request.form
 
-   traits = params['traits']
-   hash = params['hash']
+    traits = params['traits']
+    hash = params['hash']
 
-   Redis.set(hash, traits)
+    Redis.set(hash, traits)
 
-   return hash
+    return hash
 
 
 @app.route("/collections/add")
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index 59469428..c04b17be 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -238,9 +238,9 @@ class CorrelationMatrix:
         for i in range(len(self.trait_list)):
             loadings_row = []
             if len(self.trait_list) > 2:
-               the_range = 3
+                the_range = 3
             else:
-               the_range = 2
+                the_range = 2
             for j in range(the_range):
                 position = i + len(self.trait_list) * j
                 loadings_row.append(self.loadings[0][position])
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index f4eafbe7..820e81bc 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -115,8 +115,8 @@ class CTL:
         markers = []
         markernames = []
         for marker in parser.markers:
-          markernames.append(marker["name"])
-          markers.append(marker["genotypes"])
+            markernames.append(marker["name"])
+            markers.append(marker["genotypes"])
 
         genotypes = list(itertools.chain(*markers))
         logger.debug(len(genotypes) / len(individuals),
@@ -128,16 +128,16 @@ class CTL:
         # Create a phenotype matrix
         traits = []
         for trait in self.trait_db_list:
-          logger.debug("retrieving data for", trait)
-          if trait != "":
-            ts = trait.split(':')
-            gt = create_trait(name=ts[0], dataset_name=ts[1])
-            gt = retrieve_sample_data(gt, dataset, individuals)
-            for ind in individuals:
-              if ind in list(gt.data.keys()):
-                traits.append(gt.data[ind].value)
-              else:
-                traits.append("-999")
+            logger.debug("retrieving data for", trait)
+            if trait != "":
+                ts = trait.split(':')
+                gt = create_trait(name=ts[0], dataset_name=ts[1])
+                gt = retrieve_sample_data(gt, dataset, individuals)
+                for ind in individuals:
+                    if ind in list(gt.data.keys()):
+                        traits.append(gt.data[ind].value)
+                    else:
+                        traits.append("-999")
 
         rPheno = r_t(ro.r.matrix(r_as_numeric(r_unlist(traits)), nrow=len(self.trait_db_list), ncol=len(
             individuals), dimnames=r_list(self.trait_db_list, individuals), byrow=True))
@@ -177,42 +177,42 @@ class CTL:
         # We start from 2, since R starts from 1 :)
         n = 2
         for trait in self.trait_db_list:
-          # Create the QTL like CTL plots
-          self.results['imgurl' + \
-              str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
-          self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + \
-                                      self.results['imgurl' + str(n)]
-          r_png(self.results['imgloc' + str(n)],
-                width=1000, height=600, type='cairo-png')
-          self.r_plotCTLobject(
-              res, (n - 1), significance=significance, main='Phenotype ' + trait)
-          r_dev_off()
-          n = n + 1
+            # Create the QTL like CTL plots
+            self.results['imgurl' + \
+                str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
+            self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + \
+                                        self.results['imgurl' + str(n)]
+            r_png(self.results['imgloc' + str(n)],
+                  width=1000, height=600, type='cairo-png')
+            self.r_plotCTLobject(
+                res, (n - 1), significance=significance, main='Phenotype ' + trait)
+            r_dev_off()
+            n = n + 1
 
         # Flush any output from R
         sys.stdout.flush()
 
         # Create the interactive graph for cytoscape visualization (Nodes and Edges)
         if not isinstance(significant, ri.RNULLType):
-          for x in range(len(significant[0])):
-            logger.debug(significant[0][x], significant[1]
-                         [x], significant[2][x])     # Debug to console
-            # Source
-            tsS = significant[0][x].split(':')
-            # Target
-            tsT = significant[2][x].split(':')
-            # Retrieve Source info from the DB
-            gtS = create_trait(name=tsS[0], dataset_name=tsS[1])
-            # Retrieve Target info from the DB
-            gtT = create_trait(name=tsT[0], dataset_name=tsT[1])
-            self.addNode(gtS)
-            self.addNode(gtT)
-            self.addEdge(gtS, gtT, significant, x)
-
-            # Update the trait name for the displayed table
-            significant[0][x] = "{} ({})".format(gtS.symbol, gtS.name)
-            # Update the trait name for the displayed table
-            significant[2][x] = "{} ({})".format(gtT.symbol, gtT.name)
+            for x in range(len(significant[0])):
+                logger.debug(significant[0][x], significant[1]
+                             [x], significant[2][x])     # Debug to console
+                # Source
+                tsS = significant[0][x].split(':')
+                # Target
+                tsT = significant[2][x].split(':')
+                # Retrieve Source info from the DB
+                gtS = create_trait(name=tsS[0], dataset_name=tsS[1])
+                # Retrieve Target info from the DB
+                gtT = create_trait(name=tsT[0], dataset_name=tsT[1])
+                self.addNode(gtS)
+                self.addNode(gtT)
+                self.addEdge(gtS, gtT, significant, x)
+
+                # Update the trait name for the displayed table
+                significant[0][x] = "{} ({})".format(gtS.symbol, gtS.name)
+                # Update the trait name for the displayed table
+                significant[2][x] = "{} ({})".format(gtT.symbol, gtT.name)
 
         self.elements = json.dumps(self.nodes_list + self.edges_list)
 
@@ -227,8 +227,8 @@ class CTL:
         self.loadImage("imgloc1", "imgdata1")
         n = 2
         for trait in self.trait_db_list:
-          self.loadImage("imgloc" + str(n), "imgdata" + str(n))
-          n = n + 1
+            self.loadImage("imgloc" + str(n), "imgdata" + str(n))
+            n = n + 1
 
     def process_results(self, results):
         logger.info("Processing CTL output")
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index 55a7da0e..995915a9 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -16,158 +16,158 @@ logger = getLogger(__name__)
 
 @app.route("/groups/manage", methods=('GET', 'POST'))
 def manage_groups():
-   params = request.form if request.form else request.args
-   if "add_new_group" in params:
-      return redirect(url_for('add_group'))
-   else:
-      admin_groups, member_groups = get_user_groups(g.user_session.user_id)
-      return render_template("admin/group_manager.html", admin_groups=admin_groups, member_groups=member_groups)
+    params = request.form if request.form else request.args
+    if "add_new_group" in params:
+        return redirect(url_for('add_group'))
+    else:
+        admin_groups, member_groups = get_user_groups(g.user_session.user_id)
+        return render_template("admin/group_manager.html", admin_groups=admin_groups, member_groups=member_groups)
 
 
 @app.route("/groups/view", methods=('GET', 'POST'))
 def view_group():
-   params = request.form if request.form else request.args
-   group_id = params['id']
-   group_info = get_group_info(group_id)
-   admins_info = []
-   user_is_admin = False
-   if g.user_session.user_id in group_info['admins']:
-      user_is_admin = True
-   for user_id in group_info['admins']:
-      if user_id:
-         user_info = get_user_by_unique_column("user_id", user_id)
-         admins_info.append(user_info)
-   members_info = []
-   for user_id in group_info['members']:
-      if user_id:
-         user_info = get_user_by_unique_column("user_id", user_id)
-         members_info.append(user_info)
-
-   # ZS: This whole part might not scale well with many resources
-   resources_info = []
-   all_resources = get_resources()
-   for resource_id in all_resources:
-      resource_info = get_resource_info(resource_id)
-      group_masks = resource_info['group_masks']
-      if group_id in group_masks:
-         this_resource = {}
-         privileges = group_masks[group_id]
-         this_resource['id'] = resource_id
-         this_resource['name'] = resource_info['name']
-         this_resource['data'] = privileges['data']
-         this_resource['metadata'] = privileges['metadata']
-         this_resource['admin'] = privileges['admin']
-         resources_info.append(this_resource)
-
-   return render_template("admin/view_group.html", group_info=group_info, admins=admins_info, members=members_info, user_is_admin=user_is_admin, resources=resources_info)
+    params = request.form if request.form else request.args
+    group_id = params['id']
+    group_info = get_group_info(group_id)
+    admins_info = []
+    user_is_admin = False
+    if g.user_session.user_id in group_info['admins']:
+        user_is_admin = True
+    for user_id in group_info['admins']:
+        if user_id:
+            user_info = get_user_by_unique_column("user_id", user_id)
+            admins_info.append(user_info)
+    members_info = []
+    for user_id in group_info['members']:
+        if user_id:
+            user_info = get_user_by_unique_column("user_id", user_id)
+            members_info.append(user_info)
+
+    # ZS: This whole part might not scale well with many resources
+    resources_info = []
+    all_resources = get_resources()
+    for resource_id in all_resources:
+        resource_info = get_resource_info(resource_id)
+        group_masks = resource_info['group_masks']
+        if group_id in group_masks:
+            this_resource = {}
+            privileges = group_masks[group_id]
+            this_resource['id'] = resource_id
+            this_resource['name'] = resource_info['name']
+            this_resource['data'] = privileges['data']
+            this_resource['metadata'] = privileges['metadata']
+            this_resource['admin'] = privileges['admin']
+            resources_info.append(this_resource)
+
+    return render_template("admin/view_group.html", group_info=group_info, admins=admins_info, members=members_info, user_is_admin=user_is_admin, resources=resources_info)
 
 
 @app.route("/groups/remove", methods=('POST',))
 def remove_groups():
-   group_ids_to_remove = request.form['selected_group_ids']
-   for group_id in group_ids_to_remove.split(":"):
-      delete_group(g.user_session.user_id, group_id)
+    group_ids_to_remove = request.form['selected_group_ids']
+    for group_id in group_ids_to_remove.split(":"):
+        delete_group(g.user_session.user_id, group_id)
 
-   return redirect(url_for('manage_groups'))
+    return redirect(url_for('manage_groups'))
 
 
 @app.route("/groups/remove_users", methods=('POST',))
 def remove_users():
-   group_id = request.form['group_id']
-   admin_ids_to_remove = request.form['selected_admin_ids']
-   member_ids_to_remove = request.form['selected_member_ids']
+    group_id = request.form['group_id']
+    admin_ids_to_remove = request.form['selected_admin_ids']
+    member_ids_to_remove = request.form['selected_member_ids']
 
-   remove_users_from_group(g.user_session.user_id, admin_ids_to_remove.split(
-      ":"), group_id, user_type="admins")
-   remove_users_from_group(g.user_session.user_id, member_ids_to_remove.split(
-      ":"), group_id, user_type="members")
+    remove_users_from_group(g.user_session.user_id, admin_ids_to_remove.split(
+       ":"), group_id, user_type="admins")
+    remove_users_from_group(g.user_session.user_id, member_ids_to_remove.split(
+       ":"), group_id, user_type="members")
 
-   return redirect(url_for('view_group', id=group_id))
+    return redirect(url_for('view_group', id=group_id))
 
 
 @app.route("/groups/add_<path:user_type>", methods=('POST',))
 def add_users(user_type='members'):
-   group_id = request.form['group_id']
-   if user_type == "admins":
-      user_emails = request.form['admin_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id,
-                         user_emails, admins=True)
-   elif user_type == "members":
-      user_emails = request.form['member_emails_to_add'].split(",")
-      add_users_to_group(g.user_session.user_id, group_id,
-                         user_emails, admins=False)
+    group_id = request.form['group_id']
+    if user_type == "admins":
+        user_emails = request.form['admin_emails_to_add'].split(",")
+        add_users_to_group(g.user_session.user_id, group_id,
+                           user_emails, admins=True)
+    elif user_type == "members":
+        user_emails = request.form['member_emails_to_add'].split(",")
+        add_users_to_group(g.user_session.user_id, group_id,
+                           user_emails, admins=False)
 
-   return redirect(url_for('view_group', id=group_id))
+    return redirect(url_for('view_group', id=group_id))
 
 
 @app.route("/groups/change_name", methods=('POST',))
 def change_name():
-   group_id = request.form['group_id']
-   new_name = request.form['new_name']
-   group_info = change_group_name(g.user_session.user_id, group_id, new_name)
+    group_id = request.form['group_id']
+    new_name = request.form['new_name']
+    group_info = change_group_name(g.user_session.user_id, group_id, new_name)
 
-   return new_name
+    return new_name
 
 
 @app.route("/groups/create", methods=('GET', 'POST'))
 def add_or_edit_group():
-   params = request.form if request.form else request.args
-   if "group_name" in params:
-      member_user_ids = set()
-      admin_user_ids = set()
-      # ZS: Always add the user creating the group as an admin
-      admin_user_ids.add(g.user_session.user_id)
-      if "admin_emails_to_add" in params:
-         admin_emails = params['admin_emails_to_add'].split(",")
-         for email in admin_emails:
-            user_details = get_user_by_unique_column("email_address", email)
-            if user_details:
-               admin_user_ids.add(user_details['user_id'])
-         #send_group_invites(params['group_id'], user_email_list = admin_emails, user_type="admins")
-      if "member_emails_to_add" in params:
-         member_emails = params['member_emails_to_add'].split(",")
-         for email in member_emails:
-            user_details = get_user_by_unique_column("email_address", email)
-            if user_details:
-               member_user_ids.add(user_details['user_id'])
-         #send_group_invites(params['group_id'], user_email_list = user_emails, user_type="members")
-
-      create_group(list(admin_user_ids), list(
-         member_user_ids), params['group_name'])
-      return redirect(url_for('manage_groups'))
-   else:
-      return render_template("admin/create_group.html")
+    params = request.form if request.form else request.args
+    if "group_name" in params:
+        member_user_ids = set()
+        admin_user_ids = set()
+        # ZS: Always add the user creating the group as an admin
+        admin_user_ids.add(g.user_session.user_id)
+        if "admin_emails_to_add" in params:
+            admin_emails = params['admin_emails_to_add'].split(",")
+            for email in admin_emails:
+                user_details = get_user_by_unique_column("email_address", email)
+                if user_details:
+                    admin_user_ids.add(user_details['user_id'])
+            #send_group_invites(params['group_id'], user_email_list = admin_emails, user_type="admins")
+        if "member_emails_to_add" in params:
+            member_emails = params['member_emails_to_add'].split(",")
+            for email in member_emails:
+                user_details = get_user_by_unique_column("email_address", email)
+                if user_details:
+                    member_user_ids.add(user_details['user_id'])
+            #send_group_invites(params['group_id'], user_email_list = user_emails, user_type="members")
+
+        create_group(list(admin_user_ids), list(
+           member_user_ids), params['group_name'])
+        return redirect(url_for('manage_groups'))
+    else:
+        return render_template("admin/create_group.html")
 
 # ZS: Will integrate this later, for now just letting users be added directly
 
 
 def send_group_invites(group_id, user_email_list=[], user_type="members"):
-   for user_email in user_email_list:
-      user_details = get_user_by_unique_column("email_address", user_email)
-      if user_details:
-         group_info = get_group_info(group_id)
-         # ZS: Probably not necessary since the group should normally always exist if group_id is being passed here,
-         #    but it's technically possible to hit it if Redis is cleared out before submitting the new users or something
-         if group_info:
-            # ZS: Don't add user if they're already an admin or if they're being added a regular user and are already a regular user,
-            #    but do add them if they're a regular user and are added as an admin
-            if (user_details['user_id'] in group_info['admins']) or \
-               ((user_type == "members") and (user_details['user_id'] in group_info['members'])):
-               continue
-            else:
-               send_verification_email(user_details, template_name="email/group_verification.txt",
-                                       key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
-      else:
-         temp_password = ''.join(random.choice(
-            string.ascii_uppercase + string.digits) for _ in range(6))
-         user_details = {
-            'user_id': str(uuid.uuid4()),
-            'email_address': user_email,
-            'registration_info': basic_info(),
-            'password': set_password(temp_password),
-            'confirmed': 0
-         }
-         save_user(user_details, user_details['user_id'])
-         send_invitation_email(user_email, temp_password)
+    for user_email in user_email_list:
+        user_details = get_user_by_unique_column("email_address", user_email)
+        if user_details:
+            group_info = get_group_info(group_id)
+            # ZS: Probably not necessary since the group should normally always exist if group_id is being passed here,
+            #    but it's technically possible to hit it if Redis is cleared out before submitting the new users or something
+            if group_info:
+                # ZS: Don't add user if they're already an admin or if they're being added a regular user and are already a regular user,
+                #    but do add them if they're a regular user and are added as an admin
+                if (user_details['user_id'] in group_info['admins']) or \
+                   ((user_type == "members") and (user_details['user_id'] in group_info['members'])):
+                    continue
+                else:
+                    send_verification_email(user_details, template_name="email/group_verification.txt",
+                                            key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
+        else:
+            temp_password = ''.join(random.choice(
+               string.ascii_uppercase + string.digits) for _ in range(6))
+            user_details = {
+               'user_id': str(uuid.uuid4()),
+               'email_address': user_email,
+               'registration_info': basic_info(),
+               'password': set_password(temp_password),
+               'confirmed': 0
+            }
+            save_user(user_details, user_details['user_id'])
+            send_invitation_email(user_email, temp_password)
 
 # @app.route()
diff --git a/wqflask/wqflask/gsearch.py b/wqflask/wqflask/gsearch.py
index 9548d130..f02da27c 100644
--- a/wqflask/wqflask/gsearch.py
+++ b/wqflask/wqflask/gsearch.py
@@ -247,13 +247,13 @@ class GSearch:
                     if not trait_ob:
                         continue
                     if this_trait['dataset'] == this_trait['group'] + "Publish":
-                      try:
-                        if trait_ob.locus_chr != "" and trait_ob.locus_mb != "":
-                            this_trait['max_lrs_text'] = "Chr" + \
-                                str(trait_ob.locus_chr) + \
-                                    ": " + str(trait_ob.locus_mb)
-                      except:
-                          this_trait['max_lrs_text'] = "N/A"
+                        try:
+                            if trait_ob.locus_chr != "" and trait_ob.locus_mb != "":
+                                this_trait['max_lrs_text'] = "Chr" + \
+                                    str(trait_ob.locus_chr) + \
+                                        ": " + str(trait_ob.locus_mb)
+                        except:
+                            this_trait['max_lrs_text'] = "N/A"
 
                     trait_list.append(this_trait)
 
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index e624a146..2f1c142c 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -7,79 +7,79 @@ from flask import Flask, g
 
 
 def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
-	fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
-	'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
-	'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
+    fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
+    'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
+    'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
 
-	# List All Species in the Gene Table
-	speciesDict = {}
-	results = g.db.execute("""
+    # List All Species in the Gene Table
+    speciesDict = {}
+    results = g.db.execute("""
                 SELECT Species.Name, GeneList.SpeciesId
                 FROM Species, GeneList
                 WHERE GeneList.SpeciesId = Species.Id
                 GROUP BY GeneList.SpeciesId""").fetchall()
 
-	for item in results:
-		speciesDict[item[0]] = item[1]
+    for item in results:
+        speciesDict[item[0]] = item[1]
 
-	# List current Species and other Species
-	speciesId = speciesDict[species]
-	otherSpecies = [[X, speciesDict[X]] for X in list(speciesDict.keys())]
-	otherSpecies.remove([species, speciesId])
+    # List current Species and other Species
+    speciesId = speciesDict[species]
+    otherSpecies = [[X, speciesDict[X]] for X in list(speciesDict.keys())]
+    otherSpecies.remove([species, speciesId])
 
-	results = g.db.execute("""
+    results = g.db.execute("""
                 SELECT %s FROM GeneList
 				WHERE SpeciesId = %d AND
                       Chromosome = '%s' AND
 					  ((TxStart > %f and TxStart <= %f) OR (TxEnd > %f and TxEnd <= %f))
 				ORDER BY txStart
                 """ % (", ".join(fetchFields),
-                       speciesId, chrName,
-                       startMb, endMb,
-                       startMb, endMb)).fetchall()
-
-	GeneList = []
-
-	if results:
-		for result in results:
-			newdict = {}
-			for j, item in enumerate(fetchFields):
-				newdict[item] = result[j]
-			# count SNPs if possible
-			if diffCol and species == 'mouse':
-				newdict["snpCount"] = g.db.execute("""
+                   speciesId, chrName,
+                   startMb, endMb,
+                   startMb, endMb)).fetchall()
+
+    GeneList = []
+
+    if results:
+        for result in results:
+            newdict = {}
+            for j, item in enumerate(fetchFields):
+                newdict[item] = result[j]
+            # count SNPs if possible
+            if diffCol and species == 'mouse':
+                newdict["snpCount"] = g.db.execute("""
                                         SELECT count(*)
                                         FROM BXDSnpPosition
                                         WHERE Chr = '%s' AND
                                               Mb >= %2.6f AND Mb < %2.6f AND
                                               StrainId1 = %d AND StrainId2 = %d
                                         """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
-				newdict["snpDensity"] = newdict["snpCount"] / \
-					(newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
-			else:
-				newdict["snpDensity"] = newdict["snpCount"] = 0
-
-			try:
-				newdict['GeneLength'] = 1000.0 * (newdict['TxEnd'] - newdict['TxStart'])
-			except:
-				pass
-
-			# load gene from other Species by the same name
-			for item in otherSpecies:
-				othSpec, othSpecId = item
-				newdict2 = {}
-
-				resultsOther = g.db.execute("SELECT %s FROM GeneList WHERE SpeciesId = %d AND geneSymbol= '%s' LIMIT 1" % (", ".join(fetchFields),
-                                                                                                                           othSpecId,
-                                                                                                                           newdict["GeneSymbol"])).fetchone()
-
-				if resultsOther:
-					for j, item in enumerate(fetchFields):
-						newdict2[item] = resultsOther[j]
-
-					# count SNPs if possible, could be a separate function
-					if diffCol and othSpec == 'mouse':
-						newdict2["snpCount"] = g.db.execute("""
+                newdict["snpDensity"] = newdict["snpCount"] / \
+                        (newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
+            else:
+                newdict["snpDensity"] = newdict["snpCount"] = 0
+
+            try:
+                newdict['GeneLength'] = 1000.0 * (newdict['TxEnd'] - newdict['TxStart'])
+            except:
+                pass
+
+            # load gene from other Species by the same name
+            for item in otherSpecies:
+                othSpec, othSpecId = item
+                newdict2 = {}
+
+                resultsOther = g.db.execute("SELECT %s FROM GeneList WHERE SpeciesId = %d AND geneSymbol= '%s' LIMIT 1" % (", ".join(fetchFields),
+                                                                                                           othSpecId,
+                                                                                                           newdict["GeneSymbol"])).fetchone()
+
+                if resultsOther:
+                    for j, item in enumerate(fetchFields):
+                        newdict2[item] = resultsOther[j]
+
+                    # count SNPs if possible, could be a separate function
+                    if diffCol and othSpec == 'mouse':
+                        newdict2["snpCount"] = g.db.execute("""
                                                     SELECT count(*)
                                                     FROM BXDSnpPosition
                                                     WHERE Chr = '%s' AND
@@ -87,19 +87,19 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                                           StrainId1 = %d AND StrainId2 = %d
                                                     """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
 
-						newdict2["snpDensity"] = newdict2["snpCount"] / \
-							(newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
-					else:
-						newdict2["snpDensity"] = newdict2["snpCount"] = 0
+                        newdict2["snpDensity"] = newdict2["snpCount"] / \
+                                (newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
+                    else:
+                        newdict2["snpDensity"] = newdict2["snpCount"] = 0
 
-					try:
-						newdict2['GeneLength'] = 1000.0 * \
-							(newdict2['TxEnd'] - newdict2['TxStart'])
-					except:
-						pass
+                    try:
+                        newdict2['GeneLength'] = 1000.0 * \
+                                (newdict2['TxEnd'] - newdict2['TxStart'])
+                    except:
+                        pass
 
-				newdict['%sGene' % othSpec] = newdict2
+                newdict['%sGene' % othSpec] = newdict2
 
-			GeneList.append(newdict)
+            GeneList.append(newdict)
 
-	return GeneList
+    return GeneList
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index 8d0134d8..c68e0fde 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -395,17 +395,17 @@ class DisplayMappingResults:
 
         # Darwing Options
         try:
-           if self.selectedChr > -1:
-               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
-                   self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
-           else:
-               self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
-                   self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+            if self.selectedChr > -1:
+                self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
+                    self.GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
+            else:
+                self.graphWidth = min(self.GRAPH_MAX_WIDTH, max(
+                    self.MULT_GRAPH_MIN_WIDTH, int(start_vars['graphWidth'])))
         except:
-           if self.selectedChr > -1:
-               self.graphWidth = self.GRAPH_DEFAULT_WIDTH
-           else:
-               self.graphWidth = self.MULT_GRAPH_DEFAULT_WIDTH
+            if self.selectedChr > -1:
+                self.graphWidth = self.GRAPH_DEFAULT_WIDTH
+            else:
+                self.graphWidth = self.MULT_GRAPH_DEFAULT_WIDTH
 
 # BEGIN HaplotypeAnalyst
         if 'haplotypeAnalystCheck' in list(start_vars.keys()):
@@ -574,15 +574,15 @@ class DisplayMappingResults:
                     chrName, self.diffCol, self.startMb, self.endMb, "rat")
 
             if self.geneCol and self.intervalAnalystChecked:
-               #######################################################################
-               #Nick use GENEID as RefGene to get Literature Correlation Informations#
-               #For Interval Mapping, Literature Correlation isn't useful, so skip it#
-               #through set GENEID is None                                           #
-               #######################################################################
+                #######################################################################
+                #Nick use GENEID as RefGene to get Literature Correlation Informations#
+                #For Interval Mapping, Literature Correlation isn't useful, so skip it#
+                #through set GENEID is None                                           #
+                #######################################################################
 
-               GENEID = None
+                GENEID = None
 
-               self.geneTable(self.geneCol, GENEID)
+                self.geneTable(self.geneCol, GENEID)
 
         ################################################################
         # Plots goes here
@@ -2636,11 +2636,11 @@ class DisplayMappingResults:
                     LRSCoordXY.append((Xc, Yc))
 
                 if not self.multipleInterval and self.additiveChecked:
-                   if additiveMax == 0.0:
-                       additiveMax = 0.000001
-                   Yc = yZero - qtlresult['additive'] * \
-                       AdditiveHeightThresh / additiveMax
-                   AdditiveCoordXY.append((Xc, Yc))
+                    if additiveMax == 0.0:
+                        additiveMax = 0.000001
+                    Yc = yZero - qtlresult['additive'] * \
+                        AdditiveHeightThresh / additiveMax
+                    AdditiveCoordXY.append((Xc, Yc))
 
                 m += 1
 
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index b3c9fddf..32dbad1f 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -294,13 +294,13 @@ def add_categorical_covar(cross, covar_as_string, i):
     col_names = []
     # logger.info("loop")
     for x in range(1, (nCol + 1)):
-      #logger.info("loop" + str(x));
-      col_name = "covar_" + str(i) + "_" + str(x)
-      #logger.info("col_name" + col_name);
-      ro.r('the_cross$pheno <- cbind(pheno, ' + \
-           col_name + ' = newcovar[,' + str(x) + '])')
-      col_names.append(col_name)
-      #logger.info("loop" + str(x) + "done");
+        #logger.info("loop" + str(x));
+        col_name = "covar_" + str(i) + "_" + str(x)
+        #logger.info("col_name" + col_name);
+        ro.r('the_cross$pheno <- cbind(pheno, ' + \
+             col_name + ' = newcovar[,' + str(x) + '])')
+        col_names.append(col_name)
+        #logger.info("loop" + str(x) + "done");
 
     logger.info("returning from add_categorical_covar")
     return ro.r["the_cross"], col_names
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index d9b28fba..041f4348 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -65,10 +65,10 @@ class RunMapping:
         # ZS: Sometimes a group may have a genofile that only includes a subset of samples
         genofile_samplelist = []
         if 'genofile' in start_vars:
-          if start_vars['genofile'] != "":
-            self.genofile_string = start_vars['genofile']
-            self.dataset.group.genofile = self.genofile_string.split(":")[0]
-            genofile_samplelist = get_genofile_samplelist(self.dataset)
+            if start_vars['genofile'] != "":
+                self.genofile_string = start_vars['genofile']
+                self.dataset.group.genofile = self.genofile_string.split(":")[0]
+                genofile_samplelist = get_genofile_samplelist(self.dataset)
 
         all_samples_ordered = self.dataset.group.all_samples_ordered()
 
@@ -324,182 +324,182 @@ class RunMapping:
 
         self.no_results = False
         if len(results) == 0:
-          self.no_results = True
+            self.no_results = True
         else:
-          if self.pair_scan == True:
-              self.qtl_results = []
-              highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
-              for marker in results:
-                  if marker['chr1'] > 0 or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
-                      if marker['chr1'] > highest_chr or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
-                          highest_chr = marker['chr1']
-                      if 'lod_score' in list(marker.keys()):
-                          self.qtl_results.append(marker)
-
-              self.trimmed_markers = results
-
-              for qtl in enumerate(self.qtl_results):
-                  self.json_data['chr1'].append(str(qtl['chr1']))
-                  self.json_data['chr2'].append(str(qtl['chr2']))
-                  self.json_data['Mb'].append(qtl['Mb'])
-                  self.json_data['markernames'].append(qtl['name'])
-
-              self.js_data = dict(
-                  json_data=self.json_data,
-                  this_trait=self.this_trait.name,
-                  data_set=self.dataset.name,
-                  maf=self.maf,
-                  manhattan_plot=self.manhattan_plot,
-                  mapping_scale=self.mapping_scale,
-                  qtl_results=self.qtl_results
-              )
-
-          else:
-              self.qtl_results = []
-              self.results_for_browser = []
-              self.annotations_for_browser = []
-              highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
-              for marker in results:
-                  if 'Mb' in marker:
-                      this_ps = marker['Mb'] * 1000000
-                  else:
-                      this_ps = marker['cM'] * 1000000
-
-                  browser_marker = dict(
-                      chr=str(marker['chr']),
-                      rs=marker['name'],
-                      ps=this_ps,
-                      url="/show_trait?trait_id=" + \
-                          marker['name'] + "&dataset=" + \
-                              self.dataset.group.name + "Geno"
-                  )
-
-                  if self.geno_db_exists == "True":
-                      annot_marker = dict(
-                          name=str(marker['name']),
-                          chr=str(marker['chr']),
-                          rs=marker['name'],
-                          pos=this_ps,
-                          url="/show_trait?trait_id=" + \
-                              marker['name'] + "&dataset=" + \
-                                  self.dataset.group.name + "Geno"
-                      )
-                  else:
-                      annot_marker = dict(
-                          name=str(marker['name']),
-                          chr=str(marker['chr']),
-                          rs=marker['name'],
-                          pos=this_ps
-                      )
-
-                  if 'lrs_value' in marker and marker['lrs_value'] > 0:
-                      browser_marker['p_wald'] = 10**- \
-                          (marker['lrs_value'] / 4.61)
-                  elif 'lod_score' in marker and marker['lod_score'] > 0:
-                      browser_marker['p_wald'] = 10**-(marker['lod_score'])
-                  else:
-                      browser_marker['p_wald'] = 0
-
-                  self.results_for_browser.append(browser_marker)
-                  self.annotations_for_browser.append(annot_marker)
-                  if str(marker['chr']) > '0' or str(marker['chr']) == "X" or str(marker['chr']) == "X/Y":
-                      if str(marker['chr']) > str(highest_chr) or str(marker['chr']) == "X" or str(marker['chr']) == "X/Y":
-                          highest_chr = marker['chr']
-                      if ('lod_score' in marker.keys()) or ('lrs_value' in marker.keys()):
-                          if 'Mb' in marker.keys():
-                              marker['display_pos'] = "Chr" + \
-                                  str(marker['chr']) + ": " + \
-                                      "{:.6f}".format(marker['Mb'])
-                          elif 'cM' in marker.keys():
-                              marker['display_pos'] = "Chr" + \
-                                  str(marker['chr']) + ": " + \
-                                      "{:.3f}".format(marker['cM'])
-                          else:
-                              marker['display_pos'] = "N/A"
-                          self.qtl_results.append(marker)
-
-              total_markers = len(self.qtl_results)
-
-              with Bench("Exporting Results"):
-                  export_mapping_results(self.dataset, self.this_trait, self.qtl_results, self.mapping_results_path,
-                                         self.mapping_scale, self.score_type, self.transform, self.covariates, self.n_samples)
-
-              with Bench("Trimming Markers for Figure"):
-                  if len(self.qtl_results) > 30000:
-                      self.qtl_results = trim_markers_for_figure(
-                          self.qtl_results)
-                      self.results_for_browser = trim_markers_for_figure(
-                          self.results_for_browser)
-                      filtered_annotations = []
-                      for marker in self.results_for_browser:
-                          for annot_marker in self.annotations_for_browser:
-                              if annot_marker['rs'] == marker['rs']:
-                                  filtered_annotations.append(annot_marker)
-                                  break
-                      self.annotations_for_browser = filtered_annotations
-                      browser_files = write_input_for_browser(
-                          self.dataset, self.results_for_browser, self.annotations_for_browser)
-                  else:
-                      browser_files = write_input_for_browser(
-                          self.dataset, self.results_for_browser, self.annotations_for_browser)
-
-              with Bench("Trimming Markers for Table"):
-                  self.trimmed_markers = trim_markers_for_table(results)
-
-              chr_lengths = get_chr_lengths(
-                  self.mapping_scale, self.mapping_method, self.dataset, self.qtl_results)
-
-              # ZS: For zooming into genome browser, need to pass chromosome name instead of number
-              if self.dataset.group.species == "mouse":
-                  if self.selected_chr == 20:
-                      this_chr = "X"
-                  else:
-                      this_chr = str(self.selected_chr)
-              elif self.dataset.group.species == "rat":
-                  if self.selected_chr == 21:
-                      this_chr = "X"
-                  else:
-                      this_chr = str(self.selected_chr)
-              else:
-                  if self.selected_chr == 22:
-                      this_chr = "X"
-                  elif self.selected_chr == 23:
-                      this_chr = "Y"
-                  else:
-                      this_chr = str(self.selected_chr)
-
-              if self.mapping_method != "gemma":
-                  if self.score_type == "LRS":
-                      significant_for_browser = self.significant / 4.61
-                  else:
-                      significant_for_browser = self.significant
-
-                  self.js_data = dict(
-                      #result_score_type = self.score_type,
-                      #this_trait = self.this_trait.name,
-                      #data_set = self.dataset.name,
-                      #maf = self.maf,
-                      #manhattan_plot = self.manhattan_plot,
-                      #mapping_scale = self.mapping_scale,
-                      #chromosomes = chromosome_mb_lengths,
-                      #qtl_results = self.qtl_results,
-                      categorical_vars=self.categorical_vars,
-                      chr_lengths=chr_lengths,
-                      num_perm=self.num_perm,
-                      perm_results=self.perm_output,
-                      significant=significant_for_browser,
-                      browser_files=browser_files,
-                      selected_chr=this_chr,
-                      total_markers=total_markers
-                  )
-              else:
+            if self.pair_scan == True:
+                self.qtl_results = []
+                highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
+                for marker in results:
+                    if marker['chr1'] > 0 or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
+                        if marker['chr1'] > highest_chr or marker['chr1'] == "X" or marker['chr1'] == "X/Y":
+                            highest_chr = marker['chr1']
+                        if 'lod_score' in list(marker.keys()):
+                            self.qtl_results.append(marker)
+
+                self.trimmed_markers = results
+
+                for qtl in enumerate(self.qtl_results):
+                    self.json_data['chr1'].append(str(qtl['chr1']))
+                    self.json_data['chr2'].append(str(qtl['chr2']))
+                    self.json_data['Mb'].append(qtl['Mb'])
+                    self.json_data['markernames'].append(qtl['name'])
+
                 self.js_data = dict(
-                    chr_lengths=chr_lengths,
-                    browser_files=browser_files,
-                    selected_chr=this_chr,
-                    total_markers=total_markers
+                    json_data=self.json_data,
+                    this_trait=self.this_trait.name,
+                    data_set=self.dataset.name,
+                    maf=self.maf,
+                    manhattan_plot=self.manhattan_plot,
+                    mapping_scale=self.mapping_scale,
+                    qtl_results=self.qtl_results
                 )
 
+            else:
+                self.qtl_results = []
+                self.results_for_browser = []
+                self.annotations_for_browser = []
+                highest_chr = 1  # This is needed in order to convert the highest chr to X/Y
+                for marker in results:
+                    if 'Mb' in marker:
+                        this_ps = marker['Mb'] * 1000000
+                    else:
+                        this_ps = marker['cM'] * 1000000
+
+                    browser_marker = dict(
+                        chr=str(marker['chr']),
+                        rs=marker['name'],
+                        ps=this_ps,
+                        url="/show_trait?trait_id=" + \
+                            marker['name'] + "&dataset=" + \
+                                self.dataset.group.name + "Geno"
+                    )
+
+                    if self.geno_db_exists == "True":
+                        annot_marker = dict(
+                            name=str(marker['name']),
+                            chr=str(marker['chr']),
+                            rs=marker['name'],
+                            pos=this_ps,
+                            url="/show_trait?trait_id=" + \
+                                marker['name'] + "&dataset=" + \
+                                    self.dataset.group.name + "Geno"
+                        )
+                    else:
+                        annot_marker = dict(
+                            name=str(marker['name']),
+                            chr=str(marker['chr']),
+                            rs=marker['name'],
+                            pos=this_ps
+                        )
+
+                    if 'lrs_value' in marker and marker['lrs_value'] > 0:
+                        browser_marker['p_wald'] = 10**- \
+                            (marker['lrs_value'] / 4.61)
+                    elif 'lod_score' in marker and marker['lod_score'] > 0:
+                        browser_marker['p_wald'] = 10**-(marker['lod_score'])
+                    else:
+                        browser_marker['p_wald'] = 0
+
+                    self.results_for_browser.append(browser_marker)
+                    self.annotations_for_browser.append(annot_marker)
+                    if str(marker['chr']) > '0' or str(marker['chr']) == "X" or str(marker['chr']) == "X/Y":
+                        if str(marker['chr']) > str(highest_chr) or str(marker['chr']) == "X" or str(marker['chr']) == "X/Y":
+                            highest_chr = marker['chr']
+                        if ('lod_score' in marker.keys()) or ('lrs_value' in marker.keys()):
+                            if 'Mb' in marker.keys():
+                                marker['display_pos'] = "Chr" + \
+                                    str(marker['chr']) + ": " + \
+                                        "{:.6f}".format(marker['Mb'])
+                            elif 'cM' in marker.keys():
+                                marker['display_pos'] = "Chr" + \
+                                    str(marker['chr']) + ": " + \
+                                        "{:.3f}".format(marker['cM'])
+                            else:
+                                marker['display_pos'] = "N/A"
+                            self.qtl_results.append(marker)
+
+                total_markers = len(self.qtl_results)
+
+                with Bench("Exporting Results"):
+                    export_mapping_results(self.dataset, self.this_trait, self.qtl_results, self.mapping_results_path,
+                                           self.mapping_scale, self.score_type, self.transform, self.covariates, self.n_samples)
+
+                with Bench("Trimming Markers for Figure"):
+                    if len(self.qtl_results) > 30000:
+                        self.qtl_results = trim_markers_for_figure(
+                            self.qtl_results)
+                        self.results_for_browser = trim_markers_for_figure(
+                            self.results_for_browser)
+                        filtered_annotations = []
+                        for marker in self.results_for_browser:
+                            for annot_marker in self.annotations_for_browser:
+                                if annot_marker['rs'] == marker['rs']:
+                                    filtered_annotations.append(annot_marker)
+                                    break
+                        self.annotations_for_browser = filtered_annotations
+                        browser_files = write_input_for_browser(
+                            self.dataset, self.results_for_browser, self.annotations_for_browser)
+                    else:
+                        browser_files = write_input_for_browser(
+                            self.dataset, self.results_for_browser, self.annotations_for_browser)
+
+                with Bench("Trimming Markers for Table"):
+                    self.trimmed_markers = trim_markers_for_table(results)
+
+                chr_lengths = get_chr_lengths(
+                    self.mapping_scale, self.mapping_method, self.dataset, self.qtl_results)
+
+                # ZS: For zooming into genome browser, need to pass chromosome name instead of number
+                if self.dataset.group.species == "mouse":
+                    if self.selected_chr == 20:
+                        this_chr = "X"
+                    else:
+                        this_chr = str(self.selected_chr)
+                elif self.dataset.group.species == "rat":
+                    if self.selected_chr == 21:
+                        this_chr = "X"
+                    else:
+                        this_chr = str(self.selected_chr)
+                else:
+                    if self.selected_chr == 22:
+                        this_chr = "X"
+                    elif self.selected_chr == 23:
+                        this_chr = "Y"
+                    else:
+                        this_chr = str(self.selected_chr)
+
+                if self.mapping_method != "gemma":
+                    if self.score_type == "LRS":
+                        significant_for_browser = self.significant / 4.61
+                    else:
+                        significant_for_browser = self.significant
+
+                    self.js_data = dict(
+                        #result_score_type = self.score_type,
+                        #this_trait = self.this_trait.name,
+                        #data_set = self.dataset.name,
+                        #maf = self.maf,
+                        #manhattan_plot = self.manhattan_plot,
+                        #mapping_scale = self.mapping_scale,
+                        #chromosomes = chromosome_mb_lengths,
+                        #qtl_results = self.qtl_results,
+                        categorical_vars=self.categorical_vars,
+                        chr_lengths=chr_lengths,
+                        num_perm=self.num_perm,
+                        perm_results=self.perm_output,
+                        significant=significant_for_browser,
+                        browser_files=browser_files,
+                        selected_chr=this_chr,
+                        total_markers=total_markers
+                    )
+                else:
+                    self.js_data = dict(
+                        chr_lengths=chr_lengths,
+                        browser_files=browser_files,
+                        selected_chr=this_chr,
+                        total_markers=total_markers
+                    )
+
     def run_rqtl_plink(self):
         # os.chdir("") never do this inside a webserver!!
 
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index 7b9ff8fe..55b0278a 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -36,7 +36,7 @@ class User(Base):
 
     # json detailing when they became a superuser, otherwise empty
     superuser = Column(Text)
-                             # if not superuser
+                       # if not superuser
 
     logins = relationship("Login",
                           order_by="desc(Login.timestamp)",
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index 0d2fb2f8..2e1cb992 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -78,7 +78,7 @@ class SearchResultPage:
         try:
             self.search()
         except:
-           self.search_term_exists = False
+            self.search_term_exists = False
 
         self.too_many_results = False
         if self.search_term_exists:
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index bfaed9c2..725e7c9e 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -464,49 +464,49 @@ def password_reset_step2():
 
 
 def register_user(params):
-        thank_you_mode = False
-        errors = []
-        user_details = {}
-
-        user_details['email_address'] = params.get(
-            'email_address', '').encode("utf-8").strip()
-        if not (5 <= len(user_details['email_address']) <= 50):
-            errors.append(
-                'Email Address needs to be between 5 and 50 characters.')
-        else:
-            email_exists = get_user_by_unique_column(
-                "email_address", user_details['email_address'])
-            if email_exists:
-                errors.append('User already exists with that email')
+    thank_you_mode = False
+    errors = []
+    user_details = {}
 
-        user_details['full_name'] = params.get(
-            'full_name', '').encode("utf-8").strip()
-        if not (5 <= len(user_details['full_name']) <= 50):
-            errors.append('Full Name needs to be between 5 and 50 characters.')
+    user_details['email_address'] = params.get(
+        'email_address', '').encode("utf-8").strip()
+    if not (5 <= len(user_details['email_address']) <= 50):
+        errors.append(
+            'Email Address needs to be between 5 and 50 characters.')
+    else:
+        email_exists = get_user_by_unique_column(
+            "email_address", user_details['email_address'])
+        if email_exists:
+            errors.append('User already exists with that email')
 
-        user_details['organization'] = params.get(
-            'organization', '').encode("utf-8").strip()
-        if user_details['organization'] and not (5 <= len(user_details['organization']) <= 50):
-            errors.append(
-                'Organization needs to be empty or between 5 and 50 characters.')
+    user_details['full_name'] = params.get(
+        'full_name', '').encode("utf-8").strip()
+    if not (5 <= len(user_details['full_name']) <= 50):
+        errors.append('Full Name needs to be between 5 and 50 characters.')
 
-        password = str(params.get('password', ''))
-        if not (6 <= len(password)):
-            errors.append('Password needs to be at least 6 characters.')
+    user_details['organization'] = params.get(
+        'organization', '').encode("utf-8").strip()
+    if user_details['organization'] and not (5 <= len(user_details['organization']) <= 50):
+        errors.append(
+            'Organization needs to be empty or between 5 and 50 characters.')
 
-        if params.get('password_confirm') != password:
-            errors.append("Passwords don't match.")
+    password = str(params.get('password', ''))
+    if not (6 <= len(password)):
+        errors.append('Password needs to be at least 6 characters.')
 
-        user_details['password'] = set_password(password)
-        user_details['user_id'] = str(uuid.uuid4())
-        user_details['confirmed'] = 1
+    if params.get('password_confirm') != password:
+        errors.append("Passwords don't match.")
 
-        user_details['registration_info'] = basic_info()
+    user_details['password'] = set_password(password)
+    user_details['user_id'] = str(uuid.uuid4())
+    user_details['confirmed'] = 1
 
-        if len(errors) == 0:
-            save_user(user_details, user_details['user_id'])
+    user_details['registration_info'] = basic_info()
+
+    if len(errors) == 0:
+        save_user(user_details, user_details['user_id'])
 
-        return errors
+    return errors
 
 
 @app.route("/n/register", methods=('GET', 'POST'))
-- 
cgit v1.2.3


From 4e65b73a0f903834f8dbd02d11c49b75d7c935c7 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 13:06:58 +0300
Subject: autopep8: Fix E121,E122,E123,EI24,E125,E126,E127,E128,E129,E131,E133

---
 wqflask/base/data_set.py                           |   2 +-
 wqflask/maintenance/convert_geno_to_bimbam.py      |   6 +-
 wqflask/maintenance/gen_select_dataset.py          |   8 +-
 .../maintenance/generate_kinship_from_bimbam.py    |   4 +-
 wqflask/maintenance/geno_to_json.py                |   4 +-
 wqflask/maintenance/quantile_normalize.py          |  16 +--
 wqflask/maintenance/set_resource_defaults.py       |  30 ++--
 wqflask/tests/unit/base/test_webqtl_case_data.py   |   8 +-
 wqflask/tests/unit/wqflask/api/test_correlation.py |   4 +-
 .../marker_regression/test_gemma_mapping.py        |  14 +-
 .../marker_regression/test_qtlreaper_mapping.py    |   2 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |   2 +-
 .../unit/wqflask/snp_browser/test_snp_browser.py   |  12 +-
 wqflask/tests/unit/wqflask/test_server_side.py     |   2 +-
 wqflask/utility/Plot.py                            |   2 +-
 wqflask/utility/__init__.py                        |   2 +-
 wqflask/utility/elasticsearch_tools.py             |   2 +-
 wqflask/utility/genofile_parser.py                 |  10 +-
 wqflask/utility/startup_config.py                  |   2 +-
 wqflask/utility/tools.py                           |   4 +-
 wqflask/utility/webqtlUtil.py                      |  46 +++---
 wqflask/wqflask/api/correlation.py                 |   2 +-
 wqflask/wqflask/api/mapping.py                     |  14 +-
 wqflask/wqflask/api/router.py                      | 118 ++++++++--------
 wqflask/wqflask/collect.py                         |  14 +-
 .../comparison_bar_chart/comparison_bar_chart.py   |   6 +-
 wqflask/wqflask/correlation/show_corr_results.py   | 122 ++++++++--------
 .../wqflask/correlation_matrix/show_corr_matrix.py |   4 +-
 wqflask/wqflask/ctl/ctl_analysis.py                |  18 +--
 wqflask/wqflask/do_search.py                       | 156 ++++++++++-----------
 wqflask/wqflask/export_traits.py                   |   6 +-
 wqflask/wqflask/external_tools/send_to_bnw.py      |   2 +-
 .../wqflask/external_tools/send_to_geneweaver.py   |  12 +-
 .../wqflask/external_tools/send_to_webgestalt.py   |   6 +-
 wqflask/wqflask/group_manager.py                   |  20 +--
 wqflask/wqflask/gsearch.py                         |  46 +++---
 wqflask/wqflask/heatmap/heatmap.py                 |  16 +--
 wqflask/wqflask/interval_analyst/GeneUtil.py       |  20 +--
 wqflask/wqflask/markdown_routes.py                 |   2 +-
 .../marker_regression/display_mapping_results.py   |  72 +++++-----
 .../wqflask/marker_regression/qtlreaper_mapping.py |  46 +++---
 wqflask/wqflask/marker_regression/rqtl_mapping.py  |   4 +-
 wqflask/wqflask/marker_regression/run_mapping.py   |  34 ++---
 wqflask/wqflask/model.py                           |   4 +-
 wqflask/wqflask/parser.py                          |   2 +-
 wqflask/wqflask/search_results.py                  |  10 +-
 wqflask/wqflask/server_side.py                     |   4 +-
 wqflask/wqflask/show_trait/SampleList.py           |   4 +-
 wqflask/wqflask/show_trait/export_trait_data.py    |   4 +-
 wqflask/wqflask/snp_browser/snp_browser.py         |  22 +--
 wqflask/wqflask/user_login.py                      |  34 ++---
 wqflask/wqflask/user_manager.py                    |   2 +-
 wqflask/wqflask/user_session.py                    |   8 +-
 wqflask/wqflask/wgcna/wgcna_analysis.py            |   2 +-
 54 files changed, 509 insertions(+), 509 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/data_set.py b/wqflask/base/data_set.py
index 5eac695e..e20f2f98 100644
--- a/wqflask/base/data_set.py
+++ b/wqflask/base/data_set.py
@@ -151,7 +151,7 @@ class DatasetType:
                             "WHERE InbredSet.Name = '%s' AND "
                             "PublishFreeze.InbredSetId = InbredSet.Id"),
             'geno': ("SELECT GenoFreeze.Id FROM GenoFreeze WHERE "
-                      "GenoFreeze.Name = \"%s\" ")
+                     "GenoFreeze.Name = \"%s\" ")
         }
 
         dataset_name_mapping = {
diff --git a/wqflask/maintenance/convert_geno_to_bimbam.py b/wqflask/maintenance/convert_geno_to_bimbam.py
index c5af1ca6..078be529 100644
--- a/wqflask/maintenance/convert_geno_to_bimbam.py
+++ b/wqflask/maintenance/convert_geno_to_bimbam.py
@@ -56,7 +56,7 @@ class ConvertGenoFile:
             '@pat': "0",
             '@het': "0.5",
             '@unk': "NA"
-            }
+        }
 
         self.configurations = {}
         self.input_fh = open(self.input_file)
@@ -171,7 +171,7 @@ class ConvertGenoFile:
             snp_output_file = os.path.join(
                 new_directory, group_name + "_snps.txt")
             output_files = [geno_output_file,
-                pheno_output_file, snp_output_file]
+                            pheno_output_file, snp_output_file]
             print("%s -> %s" % (
                 os.path.join(old_directory, input_file), geno_output_file))
             convertob = ConvertGenoFile(input_file, output_files)
@@ -184,7 +184,7 @@ class ConvertGenoFile:
                 print("  Exception:", why)
                 print(traceback.print_exc())
                 print("    Found in row %s at tabular column %s" % (convertob.latest_row_pos,
-                                                                convertob.latest_col_pos))
+                                                                    convertob.latest_col_pos))
                 print("    Column is:", convertob.latest_col_value)
                 print("    Row is:", convertob.latest_row_value)
                 break
diff --git a/wqflask/maintenance/gen_select_dataset.py b/wqflask/maintenance/gen_select_dataset.py
index 484336a6..db65a11f 100644
--- a/wqflask/maintenance/gen_select_dataset.py
+++ b/wqflask/maintenance/gen_select_dataset.py
@@ -62,10 +62,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db=parsed_uri.path[1:],
-                        host=parsed_uri.hostname,
-                        user=parsed_uri.username,
-                        passwd=parsed_uri.password)
+        db=parsed_uri.path[1:],
+        host=parsed_uri.hostname,
+        user=parsed_uri.username,
+        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
diff --git a/wqflask/maintenance/generate_kinship_from_bimbam.py b/wqflask/maintenance/generate_kinship_from_bimbam.py
index cd39fceb..9f01d094 100644
--- a/wqflask/maintenance/generate_kinship_from_bimbam.py
+++ b/wqflask/maintenance/generate_kinship_from_bimbam.py
@@ -23,7 +23,7 @@ class GenerateKinshipMatrices:
     def generate_kinship(self):
         gemma_command = "/gnu/store/xhzgjr0jvakxv6h3blj8z496xjig69b0-profile/bin/gemma -g " + self.geno_file + \
             " -p " + self.pheno_file + \
-                " -gk 1 -outdir /home/zas1024/genotype_files/genotype/bimbam/ -o " + self.group_name
+            " -gk 1 -outdir /home/zas1024/genotype_files/genotype/bimbam/ -o " + self.group_name
         print("command:", gemma_command)
         os.system(gemma_command)
 
@@ -52,7 +52,7 @@ class GenerateKinshipMatrices:
                 print("  Exception:", why)
                 print(traceback.print_exc())
                 print("    Found in row %s at tabular column %s" % (convertob.latest_row_pos,
-                                                                convertob.latest_col_pos))
+                                                                    convertob.latest_col_pos))
                 print("    Column is:", convertob.latest_col_value)
                 print("    Row is:", convertob.latest_row_value)
                 break
diff --git a/wqflask/maintenance/geno_to_json.py b/wqflask/maintenance/geno_to_json.py
index c74489a8..32e0e34b 100644
--- a/wqflask/maintenance/geno_to_json.py
+++ b/wqflask/maintenance/geno_to_json.py
@@ -63,7 +63,7 @@ class ConvertGenoFile:
             '@pat': "0",
             '@het': "0.5",
             '@unk': "NA"
-            }
+        }
 
         self.configurations = {}
         #self.skipped_cols = 3
@@ -172,7 +172,7 @@ class ConvertGenoFile:
                 print("  Exception:", why)
                 print(traceback.print_exc())
                 print("    Found in row %s at tabular column %s" % (convertob.latest_row_pos,
-                                                                convertob.latest_col_pos))
+                                                                    convertob.latest_col_pos))
                 print("    Column is:", convertob.latest_col_value)
                 print("    Row is:", convertob.latest_row_value)
                 break
diff --git a/wqflask/maintenance/quantile_normalize.py b/wqflask/maintenance/quantile_normalize.py
index ac7689f5..88bb2cb5 100644
--- a/wqflask/maintenance/quantile_normalize.py
+++ b/wqflask/maintenance/quantile_normalize.py
@@ -21,10 +21,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db=parsed_uri.path[1:],
-                        host=parsed_uri.hostname,
-                        user=parsed_uri.username,
-                        passwd=parsed_uri.password)
+        db=parsed_uri.path[1:],
+        host=parsed_uri.hostname,
+        user=parsed_uri.username,
+        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
@@ -70,10 +70,10 @@ def set_data(dataset_name):
                 trait_name = line1.split('\t')[0]
                 for i, sample in enumerate(sample_names):
                     this_sample = {
-                                    "name": sample,
-                                    "value": line1.split('\t')[i + 1],
-                                    "qnorm": line2.split('\t')[i + 1]
-                                  }
+                        "name": sample,
+                        "value": line1.split('\t')[i + 1],
+                        "qnorm": line2.split('\t')[i + 1]
+                    }
                     sample_list.append(this_sample)
                 query = """SELECT Species.SpeciesName, InbredSet.InbredSetName, ProbeSetFreeze.FullName
                            FROM Species, InbredSet, ProbeSetFreeze, ProbeFreeze, ProbeSetXRef, ProbeSet
diff --git a/wqflask/maintenance/set_resource_defaults.py b/wqflask/maintenance/set_resource_defaults.py
index c6c4f44c..0f472494 100644
--- a/wqflask/maintenance/set_resource_defaults.py
+++ b/wqflask/maintenance/set_resource_defaults.py
@@ -44,10 +44,10 @@ def parse_db_uri():
     parsed_uri = urllib.parse.urlparse(SQL_URI)
 
     db_conn_info = dict(
-                        db=parsed_uri.path[1:],
-                        host=parsed_uri.hostname,
-                        user=parsed_uri.username,
-                        passwd=parsed_uri.password)
+        db=parsed_uri.path[1:],
+        host=parsed_uri.hostname,
+        user=parsed_uri.username,
+        passwd=parsed_uri.password)
 
     print(db_conn_info)
     return db_conn_info
@@ -69,12 +69,12 @@ def insert_probeset_resources(default_owner_id):
         resource_ob['type'] = "dataset-probeset"
         if resource[2] < 1 and resource[3] > 0:
             resource_ob['default_mask'] = {"data": "view",
-                                            "metadata": "view",
-                                            "admin": "not-admin"}
+                                           "metadata": "view",
+                                           "admin": "not-admin"}
         else:
             resource_ob['default_mask'] = {"data": "no-access",
-                                            "metadata": "no-access",
-                                            "admin": "not-admin"}
+                                           "metadata": "no-access",
+                                           "admin": "not-admin"}
         resource_ob['group_masks'] = {}
 
         add_resource(resource_ob, update=False)
@@ -101,11 +101,11 @@ def insert_publish_resources(default_owner_id):
                 resource_ob['name'] = str(resource[0])
             resource_ob['owner_id'] = default_owner_id
             resource_ob['data'] = {"dataset": str(resource[1]),
-                                    "trait": str(resource[0])}
+                                   "trait": str(resource[0])}
             resource_ob['type'] = "dataset-publish"
             resource_ob['default_mask'] = {"data": "view",
-                                            "metadata": "view",
-                                            "admin": "not-admin"}
+                                           "metadata": "view",
+                                           "admin": "not-admin"}
 
             resource_ob['group_masks'] = {}
 
@@ -133,12 +133,12 @@ def insert_geno_resources(default_owner_id):
         resource_ob['type'] = "dataset-geno"
         if resource[2] < 1:
             resource_ob['default_mask'] = {"data": "view",
-                                            "metadata": "view",
-                                            "admin": "not-admin"}
+                                           "metadata": "view",
+                                           "admin": "not-admin"}
         else:
             resource_ob['default_mask'] = {"data": "no-access",
-                                            "metadata": "no-access",
-                                            "admin": "not-admin"}
+                                           "metadata": "no-access",
+                                           "admin": "not-admin"}
         resource_ob['group_masks'] = {}
 
         add_resource(resource_ob, update=False)
diff --git a/wqflask/tests/unit/base/test_webqtl_case_data.py b/wqflask/tests/unit/base/test_webqtl_case_data.py
index cebd41ce..e1555cb4 100644
--- a/wqflask/tests/unit/base/test_webqtl_case_data.py
+++ b/wqflask/tests/unit/base/test_webqtl_case_data.py
@@ -10,10 +10,10 @@ class TestWebqtlCaseData(unittest.TestCase):
 
     def setUp(self):
         self.w = webqtlCaseData(name="Test",
-                           value=0,
-                           variance=0.0,
-                           num_cases=10,
-                           name2="Test2")
+                                value=0,
+                                variance=0.0,
+                                num_cases=10,
+                                name2="Test2")
 
     def test_webqtl_case_data_repr(self):
         self.assertEqual(
diff --git a/wqflask/tests/unit/wqflask/api/test_correlation.py b/wqflask/tests/unit/wqflask/api/test_correlation.py
index 34ffa9ef..1089a36f 100644
--- a/wqflask/tests/unit/wqflask/api/test_correlation.py
+++ b/wqflask/tests/unit/wqflask/api/test_correlation.py
@@ -106,9 +106,9 @@ class TestCorrelations(unittest.TestCase):
 
         target_vals = [3.4, 6.2, 4.1, 3.4, 1.2, 5.6]
         trait_data = {"S1": AttributeSetter({"value": 2.3}), "S2": AttributeSetter({"value": 1.1}),
-        "S3": AttributeSetter(
+                      "S3": AttributeSetter(
             {"value": 6.3}), "S4": AttributeSetter({"value": 3.6}), "S5": AttributeSetter({"value": 4.1}),
-        "S6": AttributeSetter({"value": 5.0})}
+            "S6": AttributeSetter({"value": 5.0})}
         this_trait = AttributeSetter({"data": trait_data})
         mock_normalize.return_value = ([2.3, 1.1, 6.3, 3.6, 4.1, 5.0],
                                        [3.4, 6.2, 4.1, 3.4, 1.2, 5.6], 6)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index 5cbaf0e0..4003d68f 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -162,13 +162,13 @@ X\tM5\t12\tQ\tE\tMMB\tR\t21.1\tW\t0.65\t0.6"""
             results = parse_loco_output(
                 this_dataset={}, gwa_output_filename=".xw/")
             expected_results = [
-            {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85,
-                'additive': 23.3, 'lod_score': 0.07058107428570727},
-            {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5,
-                'additive': 24.0, 'lod_score': 0.3010299956639812},
-            {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7,
-                'additive': 11.6, 'lod_score': 0.1549019599857432},
-            {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': 21.1, 'lod_score': 0.22184874961635637}]
+                {'name': 'M1', 'chr': 'X/Y', 'Mb': 2.8457155e-05, 'p_value': 0.85,
+                 'additive': 23.3, 'lod_score': 0.07058107428570727},
+                {'name': 'M2', 'chr': 4, 'Mb': 1.2e-05, 'p_value': 0.5,
+                 'additive': 24.0, 'lod_score': 0.3010299956639812},
+                {'name': 'M4', 'chr': 'Y', 'Mb': 1.2e-05, 'p_value': 0.7,
+                 'additive': 11.6, 'lod_score': 0.1549019599857432},
+                {'name': 'M5', 'chr': 'X', 'Mb': 1.2e-05, 'p_value': 0.6, 'additive': 21.1, 'lod_score': 0.22184874961635637}]
 
             self.assertEqual(expected_results, results)
 
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index 47377873..93848a84 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -18,6 +18,6 @@ class TestQtlReaperMapping(unittest.TestCase):
             mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
             filehandler = mock_open()
             write_calls = [mock.call('Trait\t'), mock.call(
-                    'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
+                'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
 
             filehandler.write.assert_has_calls(write_calls)
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index e518ec22..68686e27 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -21,7 +21,7 @@ class TestRqtlMapping(unittest.TestCase):
         """test for getting trait data_type return True"""
         query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
         mock_db.db.execute.return_value.fetchone.return_value = [
-                """{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
+            """{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
         results = get_trait_data_type("traid_id")
         mock_db.db.execute.assert_called_with(query_value)
         self.assertEqual(results, "fer434f")
diff --git a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
index 8823e1fc..89442c47 100644
--- a/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
+++ b/wqflask/tests/unit/wqflask/snp_browser/test_snp_browser.py
@@ -22,10 +22,10 @@ class TestSnpBrowser(unittest.TestCase):
         strains = {"mouse": ["S1", "S2", "S3", "S4", "S5"], "rat": []}
         expected_results = ([['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'ConScore',
                               'Domain 1', 'Domain 2', 'Details'],
-                              ['S1', 'S2', 'S3', 'S4', 'S5']], 5,
-                              ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles',
-                              'conservation_score', 'domain_1', 'domain_2',
-                              'function_details', 'S1', 'S2', 'S3', 'S4', 'S5'])
+                             ['S1', 'S2', 'S3', 'S4', 'S5']], 5,
+                            ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles',
+                             'conservation_score', 'domain_1', 'domain_2',
+                             'function_details', 'S1', 'S2', 'S3', 'S4', 'S5'])
 
         results_with_snp = get_header_list(
             variant_type="SNP", strains=strains, species="Mouse", empty_columns=empty_columns)
@@ -34,8 +34,8 @@ class TestSnpBrowser(unittest.TestCase):
         expected_results_with_indel = (
             ['Index', 'ID', 'Type', 'InDel Chr', 'Mb Start',
              'Mb End', 'Strand', 'Size', 'Sequence', 'Source'], 0,
-             ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
-            'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name'])
+            ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
+             'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name'])
 
         self.assertEqual(expected_results, results_with_snp)
         self.assertEqual(expected_results_with_indel, results_with_indel)
diff --git a/wqflask/tests/unit/wqflask/test_server_side.py b/wqflask/tests/unit/wqflask/test_server_side.py
index 9d988aea..be7ca2df 100644
--- a/wqflask/tests/unit/wqflask/test_server_side.py
+++ b/wqflask/tests/unit/wqflask/test_server_side.py
@@ -23,7 +23,7 @@ class TestServerSideTableTests(unittest.TestCase):
         ]
         headers = ['first', 'second', 'third']
         request_args = {'sEcho': '1', 'iSortCol_0': '1', 'iSortingCols': '1',
-            'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'}
+                        'sSortDir_0': 'asc', 'iDisplayStart': '0', 'iDisplayLength': '3'}
 
         test_page = ServerSideTable(
             rows_count, table_rows, headers, request_args).get_page()
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index f61e3b88..37a8a1a5 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -206,7 +206,7 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
         im_drawer.text(
             text=strY,
             xy=(xLeftOffset - im_drawer.textsize(strY,
-                font=scaleFont)[0] - 6, yc + 5),
+                                                 font=scaleFont)[0] - 6, yc + 5),
             font=scaleFont)
         y += (yTop - yLow) / stepY
 
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index 6c8cd546..25273fa0 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -32,4 +32,4 @@ class Struct:
 
     def __repr__(self):
         return '{%s}' % str(', '.join('%s : %s' % (k, repr(v)) for
-            (k, v) in list(self.__dict__.items())))
+                                      (k, v) in list(self.__dict__.items())))
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index 55907dd5..e56c22eb 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -50,7 +50,7 @@ from utility.tools import ELASTICSEARCH_HOST, ELASTICSEARCH_PORT
 
 def test_elasticsearch_connection():
     es = Elasticsearch(['http://' + ELASTICSEARCH_HOST + \
-                       ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
+                        ":" + str(ELASTICSEARCH_PORT) + '/'], verify_certs=True)
     if not es.ping():
         logger.warning("Elasticsearch is DOWN")
 
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index eb545478..86d9823e 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -37,10 +37,10 @@ class ConvertGenoFile:
         self.input_fh = open(input_file)
         print("!!!!!!!!!!!!!!!!PARSER!!!!!!!!!!!!!!!!!!")
         self.haplotype_notation = {
-          '@mat': "1",
-          '@pat': "2",
-          '@het': "-999",
-          '@unk': "-999"
+            '@mat': "1",
+            '@pat': "2",
+            '@het': "-999",
+            '@unk': "-999"
         }
         self.configurations = {}
 
@@ -93,7 +93,7 @@ class ConvertGenoFile:
             for item_count, genotype in enumerate(genotypes):
                 if genotype.upper().strip() in self.configurations:
                     this_marker.genotypes.append(
-                      self.configurations[genotype.upper().strip()])
+                        self.configurations[genotype.upper().strip()])
                 else:
                     print("WARNING:", genotype.upper())
                     this_marker.genotypes.append("NA")
diff --git a/wqflask/utility/startup_config.py b/wqflask/utility/startup_config.py
index 05f8a2b0..6ef759e0 100644
--- a/wqflask/utility/startup_config.py
+++ b/wqflask/utility/startup_config.py
@@ -39,4 +39,4 @@ def app_config():
     # es.test_elasticsearch_connection()
 
     print(("GN2 is running. Visit %s[http://localhost:%s/%s](%s)" %
-          (BLUE, str(port), ENDC, get_setting("WEBSERVER_URL"))))
+           (BLUE, str(port), ENDC, get_setting("WEBSERVER_URL"))))
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index 4f09176a..e28abb48 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -295,8 +295,8 @@ ORCID_CLIENT_SECRET = get_setting('ORCID_CLIENT_SECRET')
 ORCID_AUTH_URL = None
 if ORCID_CLIENT_ID != 'UNKNOWN' and ORCID_CLIENT_SECRET:
     ORCID_AUTH_URL = "https://orcid.org/oauth/authorize?response_type=code&scope=/authenticate&show_login=true&client_id=" + \
-                      ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + \
-                          "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
+        ORCID_CLIENT_ID + "&client_secret=" + ORCID_CLIENT_SECRET + \
+        "&redirect_uri=" + GN2_BRANCH_URL + "n/login/orcid_oauth2"
     ORCID_TOKEN_URL = get_setting('ORCID_TOKEN_URL')
 
 ELASTICSEARCH_HOST = get_setting('ELASTICSEARCH_HOST')
diff --git a/wqflask/utility/webqtlUtil.py b/wqflask/utility/webqtlUtil.py
index f355a865..0cb71567 100644
--- a/wqflask/utility/webqtlUtil.py
+++ b/wqflask/utility/webqtlUtil.py
@@ -35,29 +35,29 @@ from base import webqtlConfig
 # NL, 07/27/2010. moved from webqtlForm.py
 # Dict of Parents and F1 information, In the order of [F1, Mat, Pat]
 ParInfo = {
-'BXH': ['BHF1', 'HBF1', 'C57BL/6J', 'C3H/HeJ'],
-'AKXD': ['AKF1', 'KAF1', 'AKR/J', 'DBA/2J'],
-'BXD': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'C57BL-6JxC57BL-6NJF2': ['', '', 'C57BL/6J', 'C57BL/6NJ'],
-'BXD300': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'B6BTBRF2': ['B6BTBRF1', 'BTBRB6F1', 'C57BL/6J', 'BTBRT<+>tf/J'],
-'BHHBF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
-'BHF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
-'B6D2F2': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'BDF2-1999': ['B6D2F2', 'D2B6F2', 'C57BL/6J', 'DBA/2J'],
-'BDF2-2005': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
-'CTB6F2': ['CTB6F2', 'B6CTF2', 'C57BL/6J', 'Castaneous'],
-'CXB': ['CBF1', 'BCF1', 'C57BL/6ByJ', 'BALB/cByJ'],
-'AXBXA': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
-'AXB': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
-'BXA': ['BAF1', 'ABF1', 'C57BL/6J', 'A/J'],
-'LXS': ['LSF1', 'SLF1', 'ISS', 'ILS'],
-'HXBBXH': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv'],
-'BayXSha': ['BayXShaF1', 'ShaXBayF1', 'Bay-0', 'Shahdara'],
-'ColXBur': ['ColXBurF1', 'BurXColF1', 'Col-0', 'Bur-0'],
-'ColXCvi': ['ColXCviF1', 'CviXColF1', 'Col-0', 'Cvi'],
-'SXM': ['SMF1', 'MSF1', 'Steptoe', 'Morex'],
-'HRDP': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv']
+    'BXH': ['BHF1', 'HBF1', 'C57BL/6J', 'C3H/HeJ'],
+    'AKXD': ['AKF1', 'KAF1', 'AKR/J', 'DBA/2J'],
+    'BXD': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+    'C57BL-6JxC57BL-6NJF2': ['', '', 'C57BL/6J', 'C57BL/6NJ'],
+    'BXD300': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+    'B6BTBRF2': ['B6BTBRF1', 'BTBRB6F1', 'C57BL/6J', 'BTBRT<+>tf/J'],
+    'BHHBF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
+    'BHF2': ['B6HF2', 'HB6F2', 'C57BL/6J', 'C3H/HeJ'],
+    'B6D2F2': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+    'BDF2-1999': ['B6D2F2', 'D2B6F2', 'C57BL/6J', 'DBA/2J'],
+    'BDF2-2005': ['B6D2F1', 'D2B6F1', 'C57BL/6J', 'DBA/2J'],
+    'CTB6F2': ['CTB6F2', 'B6CTF2', 'C57BL/6J', 'Castaneous'],
+    'CXB': ['CBF1', 'BCF1', 'C57BL/6ByJ', 'BALB/cByJ'],
+    'AXBXA': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
+    'AXB': ['ABF1', 'BAF1', 'C57BL/6J', 'A/J'],
+    'BXA': ['BAF1', 'ABF1', 'C57BL/6J', 'A/J'],
+    'LXS': ['LSF1', 'SLF1', 'ISS', 'ILS'],
+    'HXBBXH': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv'],
+    'BayXSha': ['BayXShaF1', 'ShaXBayF1', 'Bay-0', 'Shahdara'],
+    'ColXBur': ['ColXBurF1', 'BurXColF1', 'Col-0', 'Bur-0'],
+    'ColXCvi': ['ColXCviF1', 'CviXColF1', 'Col-0', 'Cvi'],
+    'SXM': ['SMF1', 'MSF1', 'Steptoe', 'Morex'],
+    'HRDP': ['SHR_BNF1', 'BN_SHRF1', 'BN-Lx/Cub', 'SHR/OlaIpcv']
 }
 
 #########################################
diff --git a/wqflask/wqflask/api/correlation.py b/wqflask/wqflask/api/correlation.py
index 52026a82..870f3275 100644
--- a/wqflask/wqflask/api/correlation.py
+++ b/wqflask/wqflask/api/correlation.py
@@ -88,7 +88,7 @@ def calculate_results(this_trait, this_dataset, target_dataset, corr_params):
         corr_results = do_literature_correlation_for_all_traits(
             this_trait, this_dataset, trait_geneid_dict, corr_params)
         sorted_results = collections.OrderedDict(sorted(list(corr_results.items()),
-                                                 key=lambda t: -abs(t[1][1])))
+                                                        key=lambda t: -abs(t[1][1])))
     else:
         for target_trait, target_vals in list(target_dataset.trait_data.items()):
             result = get_sample_r_and_p_values(
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index e4a3fb77..cbef96eb 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -53,15 +53,15 @@ def do_mapping_for_api(start_vars):
         header_row = ["name", "chr", "cM", "lod_score"]
         if mapping_params['num_perm'] > 0:
             _sperm_output, _suggestive, _significant, result_markers = rqtl_mapping.run_rqtl_geno(vals, dataset, mapping_params['rqtl_method'], mapping_params['rqtl_model'],
-                                                                                        mapping_params['perm_check'], mapping_params['num_perm'],
-                                                                                        mapping_params['do_control'], mapping_params[
-                                                                                            'control_marker'],
-                                                                                        mapping_params['manhattan_plot'], mapping_params['pair_scan'])
+                                                                                                  mapping_params['perm_check'], mapping_params['num_perm'],
+                                                                                                  mapping_params['do_control'], mapping_params[
+                'control_marker'],
+                mapping_params['manhattan_plot'], mapping_params['pair_scan'])
         else:
             result_markers = rqtl_mapping.run_rqtl_geno(vals, dataset, mapping_params['rqtl_method'], mapping_params['rqtl_model'],
-                                                 mapping_params['perm_check'], mapping_params['num_perm'],
-                                                 mapping_params['do_control'], mapping_params['control_marker'],
-                                                 mapping_params['manhattan_plot'], mapping_params['pair_scan'])
+                                                        mapping_params['perm_check'], mapping_params['num_perm'],
+                                                        mapping_params['do_control'], mapping_params['control_marker'],
+                                                        mapping_params['manhattan_plot'], mapping_params['pair_scan'])
 
     if mapping_params['limit_to']:
         result_markers = result_markers[:mapping_params['limit_to']]
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index f7d52ca3..9d3446db 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -41,10 +41,10 @@ def get_species_list():
     species_list = []
     for species in the_species:
         species_dict = {
-          "Id": species[0],
-          "Name": species[1],
-          "FullName": species[2],
-          "TaxonomyId": species[3]
+            "Id": species[0],
+            "Name": species[1],
+            "FullName": species[2],
+            "TaxonomyId": species[3]
         }
         species_list.append(species_dict)
 
@@ -60,10 +60,10 @@ def get_species_info(species_name, file_format="json"):
 
     the_species = results.fetchone()
     species_dict = {
-      "Id": the_species[0],
-      "Name": the_species[1],
-      "FullName": the_species[2],
-      "TaxonomyId": the_species[3]
+        "Id": the_species[0],
+        "Name": the_species[1],
+        "FullName": the_species[2],
+        "TaxonomyId": the_species[3]
     }
 
     return flask.jsonify(species_dict)
@@ -92,12 +92,12 @@ def get_groups_list(species_name=None):
         groups_list = []
         for group in the_groups:
             group_dict = {
-              "Id": group[0],
-              "SpeciesId": group[1],
-              "DisplayName": group[2],
-              "Name": group[3],
-              "FullName": group[4],
-              "public": group[5],
+                "Id": group[0],
+                "SpeciesId": group[1],
+                "DisplayName": group[2],
+                "Name": group[3],
+                "FullName": group[4],
+                "public": group[5],
               "MappingMethodId": group[6],
               "GeneticType": group[7]
             }
@@ -137,12 +137,12 @@ def get_group_info(group_name, species_name=None, file_format="json"):
     group = results.fetchone()
     if group:
         group_dict = {
-          "Id": group[0],
-          "SpeciesId": group[1],
-          "DisplayName": group[2],
-          "Name": group[3],
-          "FullName": group[4],
-          "public": group[5],
+            "Id": group[0],
+            "SpeciesId": group[1],
+            "DisplayName": group[2],
+            "Name": group[3],
+            "FullName": group[4],
+            "public": group[5],
           "MappingMethodId": group[6],
           "GeneticType": group[7]
         }
@@ -186,12 +186,12 @@ def get_datasets_for_group(group_name, species_name=None):
         datasets_list = []
         for dataset in the_datasets:
             dataset_dict = {
-              "Id": dataset[0],
-              "ProbeFreezeId": dataset[1],
-              "AvgID": dataset[2],
-              "Short_Abbreviation": dataset[3],
-              "Long_Abbreviation": dataset[4],
-              "FullName": dataset[5],
+                "Id": dataset[0],
+                "ProbeFreezeId": dataset[1],
+                "AvgID": dataset[2],
+                "Short_Abbreviation": dataset[3],
+                "Long_Abbreviation": dataset[4],
+                "FullName": dataset[5],
               "ShortName": dataset[6],
               "CreateTime": dataset[7],
               "public": dataset[8],
@@ -243,12 +243,12 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
 
     if dataset:
         dataset_dict = {
-          "dataset_type": "mRNA expression",
-          "id": dataset[0],
-          "name": dataset[1],
-          "full_name": dataset[2],
-          "short_name": dataset[3],
-          "data_scale": dataset[4],
+            "dataset_type": "mRNA expression",
+            "id": dataset[0],
+            "name": dataset[1],
+            "full_name": dataset[2],
+            "short_name": dataset[3],
+            "data_scale": dataset[4],
           "tissue_id": dataset[5],
           "tissue": dataset[6],
           "public": dataset[7],
@@ -280,25 +280,25 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
         if dataset:
             if dataset[5]:
                 dataset_dict = {
-                  "dataset_type": "phenotype",
-                  "id": dataset[0],
-                  "name": dataset[1],
-                  "description": dataset[2],
-                  "pubmed_id": dataset[5],
-                  "title": dataset[6],
+                    "dataset_type": "phenotype",
+                    "id": dataset[0],
+                    "name": dataset[1],
+                    "description": dataset[2],
+                    "pubmed_id": dataset[5],
+                    "title": dataset[6],
                   "year": dataset[7]
                 }
             elif dataset[4]:
                 dataset_dict = {
-                  "dataset_type": "phenotype",
-                  "id": dataset[0],
-                  "name": dataset[3],
-                  "description": dataset[4]
+                    "dataset_type": "phenotype",
+                    "id": dataset[0],
+                    "name": dataset[3],
+                    "description": dataset[4]
                 }
             else:
                 dataset_dict = {
-                  "dataset_type": "phenotype",
-                  "id": dataset[0]
+                    "dataset_type": "phenotype",
+                    "id": dataset[0]
                 }
 
             datasets_list.append(dataset_dict)
@@ -364,7 +364,7 @@ def fetch_traits(dataset_name, file_format="json"):
                         """
 
                 field_list = ["Id", "Name", "Symbol", "Description", "Chr", "Mb",
-                    "Aliases", "Mean", "SE", "Locus", "LRS", "P-Value", "Additive", "h2"]
+                              "Aliases", "Mean", "SE", "Locus", "LRS", "P-Value", "Additive", "h2"]
             elif data_type == "Geno":
                 query = """
                             SELECT
@@ -382,7 +382,7 @@ def fetch_traits(dataset_name, file_format="json"):
                         """
 
                 field_list = ["Id", "Name", "Marker_Name",
-                    "Chr", "Mb", "Sequence", "Source"]
+                              "Chr", "Mb", "Sequence", "Source"]
             else:
                 query = """
                             SELECT
@@ -399,7 +399,7 @@ def fetch_traits(dataset_name, file_format="json"):
                         """
 
                 field_list = ["Id", "PhenotypeId", "PublicationId",
-                    "Locus", "LRS", "Additive", "Sequence"]
+                              "Locus", "LRS", "Additive", "Sequence"]
 
             if 'limit_to' in request.args:
                 limit_number = request.args['limit_to']
@@ -579,10 +579,10 @@ def trait_sample_data(dataset_name, trait_name, file_format="json"):
         sample_list = []
         for sample in sample_data:
             sample_dict = {
-              "sample_name": sample[0],
-              "sample_name_2": sample[1],
-              "value": sample[2],
-              "data_id": sample[3],
+                "sample_name": sample[0],
+                "sample_name_2": sample[1],
+                "value": sample[2],
+                "data_id": sample[3],
             }
             if sample[4]:
                 sample_dict["se"] = sample[4]
@@ -626,10 +626,10 @@ def trait_sample_data(dataset_name, trait_name, file_format="json"):
             sample_list = []
             for sample in sample_data:
                 sample_dict = {
-                  "sample_name": sample[0],
-                  "sample_name_2": sample[1],
-                  "value": sample[2],
-                  "data_id": sample[3]
+                    "sample_name": sample[0],
+                    "sample_name_2": sample[1],
+                    "value": sample[2],
+                    "data_id": sample[3]
                 }
                 if sample[4]:
                     sample_dict["se"] = sample[4]
@@ -796,9 +796,9 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
             config_file = [filename + ".json", json.dumps(yaml_file)]
             #config_file = [filename + ".yaml", open("{0}/{1}.yaml".format(flat_files("genotype/rqtl2"), group_name))]
             geno_file = [filename + "_geno.csv",
-                open("{0}/{1}_geno.csv".format(flat_files("genotype/rqtl2"), group_name))]
+                         open("{0}/{1}_geno.csv".format(flat_files("genotype/rqtl2"), group_name))]
             gmap_file = [filename + "_gmap.csv",
-                open("{0}/{1}_gmap.csv".format(flat_files("genotype/rqtl2"), group_name))]
+                         open("{0}/{1}_gmap.csv".format(flat_files("genotype/rqtl2"), group_name))]
             if dataset_name:
                 phenotypes = requests.get(
                     "http://gn2.genenetwork.org/api/v_pre1/sample_data/" + dataset_name)
@@ -828,7 +828,7 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                     if limit_num and i >= limit_num:
                         break
                     output_lines.append([line.strip()
-                                        for line in line.split(",")])
+                                         for line in line.split(",")])
                     i += 1
 
             csv_writer = csv.writer(si, delimiter=",")
@@ -914,7 +914,7 @@ def get_dataset_trait_ids(dataset_name, start_vars):
 
         trait_ids = [result[0] for result in results]
         trait_names = [str(result[2]) + "_" + str(result[1])
-                           for result in results]
+                       for result in results]
 
         return trait_ids, trait_names, data_type, dataset_id
 
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index b06d84ff..58518639 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -75,14 +75,14 @@ def collections_add():
     if 'traits' in request.args:
         traits = request.args['traits']
         return render_template("collections/add.html",
-                                traits=traits,
-                                collections=collections,
+                               traits=traits,
+                               collections=collections,
                               )
     else:
         hash = request.args['hash']
         return render_template("collections/add.html",
-                                hash=hash,
-                                collections=collections,
+                               hash=hash,
+                               collections=collections,
                               )
 
 
@@ -145,8 +145,8 @@ def list_collections():
 
     user_collections = list(g.user_session.user_collections)
     return render_template("collections/list.html",
-                            params=params,
-                            collections=user_collections,
+                           params=params,
+                           collections=user_collections,
                             )
 
 
@@ -225,7 +225,7 @@ def view_collection():
         return json.dumps(json_version)
     else:
         return render_template("collections/view.html",
-                           **collection_info
+                               **collection_info
                            )
 
 
diff --git a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
index d86c8e16..cb88eb53 100644
--- a/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
+++ b/wqflask/wqflask/comparison_bar_chart/comparison_bar_chart.py
@@ -35,7 +35,7 @@ class ComparisonBarChart:
 
     def __init__(self, start_vars):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
 
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
@@ -90,8 +90,8 @@ class ComparisonBarChart:
             #print("dataset_name:", dataset_name)
             dataset_ob = data_set.create_dataset(dataset_name)
             trait_ob = create_trait(dataset=dataset_ob,
-                                   name=trait_name,
-                                   cellid=None)
+                                    name=trait_name,
+                                    cellid=None)
             self.trait_list.append((trait_ob, dataset_ob))
 
         #print("trait_list:", self.trait_list)
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index e8b7b057..aa39bc5c 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -82,8 +82,8 @@ class CorrelationResults:
                     dataset_name="Temp", dataset_type="Temp", group_name = start_vars['group'])
                 self.trait_id = start_vars['trait_id']
                 self.this_trait = create_trait(dataset=self.dataset,
-                                           name=self.trait_id,
-                                           cellid=None)
+                                               name=self.trait_id,
+                                               cellid=None)
             else:
                 helper_functions.get_species_dataset_trait(self, start_vars)
 
@@ -98,7 +98,7 @@ class CorrelationResults:
 
             if ('loc_chr' in start_vars
                 and 'min_loc_mb' in start_vars
-                and 'max_loc_mb' in start_vars):
+                    and 'max_loc_mb' in start_vars):
 
                 self.location_type = get_string(start_vars, 'location_type')
                 self.location_chr = get_string(start_vars, 'loc_chr')
@@ -129,7 +129,7 @@ class CorrelationResults:
             if corr_samples_group != 'samples_primary':
                 if corr_samples_group == 'samples_other':
                     primary_samples = [x for x in primary_samples if x not in (
-                                    self.dataset.group.parlist + self.dataset.group.f1list)]
+                        self.dataset.group.parlist + self.dataset.group.f1list)]
                 self.process_samples(start_vars, list(
                     self.this_trait.data.keys()), primary_samples)
 
@@ -201,7 +201,7 @@ class CorrelationResults:
                             chr_as_int = order_id
 
                 if (float(self.correlation_data[trait][0]) >= self.p_range_lower
-                    and float(self.correlation_data[trait][0]) <= self.p_range_upper):
+                        and float(self.correlation_data[trait][0]) <= self.p_range_upper):
 
                     if (self.target_dataset.type == "ProbeSet" or self.target_dataset.type == "Publish") and bool(trait_object.mean):
                         if (self.min_expr != None) and (float(trait_object.mean) < self.min_expr):
@@ -221,8 +221,8 @@ class CorrelationResults:
                             continue
 
                     (trait_object.sample_r,
-                    trait_object.sample_p,
-                    trait_object.num_overlap) = self.correlation_data[trait]
+                     trait_object.sample_p,
+                     trait_object.num_overlap) = self.correlation_data[trait]
 
                     # Set some sane defaults
                     trait_object.tissue_corr = 0
@@ -277,7 +277,7 @@ class CorrelationResults:
                 trait.symbol for trait in self.correlation_results if trait.symbol]
 
             corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
-                                                    symbol_list=gene_symbol_list)
+                symbol_list=gene_symbol_list)
 
             for trait in self.correlation_results:
                 if trait.symbol and trait.symbol.lower() in corr_result_tissue_vals_dict:
@@ -285,8 +285,8 @@ class CorrelationResults:
                     )]
 
                     result = correlation_functions.cal_zero_order_corr_for_tiss(primary_trait_tissue_values,
-                                                                          this_trait_tissue_values,
-                                                                          self.corr_method)
+                                                                                this_trait_tissue_values,
+                                                                                self.corr_method)
 
                     trait.tissue_corr = result[0]
                     trait.tissue_pvalue = result[2]
@@ -302,7 +302,7 @@ class CorrelationResults:
 
             #print("trait_gene_symbols: ", pf(trait_gene_symbols.values()))
             corr_result_tissue_vals_dict = correlation_functions.get_trait_symbol_and_tissue_values(
-                                                    symbol_list=list(self.trait_symbol_dict.values()))
+                symbol_list=list(self.trait_symbol_dict.values()))
 
             #print("corr_result_tissue_vals: ", pf(corr_result_tissue_vals_dict))
 
@@ -315,13 +315,13 @@ class CorrelationResults:
                     )]
 
                     result = correlation_functions.cal_zero_order_corr_for_tiss(primary_trait_tissue_values,
-                                                                          this_trait_tissue_values,
-                                                                          self.corr_method)
+                                                                                this_trait_tissue_values,
+                                                                                self.corr_method)
 
                     tissue_corr_data[trait] = [symbol, result[0], result[2]]
 
             tissue_corr_data = collections.OrderedDict(sorted(list(tissue_corr_data.items()),
-                                                           key=lambda t: -abs(t[1][1])))
+                                                              key=lambda t: -abs(t[1][1])))
 
             return tissue_corr_data
 
@@ -397,7 +397,7 @@ class CorrelationResults:
                 lit_corr_data[trait] = [gene_id, 0]
 
         lit_corr_data = collections.OrderedDict(sorted(list(lit_corr_data.items()),
-                                                           key=lambda t: -abs(t[1][1])))
+                                                       key=lambda t: -abs(t[1][1])))
 
         return lit_corr_data
 
@@ -603,12 +603,12 @@ def get_header_fields(data_type, corr_method):
     if data_type == "ProbeSet":
         if corr_method == "spearman":
             header_fields = ['Index',
-                                'Record',
-                                'Symbol',
-                                'Description',
-                                'Location',
-                                'Mean',
-                                'Sample rho',
+                             'Record',
+                             'Symbol',
+                             'Description',
+                             'Location',
+                             'Mean',
+                             'Sample rho',
                                 'N',
                                 'Sample p(rho)',
                                 'Lit rho',
@@ -619,12 +619,12 @@ def get_header_fields(data_type, corr_method):
                                 'Additive Effect']
         else:
             header_fields = ['Index',
-                                'Record',
-                                'Symbol',
-                                'Description',
-                                'Location',
-                                'Mean',
-                                'Sample r',
+                             'Record',
+                             'Symbol',
+                             'Description',
+                             'Location',
+                             'Mean',
+                             'Sample r',
                                 'N',
                                 'Sample p(r)',
                                 'Lit r',
@@ -636,47 +636,47 @@ def get_header_fields(data_type, corr_method):
     elif data_type == "Publish":
         if corr_method == "spearman":
             header_fields = ['Index',
-                            'Record',
-                            'Abbreviation',
-                            'Description',
-                            'Mean',
-                            'Authors',
-                            'Year',
-                            'Sample rho',
-                            'N',
-                            'Sample p(rho)',
-                            'Max LRS',
-                            'Max LRS Location',
-                            'Additive Effect']
+                             'Record',
+                             'Abbreviation',
+                             'Description',
+                             'Mean',
+                             'Authors',
+                             'Year',
+                             'Sample rho',
+                             'N',
+                             'Sample p(rho)',
+                             'Max LRS',
+                             'Max LRS Location',
+                             'Additive Effect']
         else:
             header_fields = ['Index',
-                            'Record',
-                            'Abbreviation',
-                            'Description',
-                            'Mean',
-                            'Authors',
-                            'Year',
-                            'Sample r',
-                            'N',
-                            'Sample p(r)',
-                            'Max LRS',
-                            'Max LRS Location',
-                            'Additive Effect']
+                             'Record',
+                             'Abbreviation',
+                             'Description',
+                             'Mean',
+                             'Authors',
+                             'Year',
+                             'Sample r',
+                             'N',
+                             'Sample p(r)',
+                             'Max LRS',
+                             'Max LRS Location',
+                             'Additive Effect']
 
     else:
         if corr_method == "spearman":
             header_fields = ['Index',
-                                'ID',
-                                'Location',
-                                'Sample rho',
-                                'N',
-                                'Sample p(rho)']
+                             'ID',
+                             'Location',
+                             'Sample rho',
+                             'N',
+                             'Sample p(rho)']
         else:
             header_fields = ['Index',
-                                'ID',
-                                'Location',
-                                'Sample r',
-                                'N',
-                                'Sample p(r)']
+                             'ID',
+                             'Location',
+                             'Sample r',
+                             'N',
+                             'Sample p(r)']
 
     return header_fields
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index c04b17be..c1bf3daa 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -45,7 +45,7 @@ class CorrelationMatrix:
 
     def __init__(self, start_vars):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
 
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
@@ -215,7 +215,7 @@ class CorrelationMatrix:
         temp_dataset.group.get_samplelist()
         for i, pca_trait in enumerate(pca_traits):
             trait_id = "PCA" + str(i + 1) + "_" + temp_dataset.group.species + "_" + \
-                                   this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
+                this_group_name + "_" + datetime.datetime.now().strftime("%m%d%H%M%S")
             this_vals_string = ""
             position = 0
             for sample in temp_dataset.group.all_samples_ordered():
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index 820e81bc..a0fb34d8 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -66,12 +66,12 @@ class CTL:
 
     def addNode(self, gt):
         node_dict = {'data': {'id': str(gt.name) + ":" + str(gt.dataset.name),
-                                'sid': str(gt.name),
-                                'dataset': str(gt.dataset.name),
-                                'label': gt.name,
-                                'symbol': gt.symbol,
-                                'geneid': gt.geneid,
-                                'omim': gt.omim}}
+                              'sid': str(gt.name),
+                              'dataset': str(gt.dataset.name),
+                              'label': gt.name,
+                              'symbol': gt.symbol,
+                              'geneid': gt.geneid,
+                              'omim': gt.omim}}
         self.nodes_list.append(node_dict)
 
     def addEdge(self, gtS, gtT, significant, x):
@@ -87,7 +87,7 @@ class CTL:
     def run_analysis(self, requestform):
         logger.info("Starting CTL analysis on dataset")
         self.trait_db_list = [trait.strip()
-                                          for trait in requestform['trait_list'].split(',')]
+                              for trait in requestform['trait_list'].split(',')]
         self.trait_db_list = [x for x in self.trait_db_list if x]
 
         logger.debug("strategy:", requestform.get("strategy"))
@@ -179,9 +179,9 @@ class CTL:
         for trait in self.trait_db_list:
             # Create the QTL like CTL plots
             self.results['imgurl' + \
-                str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
+                         str(n)] = webqtlUtil.genRandStr("CTL_") + ".png"
             self.results['imgloc' + str(n)] = GENERATED_IMAGE_DIR + \
-                                        self.results['imgurl' + str(n)]
+                self.results['imgurl' + str(n)]
             r_png(self.results['imgloc' + str(n)],
                   width=1000, height=600, type='cairo-png')
             self.r_plotCTLobject(
diff --git a/wqflask/wqflask/do_search.py b/wqflask/wqflask/do_search.py
index 48527785..761ae326 100644
--- a/wqflask/wqflask/do_search.py
+++ b/wqflask/wqflask/do_search.py
@@ -112,7 +112,7 @@ class MrnaAssaySearch(DoSearch):
             match_clause = ""
 
         where_clause = (match_clause
-            + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
+                        + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
                and ProbeSetXRef.ProbeSetFreezeId = %s
                         """ % (escape(str(self.dataset.id))))
 
@@ -135,7 +135,7 @@ class MrnaAssaySearch(DoSearch):
             match_clause = ""
 
         where_clause = (match_clause
-            + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
+                        + """ProbeSet.Id = ProbeSetXRef.ProbeSetId
                and ProbeSetXRef.ProbeSetFreezeId = %s
                         """ % (escape(str(self.dataset.id))))
 
@@ -147,14 +147,14 @@ class MrnaAssaySearch(DoSearch):
         from_clause = self.normalize_spaces(from_clause)
 
         query = (self.base_query +
-            """%s
+                 """%s
                 WHERE %s
                     and ProbeSet.Id = ProbeSetXRef.ProbeSetId
                     and ProbeSetXRef.ProbeSetFreezeId = %s
                 ORDER BY ProbeSet.symbol ASC
                             """ % (escape(from_clause),
-                                    where_clause,
-                                    escape(str(self.dataset.id))))
+                                   where_clause,
+                                   escape(str(self.dataset.id))))
         return query
 
     def run_combined(self, from_clause='', where_clause=''):
@@ -166,14 +166,14 @@ class MrnaAssaySearch(DoSearch):
         from_clause = self.normalize_spaces(from_clause)
 
         query = (self.base_query +
-            """%s
+                 """%s
                 WHERE %s
                     and ProbeSet.Id = ProbeSetXRef.ProbeSetId
                     and ProbeSetXRef.ProbeSetFreezeId = %s
                 ORDER BY ProbeSet.symbol ASC
                             """ % (escape(from_clause),
-                                    where_clause,
-                                    escape(str(self.dataset.id))))
+                                   where_clause,
+                                   escape(str(self.dataset.id))))
 
         return self.execute(query)
 
@@ -199,15 +199,15 @@ class PhenotypeSearch(DoSearch):
                 FROM Phenotype, PublishFreeze, Publication, PublishXRef """
 
     search_fields = ('Phenotype.Post_publication_description',
-                    'Phenotype.Pre_publication_description',
-                    'Phenotype.Pre_publication_abbreviation',
-                    'Phenotype.Post_publication_abbreviation',
-                    'Phenotype.Lab_code',
-                    'Publication.PubMed_ID',
-                    'Publication.Abstract',
-                    'Publication.Title',
-                    'Publication.Authors',
-                    'PublishXRef.Id')
+                     'Phenotype.Pre_publication_description',
+                     'Phenotype.Pre_publication_abbreviation',
+                     'Phenotype.Post_publication_abbreviation',
+                     'Phenotype.Lab_code',
+                     'Publication.PubMed_ID',
+                     'Publication.Abstract',
+                     'Publication.Title',
+                     'Publication.Authors',
+                     'PublishXRef.Id')
 
     header_fields = ['Index',
                      'Record',
@@ -250,28 +250,28 @@ class PhenotypeSearch(DoSearch):
 
         if self.search_term[0] == "*":
             query = (self.base_query +
-                    """%s
+                     """%s
                         WHERE PublishXRef.InbredSetId = %s
                         and PublishXRef.PhenotypeId = Phenotype.Id
                         and PublishXRef.PublicationId = Publication.Id
                         and PublishFreeze.Id = %s
                         ORDER BY PublishXRef.Id""" % (
-                            from_clause,
-                            escape(str(self.dataset.group.id)),
-                            escape(str(self.dataset.id))))
+                         from_clause,
+                         escape(str(self.dataset.group.id)),
+                         escape(str(self.dataset.id))))
         else:
             query = (self.base_query +
-                    """%s
+                     """%s
                         WHERE %s
                         and PublishXRef.InbredSetId = %s
                         and PublishXRef.PhenotypeId = Phenotype.Id
                         and PublishXRef.PublicationId = Publication.Id
                         and PublishFreeze.Id = %s
                         ORDER BY PublishXRef.Id""" % (
-                            from_clause,
-                            where_clause,
-                            escape(str(self.dataset.group.id)),
-                            escape(str(self.dataset.id))))
+                         from_clause,
+                         where_clause,
+                         escape(str(self.dataset.group.id)),
+                         escape(str(self.dataset.id))))
 
         return query
 
@@ -283,16 +283,16 @@ class PhenotypeSearch(DoSearch):
         from_clause = self.normalize_spaces(from_clause)
 
         query = (self.base_query +
-                """%s
+                 """%s
                     WHERE %s
                     PublishXRef.InbredSetId = %s and
                     PublishXRef.PhenotypeId = Phenotype.Id and
                     PublishXRef.PublicationId = Publication.Id and
                     PublishFreeze.Id = %s""" % (
-                        from_clause,
-                        where_clause,
-                        escape(str(self.dataset.group.id)),
-                        escape(str(self.dataset.id))))
+                     from_clause,
+                     where_clause,
+                     escape(str(self.dataset.group.id)),
+                     escape(str(self.dataset.id))))
 
         return self.execute(query)
 
@@ -336,7 +336,7 @@ class GenotypeSearch(DoSearch):
         for field in self.search_fields:
             where_clause.append('''%s REGEXP "%s"''' % ("%s.%s" % self.mescape(self.dataset.type,
                                                                                field),
-                                                                               self.search_term))
+                                                        self.search_term))
         logger.debug("hello ;where_clause is:", pf(where_clause))
         where_clause = "(%s) " % ' OR '.join(where_clause)
 
@@ -349,16 +349,16 @@ class GenotypeSearch(DoSearch):
 
         if self.search_term[0] == "*":
             query = (self.base_query
-                    + """WHERE Geno.Id = GenoXRef.GenoId
+                     + """WHERE Geno.Id = GenoXRef.GenoId
                         and GenoXRef.GenoFreezeId = GenoFreeze.Id
                         and GenoFreeze.Id = %s""" % (escape(str(self.dataset.id))))
         else:
             query = (self.base_query +
-                    """WHERE %s
+                     """WHERE %s
                         and Geno.Id = GenoXRef.GenoId
                         and GenoXRef.GenoFreezeId = GenoFreeze.Id
                         and GenoFreeze.Id = %s""" % (where_clause,
-                                                escape(str(self.dataset.id))))
+                                                     escape(str(self.dataset.id))))
 
         return query
 
@@ -526,7 +526,7 @@ class LrsSearch(DoSearch):
                 where_clause += """ and %sXRef.Locus = Geno.name and
                                                     Geno.SpeciesId = %s
                                                     """ % self.mescape(self.dataset.type,
-                                                           self.species_id)
+                                                                       self.species_id)
         else:
             # Deal with >, <, >=, and <=
             logger.debug("self.search_term is:", self.search_term)
@@ -535,8 +535,8 @@ class LrsSearch(DoSearch):
                 lrs_val = lrs_val * 4.61
 
             where_clause = """ %sXRef.LRS %s %s """ % self.mescape(self.dataset.type,
-                                                                        self.search_operator,
-                                                                        self.search_term[0])
+                                                                   self.search_operator,
+                                                                   self.search_term[0])
 
         return where_clause
 
@@ -618,18 +618,18 @@ class CisTransLrsSearch(DoSearch):
 
             sub_clause = """ %sXRef.LRS > %s and
                 %sXRef.LRS < %s  and """ % (
-                    escape(self.dataset.type),
-                    escape(str(min(lrs_min, lrs_max))),
-                    escape(self.dataset.type),
-                    escape(str(max(lrs_min, lrs_max)))
-                )
+                escape(self.dataset.type),
+                escape(str(min(lrs_min, lrs_max))),
+                escape(self.dataset.type),
+                escape(str(max(lrs_min, lrs_max)))
+            )
         else:
             # Deal with >, <, >=, and <=
             sub_clause = """ %sXRef.LRS %s %s and """ % (
-                    escape(self.dataset.type),
-                    escape(self.search_operator),
-                    escape(self.search_term[0])
-                )
+                escape(self.dataset.type),
+                escape(self.search_operator),
+                escape(self.search_term[0])
+            )
 
         if cis_trans == "cis":
             where_clause = sub_clause + """
@@ -637,27 +637,27 @@ class CisTransLrsSearch(DoSearch):
                     %sXRef.Locus = Geno.name and
                     Geno.SpeciesId = %s and
                     %s.Chr = Geno.Chr""" % (
-                        escape(self.dataset.type),
-                        the_operator,
-                        escape(str(self.mb_buffer)),
-                        escape(self.dataset.type),
-                        escape(str(self.species_id)),
-                        escape(self.dataset.type)
-                        )
+                escape(self.dataset.type),
+                the_operator,
+                escape(str(self.mb_buffer)),
+                escape(self.dataset.type),
+                escape(str(self.species_id)),
+                escape(self.dataset.type)
+            )
         else:
             if chromosome:
                 location_clause = "(%s.Chr = '%s' and %s.Chr = Geno.Chr and ABS(%s.Mb-Geno.Mb) %s %s) or (%s.Chr != Geno.Chr and Geno.Chr = '%s')" % (escape(self.dataset.type),
-                                                                                                                                                  chromosome,
-                                                                                                                                                  escape(
+                                                                                                                                                      chromosome,
+                                                                                                                                                      escape(
                                                                                                                                                       self.dataset.type),
-                                                                                                                                                  escape(
+                                                                                                                                                      escape(
                                                                                                                                                       self.dataset.type),
-                                                                                                                                                  the_operator,
-                                                                                                                                                  escape(
+                                                                                                                                                      the_operator,
+                                                                                                                                                      escape(
                                                                                                                                                       str(self.mb_buffer)),
-                                                                                                                                                  escape(
+                                                                                                                                                      escape(
                                                                                                                                                       self.dataset.type),
-                                                                                                                                                  chromosome)
+                                                                                                                                                      chromosome)
             else:
                 location_clause = "(ABS(%s.Mb-Geno.Mb) %s %s and %s.Chr = Geno.Chr) or (%s.Chr != Geno.Chr)" % (escape(
                     self.dataset.type), the_operator, escape(str(self.mb_buffer)), escape(self.dataset.type), escape(self.dataset.type))
@@ -665,10 +665,10 @@ class CisTransLrsSearch(DoSearch):
                     %sXRef.Locus = Geno.name and
                     Geno.SpeciesId = %s and
                     (%s)""" % (
-                        escape(self.dataset.type),
-                        escape(str(self.species_id)),
-                        location_clause
-                        )
+                escape(self.dataset.type),
+                escape(str(self.species_id)),
+                location_clause
+            )
 
         return where_clause
 
@@ -752,15 +752,15 @@ class MeanSearch(MrnaAssaySearch):
 
             where_clause = """ %sXRef.mean > %s and
                              %sXRef.mean < %s """ % self.mescape(self.dataset.type,
-                                                                min(self.mean_min,
-                                                                    self.mean_max),
-                                                                self.dataset.type,
-                                                                max(self.mean_min, self.mean_max))
+                                                                 min(self.mean_min,
+                                                                     self.mean_max),
+                                                                 self.dataset.type,
+                                                                 max(self.mean_min, self.mean_max))
         else:
             # Deal with >, <, >=, and <=
             where_clause = """ %sXRef.mean %s %s """ % self.mescape(self.dataset.type,
-                                                                        self.search_operator,
-                                                                        self.search_term[0])
+                                                                    self.search_operator,
+                                                                    self.search_term[0])
 
         return where_clause
 
@@ -893,17 +893,17 @@ class PvalueSearch(MrnaAssaySearch):
             self.pvalue_min, self.pvalue_max = self.search_term[:2]
             self.where_clause = """ %sXRef.pValue > %s and %sXRef.pValue < %s
                                     """ % self.mescape(
-                                        self.dataset.type,
-                                        min(self.pvalue_min, self.pvalue_max),
-                                        self.dataset.type,
-                                        max(self.pvalue_min, self.pvalue_max))
+                self.dataset.type,
+                min(self.pvalue_min, self.pvalue_max),
+                self.dataset.type,
+                max(self.pvalue_min, self.pvalue_max))
         else:
             # Deal with >, <, >=, and <=
             self.where_clause = """ %sXRef.pValue %s %s
                                     """ % self.mescape(
-                                        self.dataset.type,
-                                        self.search_operator,
-                                        self.search_term[0])
+                self.dataset.type,
+                self.search_operator,
+                self.search_term[0])
 
         logger.debug("where_clause is:", pf(self.where_clause))
 
diff --git a/wqflask/wqflask/export_traits.py b/wqflask/wqflask/export_traits.py
index 2c180d49..a22d6acc 100644
--- a/wqflask/wqflask/export_traits.py
+++ b/wqflask/wqflask/export_traits.py
@@ -60,7 +60,7 @@ def export_search_results_csv(targs):
         trait_list.append(trait_ob)
 
     table_headers = ['Index', 'URL', 'Species', 'Group', 'Dataset', 'Record ID', 'Symbol', 'Description', 'ProbeTarget', 'PubMed_ID', 'Chr', 'Mb', 'Alias', 'Gene_ID', 'Homologene_ID', 'UniGene_ID',
-        'Strand_Probe', 'Probe_set_specificity', 'Probe_set_BLAT_score', 'Probe_set_BLAT_Mb_start', 'Probe_set_BLAT_Mb_end', 'QTL_Chr', 'QTL_Mb', 'Locus_at_Peak', 'Max_LRS', 'P_value_of_MAX', 'Mean_Expression']
+                     'Strand_Probe', 'Probe_set_specificity', 'Probe_set_BLAT_score', 'Probe_set_BLAT_Mb_start', 'Probe_set_BLAT_Mb_end', 'QTL_Chr', 'QTL_Mb', 'Locus_at_Peak', 'Max_LRS', 'P_value_of_MAX', 'Mean_Expression']
 
     traits_by_group = sort_traits_by_group(trait_list)
 
@@ -93,7 +93,7 @@ def export_search_results_csv(targs):
             row_contents = [
                 i + 1,
                 "https://genenetwork.org/show_trait?trait_id=" + \
-                    str(trait.name) + "&dataset=" + str(trait.dataset.name),
+                str(trait.name) + "&dataset=" + str(trait.dataset.name),
                 trait.dataset.group.species,
                 trait.dataset.group.name,
                 trait.dataset.name,
@@ -124,7 +124,7 @@ def export_search_results_csv(targs):
             for sample in trait.dataset.group.samplelist:
                 if sample in trait.data:
                     row_contents += [trait.data[sample].value,
-                        trait.data[sample].variance]
+                                     trait.data[sample].variance]
                 else:
                     row_contents += ["x", "x"]
 
diff --git a/wqflask/wqflask/external_tools/send_to_bnw.py b/wqflask/wqflask/external_tools/send_to_bnw.py
index 3c0f2ca7..c1b14ede 100644
--- a/wqflask/wqflask/external_tools/send_to_bnw.py
+++ b/wqflask/wqflask/external_tools/send_to_bnw.py
@@ -28,7 +28,7 @@ logger = utility.logger.getLogger(__name__)
 class SendToBNW:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         trait_samples_list = []
diff --git a/wqflask/wqflask/external_tools/send_to_geneweaver.py b/wqflask/wqflask/external_tools/send_to_geneweaver.py
index 8af9bee9..9a4f7150 100644
--- a/wqflask/wqflask/external_tools/send_to_geneweaver.py
+++ b/wqflask/wqflask/external_tools/send_to_geneweaver.py
@@ -33,7 +33,7 @@ logger = utility.logger.getLogger(__name__)
 class SendToGeneWeaver:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.chip_name = test_chip(self.trait_list)
@@ -54,11 +54,11 @@ class SendToGeneWeaver:
             trait_name_list = get_trait_name_list(self.trait_list)
 
             self.hidden_vars = {
-                                 'client': "genenetwork",
-                                 'species': species_name,
-                                 'idtype': self.chip_name,
-                                 'list': ",".join(trait_name_list),
-                               }
+                'client': "genenetwork",
+                'species': species_name,
+                'idtype': self.chip_name,
+                'list': ",".join(trait_name_list),
+            }
 
 
 def get_trait_name_list(trait_list):
diff --git a/wqflask/wqflask/external_tools/send_to_webgestalt.py b/wqflask/wqflask/external_tools/send_to_webgestalt.py
index fcd943ba..6e74f4fe 100644
--- a/wqflask/wqflask/external_tools/send_to_webgestalt.py
+++ b/wqflask/wqflask/external_tools/send_to_webgestalt.py
@@ -33,7 +33,7 @@ logger = utility.logger.getLogger(__name__)
 class SendToWebGestalt:
     def __init__(self, start_vars):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.chip_name = test_chip(self.trait_list)
@@ -49,7 +49,7 @@ class SendToWebGestalt:
             id_type = "entrezgene"
 
             self.hidden_vars = {
-                             'gene_list': "\n".join(gene_id_list),
+                'gene_list': "\n".join(gene_id_list),
                              'id_type': "entrezgene",
                              'ref_set': "genome",
                              'enriched_database_category': "geneontology",
@@ -59,7 +59,7 @@ class SendToWebGestalt:
                              'enrich_method': "ORA",
                              'fdr_method': "BH",
                              'min_num': "2"
-                               }
+            }
 
             species = self.trait_list[0][1].group.species
             if species == "rat":
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index 995915a9..b7e7e38a 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -8,7 +8,7 @@ from wqflask import app
 from wqflask.user_login import send_verification_email, send_invitation_email, basic_info, set_password
 
 from utility.redis_tools import get_user_groups, get_group_info, save_user, create_group, delete_group, add_users_to_group, remove_users_from_group, \
-                                change_group_name, save_verification_code, check_verification_code, get_user_by_unique_column, get_resources, get_resource_info
+    change_group_name, save_verification_code, check_verification_code, get_user_by_unique_column, get_resources, get_resource_info
 
 from utility.logger import getLogger
 logger = getLogger(__name__)
@@ -78,9 +78,9 @@ def remove_users():
     member_ids_to_remove = request.form['selected_member_ids']
 
     remove_users_from_group(g.user_session.user_id, admin_ids_to_remove.split(
-       ":"), group_id, user_type="admins")
+        ":"), group_id, user_type="admins")
     remove_users_from_group(g.user_session.user_id, member_ids_to_remove.split(
-       ":"), group_id, user_type="members")
+        ":"), group_id, user_type="members")
 
     return redirect(url_for('view_group', id=group_id))
 
@@ -133,7 +133,7 @@ def add_or_edit_group():
             #send_group_invites(params['group_id'], user_email_list = user_emails, user_type="members")
 
         create_group(list(admin_user_ids), list(
-           member_user_ids), params['group_name'])
+            member_user_ids), params['group_name'])
         return redirect(url_for('manage_groups'))
     else:
         return render_template("admin/create_group.html")
@@ -159,13 +159,13 @@ def send_group_invites(group_id, user_email_list=[], user_type="members"):
                                             key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
         else:
             temp_password = ''.join(random.choice(
-               string.ascii_uppercase + string.digits) for _ in range(6))
+                string.ascii_uppercase + string.digits) for _ in range(6))
             user_details = {
-               'user_id': str(uuid.uuid4()),
-               'email_address': user_email,
-               'registration_info': basic_info(),
-               'password': set_password(temp_password),
-               'confirmed': 0
+                'user_id': str(uuid.uuid4()),
+                'email_address': user_email,
+                'registration_info': basic_info(),
+                'password': set_password(temp_password),
+                'confirmed': 0
             }
             save_user(user_details, user_details['user_id'])
             send_invitation_email(user_email, temp_password)
diff --git a/wqflask/wqflask/gsearch.py b/wqflask/wqflask/gsearch.py
index f02da27c..fb8bdc55 100644
--- a/wqflask/wqflask/gsearch.py
+++ b/wqflask/wqflask/gsearch.py
@@ -124,7 +124,7 @@ class GSearch:
                     if this_trait['locus_chr'] != None and this_trait['locus_mb'] != None:
                         max_lrs_text = "Chr" + \
                             str(this_trait['locus_chr']) + \
-                                ": " + str(this_trait['locus_mb'])
+                            ": " + str(this_trait['locus_mb'])
                     this_trait['max_lrs_text'] = max_lrs_text
 
                     trait_list.append(this_trait)
@@ -133,18 +133,18 @@ class GSearch:
             self.trait_list = json.dumps(trait_list)
 
             self.header_fields = ['Index',
-                                'Record',
-                                'Species',
-                                'Group',
-                                'Tissue',
-                                'Dataset',
-                                'Symbol',
-                                'Description',
-                                'Location',
-                                'Mean',
-                                'Max LRS',
-                                'Max LRS Location',
-                                'Additive Effect']
+                                  'Record',
+                                  'Species',
+                                  'Group',
+                                  'Tissue',
+                                  'Dataset',
+                                  'Symbol',
+                                  'Description',
+                                  'Location',
+                                  'Mean',
+                                  'Max LRS',
+                                  'Max LRS Location',
+                                  'Additive Effect']
 
         elif self.type == "phenotype":
             search_term = self.terms
@@ -251,7 +251,7 @@ class GSearch:
                             if trait_ob.locus_chr != "" and trait_ob.locus_mb != "":
                                 this_trait['max_lrs_text'] = "Chr" + \
                                     str(trait_ob.locus_chr) + \
-                                        ": " + str(trait_ob.locus_mb)
+                                    ": " + str(trait_ob.locus_mb)
                         except:
                             this_trait['max_lrs_text'] = "N/A"
 
@@ -261,12 +261,12 @@ class GSearch:
             self.trait_list = json.dumps(trait_list)
 
             self.header_fields = ['Index',
-                                'Species',
-                                'Group',
-                                'Record',
-                                'Description',
-                                'Authors',
-                                'Year',
-                                'Max LRS',
-                                'Max LRS Location',
-                                'Additive Effect']
+                                  'Species',
+                                  'Group',
+                                  'Record',
+                                  'Description',
+                                  'Authors',
+                                  'Year',
+                                  'Max LRS',
+                                  'Max LRS Location',
+                                  'Additive Effect']
diff --git a/wqflask/wqflask/heatmap/heatmap.py b/wqflask/wqflask/heatmap/heatmap.py
index 02eb66e5..001bab3b 100644
--- a/wqflask/wqflask/heatmap/heatmap.py
+++ b/wqflask/wqflask/heatmap/heatmap.py
@@ -19,7 +19,7 @@ class Heatmap:
 
     def __init__(self, start_vars, temp_uuid):
         trait_db_list = [trait.strip()
-                                     for trait in start_vars['trait_list'].split(',')]
+                         for trait in start_vars['trait_list'].split(',')]
         helper_functions.get_trait_db_obs(self, trait_db_list)
 
         self.temp_uuid = temp_uuid
@@ -35,7 +35,7 @@ class Heatmap:
         self.species = species.TheSpecies(dataset=self.trait_list[0][1])
         for key in list(self.species.chromosomes.chromosomes.keys()):
             chrnames.append([self.species.chromosomes.chromosomes[key].name,
-                            self.species.chromosomes.chromosomes[key].mb_length])
+                             self.species.chromosomes.chromosomes[key].mb_length])
 
         for trait_db in self.trait_list:
 
@@ -111,7 +111,7 @@ class Heatmap:
                     trimmed_values.append(values[i])
 
             trait_filename = str(this_trait.name) + "_" + \
-                                 str(self.dataset.name) + "_pheno"
+                str(self.dataset.name) + "_pheno"
             gen_pheno_txt_file(trimmed_samples, trimmed_values, trait_filename)
 
             output_filename = self.dataset.group.name + "_GWA_" + \
@@ -119,11 +119,11 @@ class Heatmap:
                         for _ in range(6))
 
             reaper_command = REAPER_COMMAND + ' --geno {0}/{1}.geno --traits {2}/gn2/{3}.txt -n 1000 -o {4}{5}.txt'.format(flat_files('genotype'),
-                                                                                                                    genofile_name,
-                                                                                                                    TEMPDIR,
-                                                                                                                    trait_filename,
-                                                                                                                    webqtlConfig.GENERATED_IMAGE_DIR,
-                                                                                                                    output_filename)
+                                                                                                                           genofile_name,
+                                                                                                                           TEMPDIR,
+                                                                                                                           trait_filename,
+                                                                                                                           webqtlConfig.GENERATED_IMAGE_DIR,
+                                                                                                                           output_filename)
 
             os.system(reaper_command)
 
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index 2f1c142c..04980281 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -8,8 +8,8 @@ from flask import Flask, g
 
 def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
     fetchFields = ['SpeciesId', 'Id', 'GeneSymbol', 'GeneDescription', 'Chromosome', 'TxStart', 'TxEnd',
-    'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
-    'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
+                   'Strand', 'GeneID', 'NM_ID', 'kgID', 'GenBankID', 'UnigenID', 'ProteinID', 'AlignID',
+                   'exonCount', 'exonStarts', 'exonEnds', 'cdsStart', 'cdsEnd']
 
     # List All Species in the Gene Table
     speciesDict = {}
@@ -34,9 +34,9 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
 					  ((TxStart > %f and TxStart <= %f) OR (TxEnd > %f and TxEnd <= %f))
 				ORDER BY txStart
                 """ % (", ".join(fetchFields),
-                   speciesId, chrName,
-                   startMb, endMb,
-                   startMb, endMb)).fetchall()
+                       speciesId, chrName,
+                       startMb, endMb,
+                       startMb, endMb)).fetchall()
 
     GeneList = []
 
@@ -55,7 +55,7 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                               StrainId1 = %d AND StrainId2 = %d
                                         """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
                 newdict["snpDensity"] = newdict["snpCount"] / \
-                        (newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
+                    (newdict["TxEnd"] - newdict["TxStart"]) / 1000.0
             else:
                 newdict["snpDensity"] = newdict["snpCount"] = 0
 
@@ -70,8 +70,8 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                 newdict2 = {}
 
                 resultsOther = g.db.execute("SELECT %s FROM GeneList WHERE SpeciesId = %d AND geneSymbol= '%s' LIMIT 1" % (", ".join(fetchFields),
-                                                                                                           othSpecId,
-                                                                                                           newdict["GeneSymbol"])).fetchone()
+                                                                                                                           othSpecId,
+                                                                                                                           newdict["GeneSymbol"])).fetchone()
 
                 if resultsOther:
                     for j, item in enumerate(fetchFields):
@@ -88,13 +88,13 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                                                     """ % (chrName, newdict["TxStart"], newdict["TxEnd"], diffCol[0], diffCol[1])).fetchone()[0]
 
                         newdict2["snpDensity"] = newdict2["snpCount"] / \
-                                (newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
+                            (newdict2["TxEnd"] - newdict2["TxStart"]) / 1000.0
                     else:
                         newdict2["snpDensity"] = newdict2["snpCount"] = 0
 
                     try:
                         newdict2['GeneLength'] = 1000.0 * \
-                                (newdict2['TxEnd'] - newdict2['TxStart'])
+                            (newdict2['TxEnd'] - newdict2['TxStart'])
                     except:
                         pass
 
diff --git a/wqflask/wqflask/markdown_routes.py b/wqflask/wqflask/markdown_routes.py
index ebf75807..c27ff143 100644
--- a/wqflask/wqflask/markdown_routes.py
+++ b/wqflask/wqflask/markdown_routes.py
@@ -103,7 +103,7 @@ def environments():
 @environments_blueprint.route('/svg-dependency-graph')
 def svg_graph():
     directory, file_name, _ = get_file_from_python_search_path(
-            "wqflask/dependency-graph.svg").partition("dependency-graph.svg")
+        "wqflask/dependency-graph.svg").partition("dependency-graph.svg")
     return send_from_directory(directory, file_name)
 
 
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index c68e0fde..f3b1b1fc 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -629,7 +629,7 @@ class DisplayMappingResults:
                 submit=HtmlGenWrapper.create_input_tag(type_='hidden'))
 
             hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet+ \
-                "Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
+                    "Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
             for key in hddn.keys():
                 showLocusForm.append(HtmlGenWrapper.create_input_tag(
                     name=key, value=hddn[key], type_='hidden'))
@@ -889,7 +889,7 @@ class DisplayMappingResults:
             bootY = yZero - bootHeightThresh * item / highestPercent
             im_drawer.line(
                 xy=((canvas.size[0] - bootOffset + 4, bootY),
-                 (canvas.size[0] - bootOffset, bootY)),
+                    (canvas.size[0] - bootOffset, bootY)),
                 fill=BLACK)
             im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, bootY+TEXT_Y_DISPLACEMENT),
                            text='%2.1f' % item, font=bootScaleFont, fill=BLACK)
@@ -983,7 +983,7 @@ class DisplayMappingResults:
                             break
         if locPixel >= 0 and self.plotScale == 'physic':
             traitPixel = ((locPixel, yZero), (locPixel - 7,
-                          yZero + 14), (locPixel + 7, yZero + 14))
+                                              yZero + 14), (locPixel + 7, yZero + 14))
             draw_open_polygon(canvas, xy=traitPixel, outline=BLACK,
                               fill=self.TRANSCRIPT_LOCATION_COLOR)
 
@@ -1029,7 +1029,7 @@ class DisplayMappingResults:
                         SNPCounts[i - xLeftOffset] * SNP_HEIGHT_MODIFIER / maxCount)
                     im_drawer.line(
                         xy=((i, drawSNPLocationY + (snpDensity) * zoom),
-                           (i, drawSNPLocationY - (snpDensity) * zoom)),
+                            (i, drawSNPLocationY - (snpDensity) * zoom)),
                         fill=self.SNP_COLOR, width=1)
 
     def drawMultiTraitName(self, fd, canvas, gifmap, showLocusForm, offset=(40, 120, 80, 10), zoom=1):
@@ -1356,7 +1356,7 @@ class DisplayMappingResults:
                 # always apply colors now, even if SNP Track not checked - Zach 11/24/2010
 
                 densities = [1.0000000000000001e-05, 0.094094033555233408,
-                    0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
+                             0.3306166377816987, 0.88246026851027781, 2.6690084029581951, 4.1, 61.0]
                 if SNPdensity < densities[0]:
                     myColor = BLACK
                 elif SNPdensity < densities[1]:
@@ -1462,13 +1462,13 @@ class DisplayMappingResults:
                                 xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
                                      geneYLocation),
                                     (geneStartPix + xCoord,
-                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
+                                     geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
                             im_drawer.line(
                                 xy=((geneStartPix + xCoord + self.EACH_GENE_ARROW_WIDTH,
                                      geneYLocation + self.EACH_GENE_HEIGHT * zoom),
                                     (geneStartPix + xCoord,
-                                      geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
+                                     geneYLocation + (self.EACH_GENE_HEIGHT / 2) * zoom)),
                                 fill=arrowColor, width=1)
 
                 # draw the blocks for the exon regions
@@ -1476,7 +1476,7 @@ class DisplayMappingResults:
                     exonStartPix = (
                         exonStarts[i] - startMb) * plotXScale + xLeftOffset
                     exonEndPix = (exonEnds[i] - startMb) * \
-                                  plotXScale + xLeftOffset
+                        plotXScale + xLeftOffset
                     if (exonStartPix < xLeftOffset):
                         exonStartPix = xLeftOffset
                     if (exonEndPix < xLeftOffset):
@@ -1493,7 +1493,7 @@ class DisplayMappingResults:
                 # draw gray blocks for 3' and 5' UTR blocks
                 if cdsStart and cdsEnd:
                     utrStartPix = (txStart - startMb) * \
-                                   plotXScale + xLeftOffset
+                        plotXScale + xLeftOffset
                     utrEndPix = (cdsStart - startMb) * plotXScale + xLeftOffset
                     if (utrStartPix < xLeftOffset):
                         utrStartPix = xLeftOffset
@@ -1741,9 +1741,9 @@ class DisplayMappingResults:
                                         mylineColor = self.HAPLOTYPE_RECOMBINATION
                                     im_drawer.line(
                                         xy=((plotRight,
-                                            geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
                                             (drawEnd,
-                                            geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
+                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
                                         fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
                             if lastGene == 0:
@@ -1869,7 +1869,7 @@ class DisplayMappingResults:
                     fill=self.CLICKABLE_WEBQTL_REGION_COLOR)
                 im_drawer.line(
                     xy=((xBrowse1, paddingTop), (xBrowse1,
-                        (paddingTop + self.BAND_HEIGHT))),
+                                                 (paddingTop + self.BAND_HEIGHT))),
                     fill=self.CLICKABLE_WEBQTL_REGION_OUTLINE_COLOR)
 
                 if self.dataset.group.species == "mouse" or self.dataset.group.species == "rat":
@@ -1895,7 +1895,7 @@ class DisplayMappingResults:
                         fill=self.CLICKABLE_PHENOGEN_REGION_COLOR)
                     im_drawer.line(
                         xy=((xBrowse1, phenogenPaddingTop), (xBrowse1,
-                            (phenogenPaddingTop + self.BAND_HEIGHT))),
+                                                             (phenogenPaddingTop + self.BAND_HEIGHT))),
                         fill=self.CLICKABLE_PHENOGEN_REGION_OUTLINE_COLOR)
 
                 UCSC_COORDS = "%d, %d, %d, %d" % (
@@ -2051,7 +2051,7 @@ class DisplayMappingResults:
                                        fill=xAxisLabelColor)
                     else:
                         im_drawer.line(xy=((Xc, yZero),
-                                          (Xc, yZero + xMinorTickHeight)),
+                                           (Xc, yZero + xMinorTickHeight)),
                                        fill=xAxisTickMarkColor,
                                        width=X_MINOR_TICK_THICKNESS)  # Draw the MINOR tick mark
 
@@ -2159,17 +2159,17 @@ class DisplayMappingResults:
                     if differ:
                         im_drawer.line(
                             xy=((startPosX + Lpos, yZero), (xLeftOffset + offsetA,\
-                        yZero + 25)),
+                                                            yZero + 25)),
                             fill=lineColor)
                         im_drawer.line(
                             xy=((xLeftOffset + offsetA, yZero + 25), (xLeftOffset+offsetA,\
-                        yZero + 40 + Zorder*(LRectWidth+3))),
+                                                                      yZero + 40 + Zorder*(LRectWidth+3))),
                             fill=lineColor)
                         rectColor = ORANGE
                     else:
                         im_drawer.line(
                             xy=((xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3)-3), (\
-                        xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3))),
+                                xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3))),
                             fill=lineColor)
                         rectColor = DEEPPINK
                     im_drawer.rectangle(
@@ -2178,7 +2178,7 @@ class DisplayMappingResults:
                              yZero + 40 + Zorder*(LRectWidth+3)+LRectWidth)),
                         outline=rectColor, fill=rectColor, width=0)
                     COORDS = "%d,%d,%d,%d" % (xLeftOffset+offsetA-LRectHeight, yZero+40+Zorder*(LRectWidth+3),\
-                            xLeftOffset + offsetA, yZero +40+Zorder*(LRectWidth+3)+LRectWidth)
+                                              xLeftOffset + offsetA, yZero +40+Zorder*(LRectWidth+3)+LRectWidth)
                     HREF = "/show_trait?trait_id=%s&dataset=%s" % (
                         Lname, self.dataset.group.name + "Geno")
                     #HREF="javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm,fd.RISet+"Geno", Lname)
@@ -2230,7 +2230,7 @@ class DisplayMappingResults:
         if self.lrsMax <= 0:  # sliding scale
             if "lrs_value" in self.qtlresults[0]:
                 LRS_LOD_Max = max([result['lrs_value']
-                                  for result in self.qtlresults])
+                                   for result in self.qtlresults])
                 if self.LRS_LOD == "LOD" or self.LRS_LOD == "-logP":
                     LRS_LOD_Max = LRS_LOD_Max / self.LODFACTOR
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
@@ -2248,7 +2248,7 @@ class DisplayMappingResults:
                         pass
             else:
                 LRS_LOD_Max = max([result['lod_score']
-                                  for result in self.qtlresults])
+                                   for result in self.qtlresults])
                 if self.LRS_LOD == "LRS":
                     LRS_LOD_Max = LRS_LOD_Max * self.LODFACTOR
                     if self.permChecked and self.nperm > 0 and not self.multipleInterval:
@@ -2390,7 +2390,7 @@ class DisplayMappingResults:
                 )
                 im_drawer.line(
                     xy=((start_pos_x + self.SUGGESTIVE_WIDTH / 1.5, significantY),
-                       (rightEdge, significantY)),
+                        (rightEdge, significantY)),
                     fill=self.SIGNIFICANT_COLOR,
                     width=self.SIGNIFICANT_WIDTH * zoom
                     # , clipX=(xLeftOffset, xLeftOffset + plotWidth-2)
@@ -2440,7 +2440,7 @@ class DisplayMappingResults:
         else:
             if self.additiveChecked:
                 additiveMax = max([abs(X['additive'])
-                                  for X in self.qtlresults])
+                                   for X in self.qtlresults])
             lrsEdgeWidth = 3
 
         if zoom == 2:
@@ -2484,7 +2484,7 @@ class DisplayMappingResults:
                                     Xcm = Xc
                                 else:
                                     Xcm = (yZero - Yc0) / \
-                                           ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                                        ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                                 if Yc0 < yZero:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2583,12 +2583,12 @@ class DisplayMappingResults:
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
                             Yc = yZero - webqtlConfig.MAXLRS * \
                                 LRSHeightThresh / \
-                                    (LRS_LOD_Max * self.LODFACTOR)
+                                (LRS_LOD_Max * self.LODFACTOR)
                         else:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/(LRSAxisList[-1]*self.LODFACTOR)
                             Yc = yZero - \
                                 qtlresult['lrs_value'] * LRSHeightThresh / \
-                                    (LRS_LOD_Max * self.LODFACTOR)
+                                (LRS_LOD_Max * self.LODFACTOR)
                     else:
                         if qtlresult['lrs_value'] > 460 or qtlresult['lrs_value'] == 'inf':
                             #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
@@ -2597,7 +2597,7 @@ class DisplayMappingResults:
                             #Yc = yZero - qtlresult['lrs_value']*LRSHeightThresh/LRSAxisList[-1]
                             Yc = yZero - \
                                 qtlresult['lrs_value'] * \
-                                    LRSHeightThresh / LRS_LOD_Max
+                                LRSHeightThresh / LRS_LOD_Max
                 else:
                     if qtlresult['lod_score'] > 100 or qtlresult['lod_score'] == 'inf':
                         #Yc = yZero - webqtlConfig.MAXLRS*LRSHeightThresh/LRSAxisList[-1]
@@ -2607,12 +2607,12 @@ class DisplayMappingResults:
                             #Yc = yZero - qtlresult['lod_score']*self.LODFACTOR*LRSHeightThresh/LRSAxisList[-1]
                             Yc = yZero - \
                                 qtlresult['lod_score'] * self.LODFACTOR * \
-                                    LRSHeightThresh / LRS_LOD_Max
+                                LRSHeightThresh / LRS_LOD_Max
                         else:
                             #Yc = yZero - qtlresult['lod_score']*LRSHeightThresh/LRSAxisList[-1]
                             Yc = yZero - \
                                 qtlresult['lod_score'] * \
-                                    LRSHeightThresh / LRS_LOD_Max
+                                LRSHeightThresh / LRS_LOD_Max
 
                 if self.manhattan_plot == True:
                     if self.color_scheme == "single":
@@ -2665,7 +2665,7 @@ class DisplayMappingResults:
                             Xcm = Xc
                         else:
                             Xcm = (yZero - Yc0) / \
-                                   ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                                ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2731,7 +2731,7 @@ class DisplayMappingResults:
                             Xcm = Xc
                         else:
                             Xcm = (yZero - Yc0) / \
-                                   ((Yc - Yc0) / (Xc - Xc0)) + Xc0
+                                ((Yc - Yc0) / (Xc - Xc0)) + Xc0
                         if Yc0 < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xcm, yZero)),
@@ -2947,12 +2947,12 @@ class DisplayMappingResults:
         if self.dataset.group.species == "mouse":
             if refGene:
                 gene_table_header_list = ["Index",
-                                               "Symbol",
-                                               "Mb Start",
-                                               "Length (Kb)",
-                                               "SNP Count",
-                                               "SNP Density",
-                                               "Avg Expr",
+                                          "Symbol",
+                                          "Mb Start",
+                                          "Length (Kb)",
+                                          "SNP Count",
+                                          "SNP Density",
+                                          "Avg Expr",
                                                "Human Chr",
                                                "Mb Start (hg19)",
                                                "Literature Correlation",
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index 9f9591ad..5d16abde 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -26,18 +26,18 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         gen_pheno_txt_file(samples, vals, trait_filename)
 
         output_filename = (f"{this_dataset.group.name}_GWA_"
-            + ''.join(random.choice(string.ascii_uppercase + string.digits)
-                    for _ in range(6))
-            )
+                           + ''.join(random.choice(string.ascii_uppercase + string.digits)
+                                     for _ in range(6))
+        )
         bootstrap_filename = None
         permu_filename = None
 
         opt_list = []
         if boot_check and num_bootstrap > 0:
             bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_"
-                + ''.join(random.choice(string.ascii_uppercase + string.digits)
-                        for _ in range(6))
-                )
+                                  + ''.join(random.choice(string.ascii_uppercase + string.digits)
+                                            for _ in range(6))
+            )
 
             opt_list.append("-b")
             opt_list.append(f"--n_bootstrap {str(num_bootstrap)}")
@@ -45,8 +45,8 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
                 f"--bootstrap_output {webqtlConfig.GENERATED_IMAGE_DIR}{bootstrap_filename}.txt")
         if num_perm > 0:
             permu_filename = ("{this_dataset.group.name}_PERM_"
-            + ''.join(random.choice(string.ascii_uppercase
-                + string.digits) for _ in range(6))
+                              + ''.join(random.choice(string.ascii_uppercase
+                                                      + string.digits) for _ in range(6))
             )
             opt_list.append("-n " + str(num_perm))
             opt_list.append(
@@ -57,15 +57,15 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             opt_list.append("--interval 1")
 
         reaper_command = (REAPER_COMMAND +
-        ' --geno {0}/{1}.geno --traits {2}/gn2/{3}.txt {4} -o {5}{6}.txt'.format(flat_files('genotype'),
+                          ' --geno {0}/{1}.geno --traits {2}/gn2/{3}.txt {4} -o {5}{6}.txt'.format(flat_files('genotype'),
 
-                                                                              genofile_name,
-                                                                              TEMPDIR,
-                                                                              trait_filename,
-                                                                              " ".join(
-                                                                                  opt_list),
-                                                                              webqtlConfig.GENERATED_IMAGE_DIR,
-                                                                            output_filename))
+                                                                                                   genofile_name,
+                                                                                                   TEMPDIR,
+                                                                                                   trait_filename,
+                                                                                                   " ".join(
+                              opt_list),
+                              webqtlConfig.GENERATED_IMAGE_DIR,
+                              output_filename))
 
         logger.debug("reaper_command:" + reaper_command)
         os.system(reaper_command)
@@ -82,7 +82,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         significant = permu_vals[int(num_perm * 0.95 - 1)]
 
     return (marker_obs, permu_vals, suggestive, significant, bootstrap_vals,
-        [output_filename, permu_filename, bootstrap_filename])
+            [output_filename, permu_filename, bootstrap_filename])
 
 
 def gen_pheno_txt_file(samples, vals, trait_filename):
@@ -231,17 +231,17 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
                     control_geno.append(control_geno2[_idx])
 
             bootstrap_results = genotype.bootstrap(strains=trimmed_samples,
-                                                        trait=trimmed_values,
-                                                        control=control_geno,
-                                                        nboot=num_bootstrap)
+                                                   trait=trimmed_values,
+                                                   control=control_geno,
+                                                   nboot=num_bootstrap)
     else:
         reaper_results = genotype.regression(strains=trimmed_samples,
                                              trait=trimmed_values)
 
         if bootCheck:
             bootstrap_results = genotype.bootstrap(strains=trimmed_samples,
-                                                        trait=trimmed_values,
-                                                        nboot=num_bootstrap)
+                                                   trait=trimmed_values,
+                                                   nboot=num_bootstrap)
 
     json_data['chr'] = []
     json_data['pos'] = []
@@ -265,7 +265,7 @@ def run_original_reaper(this_trait, dataset, samples_before, trait_vals, json_da
         # if self.additive:
         #    self.json_data['additive'].append(qtl.additive)
         locus = {"name": reaper_locus.name, "chr": reaper_locus.chr,
-            "cM": reaper_locus.cM, "Mb": reaper_locus.Mb}
+                 "cM": reaper_locus.cM, "Mb": reaper_locus.Mb}
         qtl = {"lrs_value": qtl.lrs, "chr": converted_chr, "Mb": reaper_locus.Mb,
                "cM": reaper_locus.cM, "name": reaper_locus.name, "additive": qtl.additive, "dominance": qtl.dominance}
         qtl_results.append(qtl)
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index 32dbad1f..cf8cf514 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -411,7 +411,7 @@ def process_pair_scan_results(result):
 
     result = result[1]
     output = [tuple([result[j][i] for j in range(result.ncol)])
-                    for i in range(result.nrow)]
+              for i in range(result.nrow)]
 
     for i, line in enumerate(result.iter_row()):
         marker = {}
@@ -441,7 +441,7 @@ def process_rqtl_perm_results(num_perm, results):
 def process_rqtl_results(result, species_name):
     qtl_results = []
     output = [tuple([result[j][i] for j in range(result.ncol)])
-                    for i in range(result.nrow)]
+              for i in range(result.nrow)]
 
     for i, line in enumerate(result.iter_row()):
         marker = {}
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index 041f4348..81e0a03f 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -289,18 +289,18 @@ class RunMapping:
                             ",")
 
                 results, self.perm_output, self.suggestive, self.significant, self.bootstrap_results, self.output_files = qtlreaper_mapping.run_reaper(self.this_trait,
-                                                                                                                                    self.dataset,
-                                                                                                                                    self.samples,
-                                                                                                                                    self.vals,
-                                                                                                                                    self.json_data,
-                                                                                                                                    self.num_perm,
-                                                                                                                                    self.bootCheck,
-                                                                                                                                    self.num_bootstrap,
-                                                                                                                                    self.do_control,
-                                                                                                                                    self.control_marker,
-                                                                                                                                    self.manhattan_plot,
-                                                                                                                                    self.first_run,
-                                                                                                                                    self.output_files)
+                                                                                                                                                       self.dataset,
+                                                                                                                                                       self.samples,
+                                                                                                                                                       self.vals,
+                                                                                                                                                       self.json_data,
+                                                                                                                                                       self.num_perm,
+                                                                                                                                                       self.bootCheck,
+                                                                                                                                                       self.num_bootstrap,
+                                                                                                                                                       self.do_control,
+                                                                                                                                                       self.control_marker,
+                                                                                                                                                       self.manhattan_plot,
+                                                                                                                                                       self.first_run,
+                                                                                                                                                       self.output_files)
             else:
                 results, self.json_data, self.perm_output, self.suggestive, self.significant, self.bootstrap_results = qtlreaper_mapping.run_original_reaper(self.this_trait,
                                                                                                                                                              self.dataset,
@@ -371,7 +371,7 @@ class RunMapping:
                         ps=this_ps,
                         url="/show_trait?trait_id=" + \
                             marker['name'] + "&dataset=" + \
-                                self.dataset.group.name + "Geno"
+                        self.dataset.group.name + "Geno"
                     )
 
                     if self.geno_db_exists == "True":
@@ -382,7 +382,7 @@ class RunMapping:
                             pos=this_ps,
                             url="/show_trait?trait_id=" + \
                                 marker['name'] + "&dataset=" + \
-                                    self.dataset.group.name + "Geno"
+                            self.dataset.group.name + "Geno"
                         )
                     else:
                         annot_marker = dict(
@@ -409,11 +409,11 @@ class RunMapping:
                             if 'Mb' in marker.keys():
                                 marker['display_pos'] = "Chr" + \
                                     str(marker['chr']) + ": " + \
-                                        "{:.6f}".format(marker['Mb'])
+                                    "{:.6f}".format(marker['Mb'])
                             elif 'cM' in marker.keys():
                                 marker['display_pos'] = "Chr" + \
                                     str(marker['chr']) + ": " + \
-                                        "{:.3f}".format(marker['cM'])
+                                    "{:.3f}".format(marker['cM'])
                             else:
                                 marker['display_pos'] = "N/A"
                             self.qtl_results.append(marker)
@@ -776,7 +776,7 @@ def get_perm_strata(this_trait, sample_list, categorical_vars, used_samples):
         perm_strata_strings.append(combined_string)
 
     d = dict([(y, x + 1)
-             for x, y in enumerate(sorted(set(perm_strata_strings)))])
+              for x, y in enumerate(sorted(set(perm_strata_strings)))])
     list_to_numbers = [d[x] for x in perm_strata_strings]
     perm_strata = list_to_numbers
 
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index 55b0278a..822900cc 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -45,8 +45,8 @@ class User(Base):
                           )
 
     user_collections = relationship("UserCollection",
-                          order_by="asc(UserCollection.name)",
-                          lazy='dynamic',
+                                    order_by="asc(UserCollection.name)",
+                                    lazy='dynamic',
                           )
 
     def display_num_collections(self):
diff --git a/wqflask/wqflask/parser.py b/wqflask/wqflask/parser.py
index 6b836e20..bd1c4407 100644
--- a/wqflask/wqflask/parser.py
+++ b/wqflask/wqflask/parser.py
@@ -34,7 +34,7 @@ def parse(pstring):
                        (\w+\s*[=:\>\<][\w\*]+)  |  # wiki=bar, GO:foobar, etc
                        (".*?") | ('.*?') | # terms in quotes, i.e. "brain weight"
                        ([\w\*\?]+))  # shh, brain, etc """, pstring,
-                                                    flags=re.VERBOSE)
+                       flags=re.VERBOSE)
 
     pstring = [item.strip() for item in pstring if item and item.strip()]
 
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index 2e1cb992..fc48959e 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -173,10 +173,10 @@ class SearchResultPage:
 
         if self.dataset.type == "ProbeSet":
             self.header_data_names = ['index', 'display_name', 'symbol', 'description',
-                'location', 'mean', 'lrs_score', 'lrs_location', 'additive']
+                                      'location', 'mean', 'lrs_score', 'lrs_location', 'additive']
         elif self.dataset.type == "Publish":
             self.header_data_names = ['index', 'display_name', 'description', 'mean',
-                'authors', 'pubmed_text', 'lrs_score', 'lrs_location', 'additive']
+                                      'authors', 'pubmed_text', 'lrs_score', 'lrs_location', 'additive']
         elif self.dataset.type == "Geno":
             self.header_data_names = ['index', 'display_name', 'location']
 
@@ -273,9 +273,9 @@ class SearchResultPage:
         if search_ob:
             search_class = getattr(do_search, search_ob)
             the_search = search_class(search_term,
-                                    search_operator,
-                                    self.dataset,
-                                    search_type['key']
+                                      search_operator,
+                                      self.dataset,
+                                      search_type['key']
                                     )
             return the_search
         else:
diff --git a/wqflask/wqflask/server_side.py b/wqflask/wqflask/server_side.py
index 8ca3a9eb..7f68efad 100644
--- a/wqflask/wqflask/server_side.py
+++ b/wqflask/wqflask/server_side.py
@@ -49,8 +49,8 @@ class ServerSideTable:
                 column_name = self.header_data_names[column_number - 1]
                 sort_direction = self.request_values['sSortDir_' + str(i)]
                 self.table_rows = sorted(self.table_rows,
-                              key=lambda x: x[column_name],
-                              reverse=is_reverse(sort_direction))
+                                         key=lambda x: x[column_name],
+                                         reverse=is_reverse(sort_direction))
 
     def paginate_rows(self):
         """
diff --git a/wqflask/wqflask/show_trait/SampleList.py b/wqflask/wqflask/show_trait/SampleList.py
index 3a63c84e..f9d30dba 100644
--- a/wqflask/wqflask/show_trait/SampleList.py
+++ b/wqflask/wqflask/show_trait/SampleList.py
@@ -75,7 +75,7 @@ class SampleList:
                     if self.dataset.group.species == "mouse":
                         if len(sample.extra_attributes['rrid'].split(":")) > 1:
                             the_rrid = sample.extra_attributes['rrid'].split(":")[
-                                                                             1]
+                                1]
                             sample.extra_attributes['rrid'] = [
                                 sample.extra_attributes['rrid']]
                             sample.extra_attributes['rrid'].append(
@@ -83,7 +83,7 @@ class SampleList:
                     elif self.dataset.group.species == "rat":
                         if len(str(sample.extra_attributes['rrid'])):
                             the_rrid = sample.extra_attributes['rrid'].split("_")[
-                                                                             1]
+                                1]
                             sample.extra_attributes['rrid'] = [
                                 sample.extra_attributes['rrid']]
                             sample.extra_attributes['rrid'].append(
diff --git a/wqflask/wqflask/show_trait/export_trait_data.py b/wqflask/wqflask/show_trait/export_trait_data.py
index 81e7903b..7fabc3f6 100644
--- a/wqflask/wqflask/show_trait/export_trait_data.py
+++ b/wqflask/wqflask/show_trait/export_trait_data.py
@@ -41,7 +41,7 @@ def get_export_metadata(trait_id, dataset_name):
     if dataset.type == "Publish":
         metadata.append(["Phenotype ID: " + trait_id])
         metadata.append(["Phenotype URL: " + "http://genenetwork.org/show_trait?trait_id=" + \
-                        trait_id + "&dataset=" + dataset_name])
+                         trait_id + "&dataset=" + dataset_name])
         metadata.append(["Group: " + dataset.group.name])
         metadata.append(
             ["Phenotype: " + this_trait.description_display.replace(",", "\",\"")])
@@ -56,7 +56,7 @@ def get_export_metadata(trait_id, dataset_name):
     else:
         metadata.append(["Record ID: " + trait_id])
         metadata.append(["Trait URL: " + "http://genenetwork.org/show_trait?trait_id=" + \
-                        trait_id + "&dataset=" + dataset_name])
+                         trait_id + "&dataset=" + dataset_name])
         if this_trait.symbol:
             metadata.append(["Symbol: " + this_trait.symbol])
         metadata.append(["Dataset: " + dataset.name])
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index 5b7a663c..42fe339e 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -294,7 +294,7 @@ class SnpBrowser:
 
                 effect_info_dict = get_effect_info(effect_list)
                 coding_domain_list = ['Start Gained', 'Start Lost',
-                    'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
+                                      'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
                 intron_domain_list = ['Splice Site', 'Nonsplice Site']
 
                 for key in effect_info_dict:
@@ -320,7 +320,7 @@ class SnpBrowser:
                         if self.redundant == "false" or last_mb != mb:  # filter redundant
                             if self.include_record(domain, function, snp_source, conservation_score):
                                 info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain,
-                                    function, function_details, snp_source, conservation_score, snp_id]
+                                             function, function_details, snp_source, conservation_score, snp_id]
                                 info_list.extend(self.allele_list)
                                 filtered_results.append(info_list)
                         last_mb = mb
@@ -351,7 +351,7 @@ class SnpBrowser:
                             if self.redundant == "false" or last_mb != mb:
                                 if self.include_record(domain, function, snp_source, conservation_score):
                                     info_list = [snp_name, rs, chr, mb, alleles, gene, transcript, exon, domain,
-                                        function, function_details, snp_source, conservation_score, snp_id]
+                                                 function, function_details, snp_source, conservation_score, snp_id]
                                     info_list.extend(self.allele_list)
                                     filtered_results.append(info_list)
                             last_mb = mb
@@ -366,7 +366,7 @@ class SnpBrowser:
                     domain = conservation_score = snp_id = snp_name = rs = flank_3 = flank_5 = ncbi = function = ""
                     if self.include_record(domain, function, source_name, conservation_score):
                         filtered_results.append([indel_name, indel_chr, indel_mb_start, indel_mb_end,
-                                                indel_strand, indel_type, indel_size, indel_sequence, source_name])
+                                                 indel_strand, indel_type, indel_size, indel_sequence, source_name])
                 last_mb = indel_mb_start
 
             else:
@@ -703,9 +703,9 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
     header_data_names = []
     if variant_type == "SNP":
         header_fields.append(['Index', 'SNP ID', 'Chr', 'Mb', 'Alleles', 'Source', 'ConScore',
-                             'Gene', 'Transcript', 'Exon', 'Domain 1', 'Domain 2', 'Function', 'Details'])
+                              'Gene', 'Transcript', 'Exon', 'Domain 1', 'Domain 2', 'Function', 'Details'])
         header_data_names = ['index', 'snp_name', 'chr', 'mb_formatted', 'alleles', 'snp_source', 'conservation_score',
-            'gene_name', 'transcript', 'exon', 'domain_1', 'domain_2', 'function', 'function_details']
+                             'gene_name', 'transcript', 'exon', 'domain_1', 'domain_2', 'function', 'function_details']
 
         header_fields.append(strain_list)
         header_data_names += strain_list
@@ -742,9 +742,9 @@ def get_header_list(variant_type, strains, species=None, empty_columns=None):
 
     elif variant_type == "InDel":
         header_fields = ['Index', 'ID', 'Type', 'InDel Chr',
-            'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source']
+                         'Mb Start', 'Mb End', 'Strand', 'Size', 'Sequence', 'Source']
         header_data_names = ['index', 'indel_name', 'indel_type', 'indel_chr', 'indel_mb_s',
-            'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name']
+                             'indel_mb_e', 'indel_strand', 'indel_size', 'indel_sequence', 'source_name']
 
     return header_fields, empty_field_count, header_data_names
 
@@ -758,9 +758,9 @@ def get_effect_details_by_category(effect_name=None, effect_value=None):
     tmp_list = []
 
     gene_group_list = ['Upstream', 'Downstream',
-        'Splice Site', 'Nonsplice Site', '3\' UTR']
+                       'Splice Site', 'Nonsplice Site', '3\' UTR']
     biotype_group_list = ['Unknown Effect In Exon', 'Start Gained',
-        'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
+                          'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
     new_codon_group_list = ['Start Gained']
     codon_effect_group_list = [
         'Start Lost', 'Stop Gained', 'Stop Lost', 'Nonsynonymous', 'Synonymous']
@@ -913,7 +913,7 @@ def get_gene_id_name_dict(species_id, gene_name_list):
     if len(gene_name_list) == 0:
         return ""
     gene_name_str_list = ["'" + gene_name + \
-        "'" for gene_name in gene_name_list]
+                          "'" for gene_name in gene_name_list]
     gene_name_str = ",".join(gene_name_str_list)
 
     query = """
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index 725e7c9e..0d5f1f3e 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -59,12 +59,12 @@ def encode_password(pass_gen_fields, unencrypted_password):
 
 def set_password(password):
     pass_gen_fields = {
-      "unencrypted_password": password,
-      "algorithm": "pbkdf2",
-      "hashfunc": "sha256",
-      "salt": base64.b64encode(os.urandom(32)),
-      "iterations": 100000,
-      "keylength": 32,
+        "unencrypted_password": password,
+        "algorithm": "pbkdf2",
+        "hashfunc": "sha256",
+        "salt": base64.b64encode(os.urandom(32)),
+        "iterations": 100000,
+        "keylength": 32,
       "created_timestamp": timestamp()
     }
 
@@ -89,18 +89,18 @@ def get_signed_session_id(user):
 
     if 'github_id' in user:
         session = dict(login_time=time.time(),
-                    user_type="github",
-                    user_id=user['user_id'],
-                    github_id=user['github_id'],
-                    user_name=user['name'],
-                    user_url=user['user_url'])
+                       user_type="github",
+                       user_id=user['user_id'],
+                       github_id=user['github_id'],
+                       user_name=user['name'],
+                       user_url=user['user_url'])
     elif 'orcid' in user:
         session = dict(login_time=time.time(),
-                    user_type="orcid",
-                    user_id=user['user_id'],
-                    github_id=user['orcid'],
-                    user_name=user['name'],
-                    user_url=user['user_url'])
+                       user_type="orcid",
+                       user_id=user['user_id'],
+                       github_id=user['orcid'],
+                       user_name=user['name'],
+                       user_url=user['user_url'])
     else:
         session = dict(login_time=time.time(),
                        user_type="gn2",
@@ -269,7 +269,7 @@ def github_oauth2():
     result = requests.post(
         "https://github.com/login/oauth/access_token", json=data)
     result_dict = {arr[0]: arr[1]
-        for arr in [tok.split("=") for tok in result.text.split("&")]}
+                   for arr in [tok.split("=") for tok in result.text.split("&")]}
 
     github_user = get_github_user_details(result_dict["access_token"])
 
diff --git a/wqflask/wqflask/user_manager.py b/wqflask/wqflask/user_manager.py
index 9ebec405..fb26bfb1 100644
--- a/wqflask/wqflask/user_manager.py
+++ b/wqflask/wqflask/user_manager.py
@@ -475,7 +475,7 @@ def set_password(password, user):
     pwfields.encrypt_time = enc_password.encrypt_time
 
     user.password = json.dumps(pwfields.__dict__,
-                                    sort_keys=True,
+                               sort_keys=True,
                                    )
 
 
diff --git a/wqflask/wqflask/user_session.py b/wqflask/wqflask/user_session.py
index 3e543445..67e2e158 100644
--- a/wqflask/wqflask/user_session.py
+++ b/wqflask/wqflask/user_session.py
@@ -105,8 +105,8 @@ class UserSession:
             if user_cookie:
                 self.logged_in = False
                 self.record = dict(login_time=time.time(),
-                                    user_type="anon",
-                                    user_id=str(uuid.uuid4()))
+                                   user_type="anon",
+                                   user_id=str(uuid.uuid4()))
                 Redis.hmset(self.redis_key, self.record)
                 Redis.expire(self.redis_key, THIRTY_DAYS)
 
@@ -117,8 +117,8 @@ class UserSession:
                 return None
             else:
                 self.record = dict(login_time=time.time(),
-                                    user_type="anon",
-                                    user_id=str(uuid.uuid4()))
+                                   user_type="anon",
+                                   user_id=str(uuid.uuid4()))
                 Redis.hmset(self.redis_key, self.record)
                 Redis.expire(self.redis_key, THIRTY_DAYS)
         else:
diff --git a/wqflask/wqflask/wgcna/wgcna_analysis.py b/wqflask/wqflask/wgcna/wgcna_analysis.py
index 21516b30..f96892a0 100644
--- a/wqflask/wqflask/wgcna/wgcna_analysis.py
+++ b/wqflask/wqflask/wgcna/wgcna_analysis.py
@@ -70,7 +70,7 @@ class WGCNA:
         self.trait_db_list = [trait.strip()
                               for trait in requestform['trait_list'].split(',')]
         print(("Retrieved phenotype data from database",
-              requestform['trait_list']))
+               requestform['trait_list']))
         helper_functions.get_trait_db_obs(self, self.trait_db_list)
 
         # self.input contains the phenotype values we need to send to R
-- 
cgit v1.2.3


From 99f8bdbb70e4e00df6671c3f20db4857ffa96d6f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 30 Apr 2021 13:15:10 +0300
Subject: autopep8: Run autopep8 100 times with target rules

Rules used are:
E20,E211,E22,E224,E224,E225,E226,E227,E228,E231,E241,E242,
E251,E252,E26,E265,E266,E27,E301,E302,E303,E304,E305,E306,
E401,E501,E70,E701,W291,W292,W293,W391,W504,E101,E11,E121,
E122,E123,E124,E125,E126,E127,E128,E129,E131,E133
---
 wqflask/base/webqtlConfig.py                       |   2 +-
 wqflask/maintenance/quantile_normalize.py          |   2 +-
 .../marker_regression/test_qtlreaper_mapping.py    |   7 +-
 .../wqflask/marker_regression/test_rqtl_mapping.py |   4 +-
 wqflask/utility/Plot.py                            |   5 +-
 wqflask/utility/elasticsearch_tools.py             |   2 +-
 wqflask/utility/svg.py                             |  50 ++++-----
 wqflask/wqflask/api/mapping.py                     |   3 +-
 wqflask/wqflask/api/router.py                      |  30 +++---
 wqflask/wqflask/collect.py                         |   8 +-
 wqflask/wqflask/correlation/corr_scatter_plot.py   |   4 +-
 wqflask/wqflask/correlation/show_corr_results.py   |  34 +++---
 .../wqflask/correlation_matrix/show_corr_matrix.py |   2 +-
 wqflask/wqflask/ctl/ctl_analysis.py                |   2 +-
 wqflask/wqflask/group_manager.py                   |   8 +-
 wqflask/wqflask/interval_analyst/GeneUtil.py       |   3 +-
 .../marker_regression/display_mapping_results.py   | 120 ++++++++++-----------
 wqflask/wqflask/marker_regression/gemma_mapping.py |   2 +-
 .../wqflask/marker_regression/qtlreaper_mapping.py |   9 +-
 wqflask/wqflask/marker_regression/rqtl_mapping.py  |  10 +-
 wqflask/wqflask/marker_regression/run_mapping.py   |   3 +-
 wqflask/wqflask/model.py                           |   4 +-
 wqflask/wqflask/resource_manager.py                |   2 +-
 wqflask/wqflask/search_results.py                  |   2 +-
 wqflask/wqflask/snp_browser/snp_browser.py         |   4 +-
 wqflask/wqflask/user_login.py                      |   6 +-
 wqflask/wqflask/user_manager.py                    |   6 +-
 wqflask/wqflask/views.py                           |   2 +-
 28 files changed, 172 insertions(+), 164 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/base/webqtlConfig.py b/wqflask/base/webqtlConfig.py
index 872b52eb..39947158 100644
--- a/wqflask/base/webqtlConfig.py
+++ b/wqflask/base/webqtlConfig.py
@@ -15,7 +15,7 @@ from utility.tools import valid_path, mk_dir, assert_dir, assert_writable_dir, f
 DEBUG = 1
 
 # USER privilege
-USERDICT = {'guest': 1, 'user': 2, 'admin': 3, 'root':4}
+USERDICT = {'guest': 1, 'user': 2, 'admin': 3, 'root': 4}
 
 # Set privileges
 SUPER_PRIVILEGES = {'data': 'edit', 'metadata': 'edit', 'admin': 'edit-admins'}
diff --git a/wqflask/maintenance/quantile_normalize.py b/wqflask/maintenance/quantile_normalize.py
index 88bb2cb5..0cc963e5 100644
--- a/wqflask/maintenance/quantile_normalize.py
+++ b/wqflask/maintenance/quantile_normalize.py
@@ -123,7 +123,7 @@ if __name__ == '__main__':
     success, _ = bulk(es, set_data(sys.argv[1]))
 
     response = es.search(
-        index="traits", doc_type="trait", body = {
+        index="traits", doc_type="trait", body={
             "query": {"match": {"name": "ENSMUSG00000028982"}}
         }
     )
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
index 93848a84..8b4337ec 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_qtlreaper_mapping.py
@@ -9,13 +9,14 @@ from wqflask.marker_regression.qtlreaper_mapping import gen_pheno_txt_file
 class TestQtlReaperMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.qtlreaper_mapping.TEMPDIR", "/home/user/data")
     def test_gen_pheno_txt_file(self):
-        vals = ["V1", "x", "V4", "V3","x"]
-        samples = ["S1", "S2", "S3", "S4","S5"]
+        vals = ["V1", "x", "V4", "V3", "x"]
+        samples = ["S1", "S2", "S3", "S4", "S5"]
         trait_filename = "trait_file"
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
             gen_pheno_txt_file(samples=samples, vals=vals,
                                trait_filename=trait_filename)
-            mock_open.assert_called_once_with("/home/user/data/gn2/trait_file.txt", "w")
+            mock_open.assert_called_once_with(
+                "/home/user/data/gn2/trait_file.txt", "w")
             filehandler = mock_open()
             write_calls = [mock.call('Trait\t'), mock.call(
                 'S1\tS3\tS4\n'), mock.call('T1\t'), mock.call('V1\tV4\tV3')]
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 68686e27..91d2c587 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -28,7 +28,7 @@ class TestRqtlMapping(unittest.TestCase):
 
     def test_sanitize_rqtl_phenotype(self):
         """test for sanitizing rqtl phenotype"""
-        vals = ['f', "x", "r", "x","x"]
+        vals = ['f', "x", "r", "x", "x"]
         results = sanitize_rqtl_phenotype(vals)
         expected_phenotype_string = 'c(f,NA,r,NA,NA)'
 
@@ -36,7 +36,7 @@ class TestRqtlMapping(unittest.TestCase):
 
     def test_sanitize_rqtl_names(self):
         """test for sanitzing rqtl names"""
-        vals = ['f', "x", "r", "x","x"]
+        vals = ['f', "x", "r", "x", "x"]
         expected_sanitized_name = "c('f',NA,'r',NA,NA)"
         results = sanitize_rqtl_names(vals)
         self.assertEqual(expected_sanitized_name, results)
diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index 37a8a1a5..9b2c6735 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -188,7 +188,8 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     for i in range(int(stepX) + 1):
         xc = xLeftOffset + (x - xLow) * xScale
         im_drawer.line(
-            xy=((xc, yTopOffset + plotHeight), (xc, yTopOffset + plotHeight + 5)),
+            xy=((xc, yTopOffset + plotHeight),
+                (xc, yTopOffset + plotHeight + 5)),
             fill=axesColor)
         strX = cformat(d=x, rank=0)
         im_drawer.text(
@@ -217,7 +218,7 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
             text=XLabel,
             xy=(xLeftOffset + (
                 plotWidth - im_drawer.textsize(XLabel, font=labelFont)[0]) / 2.0,
-                yTopOffset + plotHeight + yBottomOffset-10),
+                yTopOffset + plotHeight + yBottomOffset - 10),
             font=labelFont, fill=labelColor)
 
     if YLabel:
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index e56c22eb..eae3ba03 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -105,7 +105,7 @@ def get_item_by_unique_column(es, column_name, column_value, index, doc_type):
     item_details = None
     try:
         response = es.search(
-            index=index, doc_type=doc_type, body = {
+            index=index, doc_type=doc_type, body={
                 "query": {"match": {column_name: column_value}}
             })
         if len(response["hits"]["hits"]) > 0:
diff --git a/wqflask/utility/svg.py b/wqflask/utility/svg.py
index bc3bc833..eddb97da 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -229,13 +229,13 @@ class pathdata:
 
     def bezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy absolut"""
-        self.path.append('C' + str(x1) + ','+str(y1)+' '+str(x2)
-                         + ',' + str(y2) + ' '+str(x)+','+str(y))
+        self.path.append('C' + str(x1) + ',' + str(y1) + ' ' + str(x2)
+                         + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
 
     def relbezier(self, x1, y1, x2, y2, x, y):
         """bezier with xy1 and xy2 to xy relative"""
-        self.path.append('c' + str(x1) + ','+str(y1)+' '+str(x2)
-                         + ',' + str(y2) + ' '+str(x)+','+str(y))
+        self.path.append('c' + str(x1) + ',' + str(y1) + ' ' + str(x2)
+                         + ',' + str(y2) + ' ' + str(x) + ',' + str(y))
 
     def smbezier(self, x2, y2, x, y):
         """smooth bezier with xy2 to xy absolut"""
@@ -267,13 +267,13 @@ class pathdata:
 
     def ellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy absolut"""
-        self.path.append('A' + str(rx) + ','+str(ry)+' '+str(xrot)
-                         + ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('A' + str(rx) + ',' + str(ry) + ' ' + str(xrot)
+                         + ' ' + str(laf) + ' ' + str(sf) + ' ' + str(x) + ' ' + str(y))
 
     def relellarc(self, rx, ry, xrot, laf, sf, x, y):
         """elliptival arc with rx and ry rotating with xrot using large-arc-flag and sweep-flag  to xy relative"""
-        self.path.append('a' + str(rx) + ','+str(ry)+' '+str(xrot)
-                         + ' ' + str(laf) + ' '+str(sf)+' '+str(x)+' '+str(y))
+        self.path.append('a' + str(rx) + ',' + str(ry) + ' ' + str(xrot)
+                         + ' ' + str(laf) + ' ' + str(sf) + ' ' + str(x) + ' ' + str(y))
 
     def __repr__(self):
         return ' '.join(self.path)
@@ -471,7 +471,7 @@ class ellipse(SVGelement):
     an ellipse is defined as a center and a x and y radius.
     """
 
-    def __init__(self, cx=None, cy=None, rx=None, ry=None,fill=None,stroke=None,stroke_width=None,**args):
+    def __init__(self, cx=None, cy=None, rx=None, ry=None, fill=None, stroke=None, stroke_width=None, **args):
         if rx == None or ry == None:
             raise ValueError('both rx and ry are required')
 
@@ -494,7 +494,7 @@ class circle(SVGelement):
     The circle creates an element using a x, y and radius values eg
     """
 
-    def __init__(self, cx=None, cy=None, r=None, fill=None,stroke=None,stroke_width=None,**args):
+    def __init__(self, cx=None, cy=None, r=None, fill=None, stroke=None, stroke_width=None, **args):
         if r == None:
             raise ValueError('r is required')
         SVGelement.__init__(self, 'circle', {'r': r}, **args)
@@ -527,7 +527,7 @@ class line(SVGelement):
     A line is defined by a begin x,y pair and an end x,y pair
     """
 
-    def __init__(self, x1=None, y1=None, x2=None, y2=None,stroke=None,stroke_width=None,**args):
+    def __init__(self, x1=None, y1=None, x2=None, y2=None, stroke=None, stroke_width=None, **args):
         SVGelement.__init__(self, 'line', **args)
         if x1 != None:
             self.attributes['x1'] = x1
@@ -549,7 +549,7 @@ class polyline(SVGelement):
     a polyline is defined by a list of xy pairs
     """
 
-    def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
+    def __init__(self, points, fill=None, stroke=None, stroke_width=None, **args):
         SVGelement.__init__(self, 'polyline', {
                             'points': _xypointlist(points)}, **args)
         if fill != None:
@@ -566,7 +566,7 @@ class polygon(SVGelement):
     a polygon is defined by a list of xy pairs
     """
 
-    def __init__(self, points, fill=None, stroke=None, stroke_width=None,**args):
+    def __init__(self, points, fill=None, stroke=None, stroke_width=None, **args):
         SVGelement.__init__(
             self, 'polygon', {'points': _xypointlist(points)}, **args)
         if fill != None:
@@ -583,7 +583,7 @@ class path(SVGelement):
     a path is defined by a path object and optional width, stroke and fillcolor
     """
 
-    def __init__(self, pathdata, fill=None, stroke=None, stroke_width=None,id=None,**args):
+    def __init__(self, pathdata, fill=None, stroke=None, stroke_width=None, id=None, **args):
         SVGelement.__init__(self, 'path', {'d': str(pathdata)}, **args)
         if stroke != None:
             self.attributes['stroke'] = stroke
@@ -601,7 +601,7 @@ class text(SVGelement):
     a text element can bge used for displaying text on the screen
     """
 
-    def __init__(self, x=None, y=None, text=None, font_size=None,font_family=None,text_anchor=None,**args):
+    def __init__(self, x=None, y=None, text=None, font_size=None, font_family=None, text_anchor=None, **args):
         SVGelement.__init__(self, 'text', **args)
         if x != None:
             self.attributes['x'] = x
@@ -637,7 +637,7 @@ class pattern(SVGelement):
     in x and y to cover the areas to be painted.
     """
 
-    def __init__(self, x=None, y=None, width=None, height=None,patternUnits=None,**args):
+    def __init__(self, x=None, y=None, width=None, height=None, patternUnits=None, **args):
         SVGelement.__init__(self, 'pattern', **args)
         if x != None:
             self.attributes['x'] = x
@@ -684,7 +684,7 @@ class lineargradient(SVGelement):
     stop elements van be added to define the gradient colors.
     """
 
-    def __init__(self, x1=None, y1=None, x2=None, y2=None,id=None,**args):
+    def __init__(self, x1=None, y1=None, x2=None, y2=None, id=None, **args):
         SVGelement.__init__(self, 'linearGradient', **args)
         if x1 != None:
             self.attributes['x1'] = x1
@@ -705,7 +705,7 @@ class radialgradient(SVGelement):
     stop elements van be added to define the gradient colors.
     """
 
-    def __init__(self, cx=None, cy=None, r=None, fx=None,fy=None,id=None,**args):
+    def __init__(self, cx=None, cy=None, r=None, fx=None, fy=None, id=None, **args):
         SVGelement.__init__(self, 'radialGradient', **args)
         if cx != None:
             self.attributes['cx'] = cx
@@ -749,11 +749,11 @@ class image(SVGelement):
     adds an image to the drawing. Supported formats are .png, .jpg and .svg.
     """
 
-    def __init__(self, url, x=None, y=None, width=None,height=None,**args):
+    def __init__(self, url, x=None, y=None, width=None, height=None, **args):
         if width == None or height == None:
             raise ValueError('both height and width are required')
         SVGelement.__init__(
-            self, 'image', {'xlink:href': url, 'width': width, 'height':height}, **args)
+            self, 'image', {'xlink:href': url, 'width': width, 'height': height}, **args)
         if x != None:
             self.attributes['x'] = x
         if y != None:
@@ -777,7 +777,7 @@ class marker(SVGelement):
     add an element to it which should be used as a marker.
     """
 
-    def __init__(self, id=None, viewBox=None, refx=None, refy=None,markerWidth=None,markerHeight=None,**args):
+    def __init__(self, id=None, viewBox=None, refx=None, refy=None, markerWidth=None, markerHeight=None, **args):
         SVGelement.__init__(self, 'marker', **args)
         if id != None:
             self.attributes['id'] = id
@@ -851,7 +851,7 @@ class use(SVGelement):
     references a symbol by linking to its id and its position, height and width
     """
 
-    def __init__(self, link, x=None, y=None, width=None,height=None,**args):
+    def __init__(self, link, x=None, y=None, width=None, height=None, **args):
         SVGelement.__init__(self, 'use', {'xlink:href': link}, **args)
         if x != None:
             self.attributes['x'] = x
@@ -904,7 +904,7 @@ class animate(SVGelement):
     animates an attribute.
     """
 
-    def __init__(self, attribute, fr=None, to=None, dur=None,**args):
+    def __init__(self, attribute, fr=None, to=None, dur=None, **args):
         SVGelement.__init__(
             self, 'animate', {'attributeName': attribute}, **args)
         if fr != None:
@@ -935,7 +935,7 @@ class animateTransform(SVGelement):
     transform an element from and to a value.
     """
 
-    def __init__(self, type=None, fr=None, to=None, dur=None,**args):
+    def __init__(self, type=None, fr=None, to=None, dur=None, **args):
         SVGelement.__init__(self, 'animateTransform', {
                             'attributeName': 'transform'}, **args)
         # As far as I know the attributeName is always transform
@@ -955,7 +955,7 @@ class animateColor(SVGelement):
     Animates the color of a element
     """
 
-    def __init__(self, attribute, type=None, fr=None, to=None,dur=None,**args):
+    def __init__(self, attribute, type=None, fr=None, to=None, dur=None, **args):
         SVGelement.__init__(self, 'animateColor', {
                             'attributeName': attribute}, **args)
         if type != None:
diff --git a/wqflask/wqflask/api/mapping.py b/wqflask/wqflask/api/mapping.py
index cbef96eb..f8b0d8bd 100644
--- a/wqflask/wqflask/api/mapping.py
+++ b/wqflask/wqflask/api/mapping.py
@@ -53,7 +53,8 @@ def do_mapping_for_api(start_vars):
         header_row = ["name", "chr", "cM", "lod_score"]
         if mapping_params['num_perm'] > 0:
             _sperm_output, _suggestive, _significant, result_markers = rqtl_mapping.run_rqtl_geno(vals, dataset, mapping_params['rqtl_method'], mapping_params['rqtl_model'],
-                                                                                                  mapping_params['perm_check'], mapping_params['num_perm'],
+                                                                                                  mapping_params['perm_check'], mapping_params[
+                                                                                                      'num_perm'],
                                                                                                   mapping_params['do_control'], mapping_params[
                 'control_marker'],
                 mapping_params['manhattan_plot'], mapping_params['pair_scan'])
diff --git a/wqflask/wqflask/api/router.py b/wqflask/wqflask/api/router.py
index 9d3446db..aec74c9e 100644
--- a/wqflask/wqflask/api/router.py
+++ b/wqflask/wqflask/api/router.py
@@ -98,8 +98,8 @@ def get_groups_list(species_name=None):
                 "Name": group[3],
                 "FullName": group[4],
                 "public": group[5],
-              "MappingMethodId": group[6],
-              "GeneticType": group[7]
+                "MappingMethodId": group[6],
+                "GeneticType": group[7]
             }
             groups_list.append(group_dict)
 
@@ -143,8 +143,8 @@ def get_group_info(group_name, species_name=None, file_format="json"):
             "Name": group[3],
             "FullName": group[4],
             "public": group[5],
-          "MappingMethodId": group[6],
-          "GeneticType": group[7]
+            "MappingMethodId": group[6],
+            "GeneticType": group[7]
         }
 
         return flask.jsonify(group_dict)
@@ -192,11 +192,11 @@ def get_datasets_for_group(group_name, species_name=None):
                 "Short_Abbreviation": dataset[3],
                 "Long_Abbreviation": dataset[4],
                 "FullName": dataset[5],
-              "ShortName": dataset[6],
-              "CreateTime": dataset[7],
-              "public": dataset[8],
-              "confidentiality": dataset[9],
-              "DataScale": dataset[10]
+                "ShortName": dataset[6],
+                "CreateTime": dataset[7],
+                "public": dataset[8],
+                "confidentiality": dataset[9],
+                "DataScale": dataset[10]
             }
             datasets_list.append(dataset_dict)
 
@@ -249,10 +249,10 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
             "full_name": dataset[2],
             "short_name": dataset[3],
             "data_scale": dataset[4],
-          "tissue_id": dataset[5],
-          "tissue": dataset[6],
-          "public": dataset[7],
-          "confidential": dataset[8]
+            "tissue_id": dataset[5],
+            "tissue": dataset[6],
+            "public": dataset[7],
+            "confidential": dataset[8]
         }
 
         datasets_list.append(dataset_dict)
@@ -286,7 +286,7 @@ def get_dataset_info(dataset_name, group_name=None, file_format="json"):
                     "description": dataset[2],
                     "pubmed_id": dataset[5],
                     "title": dataset[6],
-                  "year": dataset[7]
+                    "year": dataset[7]
                 }
             elif dataset[4]:
                 dataset_dict = {
@@ -777,7 +777,7 @@ def get_genotypes(group_name, file_format="csv", dataset_name=None):
                         i += 1
 
             csv_writer = csv.writer(
-                si, delimiter="\t", escapechar="\\", quoting = csv.QUOTE_NONE)
+                si, delimiter="\t", escapechar="\\", quoting=csv.QUOTE_NONE)
         else:
             return return_error(code=204, source=request.url_rule.rule, title="No Results", details="")
     elif file_format == "rqtl2":
diff --git a/wqflask/wqflask/collect.py b/wqflask/wqflask/collect.py
index 58518639..01274ba9 100644
--- a/wqflask/wqflask/collect.py
+++ b/wqflask/wqflask/collect.py
@@ -77,13 +77,13 @@ def collections_add():
         return render_template("collections/add.html",
                                traits=traits,
                                collections=collections,
-                              )
+                               )
     else:
         hash = request.args['hash']
         return render_template("collections/add.html",
                                hash=hash,
                                collections=collections,
-                              )
+                               )
 
 
 @app.route("/collections/new")
@@ -147,7 +147,7 @@ def list_collections():
     return render_template("collections/list.html",
                            params=params,
                            collections=user_collections,
-                            )
+                           )
 
 
 @app.route("/collections/remove", methods=('POST',))
@@ -226,7 +226,7 @@ def view_collection():
     else:
         return render_template("collections/view.html",
                                **collection_info
-                           )
+                               )
 
 
 @app.route("/collections/change_name", methods=('POST',))
diff --git a/wqflask/wqflask/correlation/corr_scatter_plot.py b/wqflask/wqflask/correlation/corr_scatter_plot.py
index 4f756f58..cafb9265 100644
--- a/wqflask/wqflask/correlation/corr_scatter_plot.py
+++ b/wqflask/wqflask/correlation/corr_scatter_plot.py
@@ -18,12 +18,12 @@ class CorrScatterPlot:
     def __init__(self, params):
         if "Temp" in params['dataset_1']:
             self.dataset_1 = data_set.create_dataset(
-                dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_1'].split("_")[1])
+                dataset_name="Temp", dataset_type="Temp", group_name=params['dataset_1'].split("_")[1])
         else:
             self.dataset_1 = data_set.create_dataset(params['dataset_1'])
         if "Temp" in params['dataset_2']:
             self.dataset_2 = data_set.create_dataset(
-                dataset_name="Temp", dataset_type="Temp", group_name = params['dataset_2'].split("_")[1])
+                dataset_name="Temp", dataset_type="Temp", group_name=params['dataset_2'].split("_")[1])
         else:
             self.dataset_2 = data_set.create_dataset(params['dataset_2'])
 
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index aa39bc5c..9b0b6118 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -79,7 +79,7 @@ class CorrelationResults:
         with Bench("Doing correlations"):
             if start_vars['dataset'] == "Temp":
                 self.dataset = data_set.create_dataset(
-                    dataset_name="Temp", dataset_type="Temp", group_name = start_vars['group'])
+                    dataset_name="Temp", dataset_type="Temp", group_name=start_vars['group'])
                 self.trait_id = start_vars['trait_id']
                 self.this_trait = create_trait(dataset=self.dataset,
                                                name=self.trait_id,
@@ -609,14 +609,14 @@ def get_header_fields(data_type, corr_method):
                              'Location',
                              'Mean',
                              'Sample rho',
-                                'N',
-                                'Sample p(rho)',
-                                'Lit rho',
-                                'Tissue rho',
-                                'Tissue p(rho)',
-                                'Max LRS',
-                                'Max LRS Location',
-                                'Additive Effect']
+                             'N',
+                             'Sample p(rho)',
+                             'Lit rho',
+                             'Tissue rho',
+                             'Tissue p(rho)',
+                             'Max LRS',
+                             'Max LRS Location',
+                             'Additive Effect']
         else:
             header_fields = ['Index',
                              'Record',
@@ -625,14 +625,14 @@ def get_header_fields(data_type, corr_method):
                              'Location',
                              'Mean',
                              'Sample r',
-                                'N',
-                                'Sample p(r)',
-                                'Lit r',
-                                'Tissue r',
-                                'Tissue p(r)',
-                                'Max LRS',
-                                'Max LRS Location',
-                                'Additive Effect']
+                             'N',
+                             'Sample p(r)',
+                             'Lit r',
+                             'Tissue r',
+                             'Tissue p(r)',
+                             'Max LRS',
+                             'Max LRS Location',
+                             'Additive Effect']
     elif data_type == "Publish":
         if corr_method == "spearman":
             header_fields = ['Index',
diff --git a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
index c1bf3daa..3a54a218 100644
--- a/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
+++ b/wqflask/wqflask/correlation_matrix/show_corr_matrix.py
@@ -211,7 +211,7 @@ class CorrelationMatrix:
 
         this_group_name = self.trait_list[0][1].group.name
         temp_dataset = data_set.create_dataset(
-            dataset_name="Temp", dataset_type="Temp", group_name = this_group_name)
+            dataset_name="Temp", dataset_type="Temp", group_name=this_group_name)
         temp_dataset.group.get_samplelist()
         for i, pca_trait in enumerate(pca_traits):
             trait_id = "PCA" + str(i + 1) + "_" + temp_dataset.group.species + "_" + \
diff --git a/wqflask/wqflask/ctl/ctl_analysis.py b/wqflask/wqflask/ctl/ctl_analysis.py
index a0fb34d8..bb928ec5 100644
--- a/wqflask/wqflask/ctl/ctl_analysis.py
+++ b/wqflask/wqflask/ctl/ctl_analysis.py
@@ -154,7 +154,7 @@ class CTL:
 
         # Perform the CTL scan
         res = self.r_CTLscan(rGeno, rPheno, strategy=strategy,
-                             nperm=nperm, parametric = parametric, nthreads=6)
+                             nperm=nperm, parametric=parametric, nthreads=6)
 
         # Get significant interactions
         significant = self.r_CTLsignificant(res, significance=significance)
diff --git a/wqflask/wqflask/group_manager.py b/wqflask/wqflask/group_manager.py
index b7e7e38a..04a100ba 100644
--- a/wqflask/wqflask/group_manager.py
+++ b/wqflask/wqflask/group_manager.py
@@ -120,14 +120,16 @@ def add_or_edit_group():
         if "admin_emails_to_add" in params:
             admin_emails = params['admin_emails_to_add'].split(",")
             for email in admin_emails:
-                user_details = get_user_by_unique_column("email_address", email)
+                user_details = get_user_by_unique_column(
+                    "email_address", email)
                 if user_details:
                     admin_user_ids.add(user_details['user_id'])
             #send_group_invites(params['group_id'], user_email_list = admin_emails, user_type="admins")
         if "member_emails_to_add" in params:
             member_emails = params['member_emails_to_add'].split(",")
             for email in member_emails:
-                user_details = get_user_by_unique_column("email_address", email)
+                user_details = get_user_by_unique_column(
+                    "email_address", email)
                 if user_details:
                     member_user_ids.add(user_details['user_id'])
             #send_group_invites(params['group_id'], user_email_list = user_emails, user_type="members")
@@ -156,7 +158,7 @@ def send_group_invites(group_id, user_email_list=[], user_type="members"):
                     continue
                 else:
                     send_verification_email(user_details, template_name="email/group_verification.txt",
-                                            key_prefix="verification_code", subject = "You've been invited to join a GeneNetwork user group")
+                                            key_prefix="verification_code", subject="You've been invited to join a GeneNetwork user group")
         else:
             temp_password = ''.join(random.choice(
                 string.ascii_uppercase + string.digits) for _ in range(6))
diff --git a/wqflask/wqflask/interval_analyst/GeneUtil.py b/wqflask/wqflask/interval_analyst/GeneUtil.py
index 04980281..5e86ae31 100644
--- a/wqflask/wqflask/interval_analyst/GeneUtil.py
+++ b/wqflask/wqflask/interval_analyst/GeneUtil.py
@@ -60,7 +60,8 @@ def loadGenes(chrName, diffCol, startMb, endMb, species='mouse'):
                 newdict["snpDensity"] = newdict["snpCount"] = 0
 
             try:
-                newdict['GeneLength'] = 1000.0 * (newdict['TxEnd'] - newdict['TxStart'])
+                newdict['GeneLength'] = 1000.0 * \
+                    (newdict['TxEnd'] - newdict['TxStart'])
             except:
                 pass
 
diff --git a/wqflask/wqflask/marker_regression/display_mapping_results.py b/wqflask/wqflask/marker_regression/display_mapping_results.py
index f3b1b1fc..5bf8822a 100644
--- a/wqflask/wqflask/marker_regression/display_mapping_results.py
+++ b/wqflask/wqflask/marker_regression/display_mapping_results.py
@@ -591,7 +591,7 @@ class DisplayMappingResults:
         intCanvas = Image.new("RGBA", size=(self.graphWidth, self.graphHeight))
         with Bench("Drawing Plot"):
             gifmap = self.plotIntMapping(
-                intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm)
+                intCanvas, startMb=self.startMb, endMb=self.endMb, showLocusForm=showLocusForm)
 
         self.gifmap = gifmap.__str__()
 
@@ -610,7 +610,7 @@ class DisplayMappingResults:
             intCanvasX2 = Image.new("RGBA", size=(
                 self.graphWidth * 2, self.graphHeight * 2))
             gifmapX2 = self.plotIntMapping(
-                intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm= showLocusForm, zoom=2)
+                intCanvasX2, startMb=self.startMb, endMb=self.endMb, showLocusForm=showLocusForm, zoom=2)
             intCanvasX2.save(
                 "{}.png".format(
                     os.path.join(webqtlConfig.GENERATED_IMAGE_DIR,
@@ -628,8 +628,8 @@ class DisplayMappingResults:
                 name=showLocusForm,
                 submit=HtmlGenWrapper.create_input_tag(type_='hidden'))
 
-            hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet+ \
-                    "Geno",'CellID':'_', 'RISet':fd.RISet, 'incparentsf1':'ON'}
+            hddn = {'FormID': 'showDatabase', 'ProbeSetID': '_', 'database': fd.RISet + \
+                    "Geno", 'CellID': '_', 'RISet': fd.RISet, 'incparentsf1': 'ON'}
             for key in hddn.keys():
                 showLocusForm.append(HtmlGenWrapper.create_input_tag(
                     name=key, value=hddn[key], type_='hidden'))
@@ -651,7 +651,7 @@ class DisplayMappingResults:
             btminfo.append(
                 'Mapping using genotype data as a trait will result in infinity LRS at one locus. In order to display the result properly, all LRSs higher than 100 are capped at 100.')
 
-    def plotIntMapping(self, canvas, offset=(80, 120, 90, 100), zoom=1, startMb= None, endMb = None, showLocusForm = ""):
+    def plotIntMapping(self, canvas, offset=(80, 120, 90, 100), zoom=1, startMb=None, endMb=None, showLocusForm=""):
         im_drawer = ImageDraw.Draw(canvas)
         # calculating margins
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
@@ -730,7 +730,7 @@ class DisplayMappingResults:
                                   zoom=zoom, startMb=startMb, endMb=endMb)
             if self.SNPChecked:
                 self.drawSNPTrackNew(
-                    canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb = endMb)
+                    canvas, offset=newoffset, zoom=2 * zoom, startMb=startMb, endMb=endMb)
 # BEGIN HaplotypeAnalyst
             if self.haplotypeAnalystChecked:
                 self.drawHaplotypeBand(
@@ -758,7 +758,7 @@ class DisplayMappingResults:
 
         return gifmap
 
-    def drawBootStrapResult(self, canvas, nboot, drawAreaHeight, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawBootStrapResult(self, canvas, nboot, drawAreaHeight, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -873,14 +873,14 @@ class DisplayMappingResults:
             font=VERDANA_FILE, size=13 * fontZoom)
         im_drawer.rectangle(
             xy=((canvas.size[0] - bootOffset, yZero - bootHeightThresh),
-                (canvas.size[0] - bootOffset - 15*zoom, yZero)),
+                (canvas.size[0] - bootOffset - 15 * zoom, yZero)),
             fill=YELLOW, outline=BLACK)
         im_drawer.line(
             xy=((canvas.size[0] - bootOffset + 4, yZero),
                 (canvas.size[0] - bootOffset, yZero)),
             fill=BLACK)
         TEXT_Y_DISPLACEMENT = -8
-        im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, yZero+TEXT_Y_DISPLACEMENT), text='0%',
+        im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, yZero + TEXT_Y_DISPLACEMENT), text='0%',
                        font=bootScaleFont, fill=BLACK)
 
         for item in bootScale:
@@ -891,7 +891,7 @@ class DisplayMappingResults:
                 xy=((canvas.size[0] - bootOffset + 4, bootY),
                     (canvas.size[0] - bootOffset, bootY)),
                 fill=BLACK)
-            im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, bootY+TEXT_Y_DISPLACEMENT),
+            im_drawer.text(xy=(canvas.size[0] - bootOffset + 10, bootY + TEXT_Y_DISPLACEMENT),
                            text='%2.1f' % item, font=bootScaleFont, fill=BLACK)
 
         if self.legendChecked:
@@ -910,7 +910,7 @@ class DisplayMappingResults:
                            text='Frequency of the Peak LRS',
                            font=smallLabelFont, fill=BLACK)
 
-    def drawProbeSetPosition(self, canvas, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawProbeSetPosition(self, canvas, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         if len(self.traitList) != 1:
             return
@@ -987,7 +987,7 @@ class DisplayMappingResults:
             draw_open_polygon(canvas, xy=traitPixel, outline=BLACK,
                               fill=self.TRANSCRIPT_LOCATION_COLOR)
 
-    def drawSNPTrackNew(self, canvas, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawSNPTrackNew(self, canvas, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.diffCol:
             return
@@ -1059,7 +1059,7 @@ class DisplayMappingResults:
 
             im_drawer.rectangle(
                 xy=((rightShift, yPaddingTop + kstep * 15),
-                    (rectWidth + rightShift, yPaddingTop + 10+kstep*15)),
+                    (rectWidth + rightShift, yPaddingTop + 10 + kstep * 15)),
                 fill=thisLRSColor, outline=BLACK)
             im_drawer.text(
                 text=name, xy=(rectWidth + 2 + rightShift,
@@ -1303,7 +1303,7 @@ class DisplayMappingResults:
                     text=string4, xy=(xLeftOffset, y_constant * fontZoom),
                     font=labelFont, fill=labelColor)
 
-    def drawGeneBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawGeneBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
             return
@@ -1434,7 +1434,7 @@ class DisplayMappingResults:
                     xy=(
                         (geneStartPix, geneYLocation + \
                          self.EACH_GENE_HEIGHT / 2 * zoom),
-                        (geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 *zoom)),
+                        (geneEndPix, geneYLocation + self.EACH_GENE_HEIGHT / 2 * zoom)),
                     fill=outlineColor, width=1)
 
                 # draw the arrows
@@ -1558,7 +1558,7 @@ class DisplayMappingResults:
                     target="_blank"))
 
 # BEGIN HaplotypeAnalyst
-    def drawHaplotypeBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawHaplotypeBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         if self.plotScale != 'physic' or self.selectedChr == -1 or not self.geneCol:
             return
 
@@ -1630,7 +1630,7 @@ class DisplayMappingResults:
                     geneStartPix = xLeftOffset + plotXScale * \
                         (float(txStart) - startMb) - 0
                     geneEndPix = xLeftOffset + plotXScale * \
-                        (float(txEnd) - startMb)  + 0
+                        (float(txEnd) - startMb) + 0
 
                     if oldgeneEndPix >= xLeftOffset:
                         drawStart = oldgeneEndPix + 4
@@ -1707,19 +1707,19 @@ class DisplayMappingResults:
 
                                     im_drawer.line(
                                         xy=((drawStart,
-                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                             geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
                                             (drawEnd,
-                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
-                                        fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
+                                             geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom)),
+                                        fill=mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
                                     fillColor = BLACK
                                     outlineColor = BLACK
                                     if lastGene == 0:
                                         im_drawer.rectangle(
                                             xy=((geneStartPix,
-                                                 geneYLocation + 2 * ind*self.EACH_GENE_HEIGHT*zoom),
+                                                 geneYLocation + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
                                                 (geneEndPix,
-                                                 geneYLocation + 2 *ind*self.EACH_GENE_HEIGHT + 2*self.EACH_GENE_HEIGHT*zoom)),
+                                                 geneYLocation + 2 * ind * self.EACH_GENE_HEIGHT + 2 * self.EACH_GENE_HEIGHT * zoom)),
                                             outline=outlineColor, fill=fillColor)
 
                                     COORDS = "%d, %d, %d, %d" % (
@@ -1741,10 +1741,10 @@ class DisplayMappingResults:
                                         mylineColor = self.HAPLOTYPE_RECOMBINATION
                                     im_drawer.line(
                                         xy=((plotRight,
-                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                             geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
                                             (drawEnd,
-                                             geneYLocation + 7 + 2*ind*self.EACH_GENE_HEIGHT*zoom)),
-                                        fill= mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
+                                             geneYLocation + 7 + 2 * ind * self.EACH_GENE_HEIGHT * zoom)),
+                                        fill=mylineColor, width=zoom * (self.EACH_GENE_HEIGHT + 2))
 
                             if lastGene == 0:
                                 draw_rotated_text(
@@ -1752,7 +1752,7 @@ class DisplayMappingResults:
                                     font=ImageFont.truetype(font=VERDANA_FILE,
                                                             size=12),
                                     xy=(geneStartPix,
-                                        geneYLocation + 17 + 2*maxind*self.EACH_GENE_HEIGHT*zoom),
+                                        geneYLocation + 17 + 2 * maxind * self.EACH_GENE_HEIGHT * zoom),
                                     fill=BLACK, angle=-90)
 
                             oldgeneEndPix = geneEndPix
@@ -1778,21 +1778,21 @@ class DisplayMappingResults:
                         im_drawer.text(
                             text="%s" % (samplelist[j]),
                             xy=((xLeftOffset + plotWidth + 10),
-                                geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                geneYLocation + 11 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
                             font=ImageFont.truetype(
                                 font=VERDANA_FILE, size=12),
                             fill=BLACK)
                         im_drawer.text(
                             text="%2.2f" % (expr),
                             xy=((xLeftOffset + plotWidth + 60),
-                                geneYLocation + 11 + 2*ind*self.EACH_GENE_HEIGHT*zoom),
+                                geneYLocation + 11 + 2 * ind * self.EACH_GENE_HEIGHT * zoom),
                             font=ImageFont.truetype(
                                 font=VERDANA_FILE, size=12),
                             fill=BLACK)
 
 # END HaplotypeAnalyst
 
-    def drawClickBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawClickBand(self, canvas, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         if self.plotScale != 'physic' or self.selectedChr == -1:
             return
@@ -1817,8 +1817,8 @@ class DisplayMappingResults:
 
         numBasesCurrentlyOnScreen = self.kONE_MILLION * \
             abs(startMb - endMb)  # Number of bases on screen now
-        flankingWidthInBases = int (
-            min((float(numBasesCurrentlyOnScreen) / 2.0), (5*self.kONE_MILLION)))
+        flankingWidthInBases = int(
+            min((float(numBasesCurrentlyOnScreen) / 2.0), (5 * self.kONE_MILLION)))
         webqtlZoomWidth = numBasesCurrentlyOnScreen / 16.0
         # Flanking width should be such that we either zoom in to a 10 million base region, or we show the clicked region at the same scale as we are currently seeing.
 
@@ -1990,7 +1990,7 @@ class DisplayMappingResults:
             # end of drawBrowserClickableRegions
         pass
 
-    def drawXAxis(self, canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawXAxis(self, canvas, drawAreaHeight, gifmap, plotXScale, showLocusForm, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -2087,7 +2087,7 @@ class DisplayMappingResults:
                 xy=(
                     xLeftOffset + (plotWidth - im_drawer.textsize(
                         "Megabases", font=megabaseLabelFont)[0]) / 2,
-                    strYLoc + MBLabelFont.font.height + 10*(zoom%2)),
+                    strYLoc + MBLabelFont.font.height + 10 * (zoom % 2)),
                 font=megabaseLabelFont, fill=BLACK)
             pass
         else:
@@ -2110,7 +2110,7 @@ class DisplayMappingResults:
                                 thisChr.append(
                                     [_locus.name, _locus.cM - Locus0CM])
                     else:
-                        for j in (0, nLoci / 4, nLoci / 2, nLoci*3/4, -1):
+                        for j in (0, nLoci / 4, nLoci / 2, nLoci * 3 / 4, -1):
                             while _chr[j].name == ' - ':
                                 j += 1
                             if _chr[j].cM != preLpos:
@@ -2162,23 +2162,23 @@ class DisplayMappingResults:
                                                             yZero + 25)),
                             fill=lineColor)
                         im_drawer.line(
-                            xy=((xLeftOffset + offsetA, yZero + 25), (xLeftOffset+offsetA,\
-                                                                      yZero + 40 + Zorder*(LRectWidth+3))),
+                            xy=((xLeftOffset + offsetA, yZero + 25), (xLeftOffset + offsetA,\
+                                                                      yZero + 40 + Zorder * (LRectWidth + 3))),
                             fill=lineColor)
                         rectColor = ORANGE
                     else:
                         im_drawer.line(
-                            xy=((xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3)-3), (\
-                                xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3))),
+                            xy=((xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3) - 3), (\
+                                xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3))),
                             fill=lineColor)
                         rectColor = DEEPPINK
                     im_drawer.rectangle(
-                        xy=((xLeftOffset + offsetA, yZero + 40+Zorder*(LRectWidth+3)),
+                        xy=((xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3)),
                             (xLeftOffset + offsetA - LRectHeight,
-                             yZero + 40 + Zorder*(LRectWidth+3)+LRectWidth)),
+                             yZero + 40 + Zorder * (LRectWidth + 3) + LRectWidth)),
                         outline=rectColor, fill=rectColor, width=0)
-                    COORDS = "%d,%d,%d,%d" % (xLeftOffset+offsetA-LRectHeight, yZero+40+Zorder*(LRectWidth+3),\
-                                              xLeftOffset + offsetA, yZero +40+Zorder*(LRectWidth+3)+LRectWidth)
+                    COORDS = "%d,%d,%d,%d" % (xLeftOffset + offsetA - LRectHeight, yZero + 40 + Zorder * (LRectWidth + 3),\
+                                              xLeftOffset + offsetA, yZero + 40 + Zorder * (LRectWidth + 3) + LRectWidth)
                     HREF = "/show_trait?trait_id=%s&dataset=%s" % (
                         Lname, self.dataset.group.name + "Geno")
                     #HREF="javascript:showDatabase3('%s','%s','%s','');" % (showLocusForm,fd.RISet+"Geno", Lname)
@@ -2203,13 +2203,13 @@ class DisplayMappingResults:
                 text="Centimorgans",
                 xy=(xLeftOffset + (plotWidth - im_drawer.textsize(
                     "Centimorgans", font=centimorganLabelFont)[0]) / 2,
-                    strYLoc + MBLabelFont.font.height + 10 * (zoom %2)),
+                    strYLoc + MBLabelFont.font.height + 10 * (zoom % 2)),
                 font=centimorganLabelFont, fill=BLACK)
 
         im_drawer.line(xy=((xLeftOffset, yZero), (xLeftOffset + plotWidth, yZero)),
                        fill=BLACK, width=X_AXIS_THICKNESS)  # Draw the X axis itself
 
-    def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb= None, endMb = None):
+    def drawQTL(self, canvas, drawAreaHeight, gifmap, plotXScale, offset=(40, 120, 80, 10), zoom=1, startMb=None, endMb=None):
         im_drawer = ImageDraw.Draw(canvas)
         xLeftOffset, xRightOffset, yTopOffset, yBottomOffset = offset
         plotWidth = canvas.size[0] - xLeftOffset - xRightOffset
@@ -2364,7 +2364,7 @@ class DisplayMappingResults:
             TEXT_Y_DISPLACEMENT = -10
             im_drawer.text(
                 text=scaleStr,
-                xy=(xLeftOffset - 4 - im_drawer.textsize(scaleStr, font=LRSScaleFont)[0]-5,
+                xy=(xLeftOffset - 4 - im_drawer.textsize(scaleStr, font=LRSScaleFont)[0] - 5,
                     yLRS + TEXT_Y_DISPLACEMENT),
                 font=LRSScaleFont, fill=self.LRS_COLOR)
 
@@ -2479,7 +2479,7 @@ class DisplayMappingResults:
                         if k > 0:
                             Xc0, Yc0 = AdditiveCoordXY[k - 1]
                             Xc, Yc = aPoint
-                            if (Yc0 - yZero) * (Yc-yZero) < 0:
+                            if (Yc0 - yZero) * (Yc - yZero) < 0:
                                 if Xc == Xc0:  # genotype , locus distance is 0
                                     Xcm = Xc
                                 else:
@@ -2509,7 +2509,7 @@ class DisplayMappingResults:
                                         fill=plusColor, width=lineWidth
                                         # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                                     )
-                            elif (Yc0 - yZero) * (Yc-yZero) > 0:
+                            elif (Yc0 - yZero) * (Yc - yZero) > 0:
                                 if Yc < yZero:
                                     im_drawer.line(
                                         xy=((Xc0, Yc0), (Xc, Yc)),
@@ -2660,7 +2660,7 @@ class DisplayMappingResults:
                 if k > 0:
                     Xc0, Yc0 = AdditiveCoordXY[k - 1]
                     Xc, Yc = aPoint
-                    if (Yc0 - yZero) * (Yc-yZero) < 0:
+                    if (Yc0 - yZero) * (Yc - yZero) < 0:
                         if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
@@ -2689,7 +2689,7 @@ class DisplayMappingResults:
                                 fill=plusColor, width=lineWidth
                                 # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
-                    elif (Yc0 - yZero) * (Yc-yZero) > 0:
+                    elif (Yc0 - yZero) * (Yc - yZero) > 0:
                         if Yc < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)), fill=plusColor,
@@ -2726,7 +2726,7 @@ class DisplayMappingResults:
                 if k > 0:
                     Xc0, Yc0 = DominanceCoordXY[k - 1]
                     Xc, Yc = aPoint
-                    if (Yc0 - yZero) * (Yc-yZero) < 0:
+                    if (Yc0 - yZero) * (Yc - yZero) < 0:
                         if Xc == Xc0:  # genotype , locus distance is 0
                             Xcm = Xc
                         else:
@@ -2754,7 +2754,7 @@ class DisplayMappingResults:
                                 fill=plusColor, width=lineWidth
                                 # , clipX=(xLeftOffset, xLeftOffset + plotWidth)
                             )
-                    elif (Yc0 - yZero) * (Yc-yZero) > 0:
+                    elif (Yc0 - yZero) * (Yc - yZero) > 0:
                         if Yc < yZero:
                             im_drawer.line(
                                 xy=((Xc0, Yc0), (Xc, Yc)),
@@ -2805,8 +2805,8 @@ class DisplayMappingResults:
                 scaleStr = "%2.3f" % item
                 im_drawer.text(
                     text=scaleStr,
-                    xy= (xLeftOffset + plotWidth + 6,
-                         additiveY + TEXT_Y_DISPLACEMENT),
+                    xy=(xLeftOffset + plotWidth + 6,
+                        additiveY + TEXT_Y_DISPLACEMENT),
                     font=additiveScaleFont, fill=self.ADDITIVE_COLOR_POSITIVE)
 
             im_drawer.line(
@@ -2818,7 +2818,7 @@ class DisplayMappingResults:
             xy=((xLeftOffset, yZero), (xLeftOffset, yTopOffset + 30 * (zoom - 1))),
             fill=self.LRS_COLOR, width=1 * zoom)  # the blue line running up the y axis
 
-    def drawGraphBackground(self, canvas, gifmap, offset=(80, 120, 80, 50), zoom=1, startMb= None, endMb = None):
+    def drawGraphBackground(self, canvas, gifmap, offset=(80, 120, 80, 50), zoom=1, startMb=None, endMb=None):
         # conditions
         # multiple Chromosome view
         # single Chromosome Physical
@@ -2953,10 +2953,10 @@ class DisplayMappingResults:
                                           "SNP Count",
                                           "SNP Density",
                                           "Avg Expr",
-                                               "Human Chr",
-                                               "Mb Start (hg19)",
-                                               "Literature Correlation",
-                                               "Gene Description"]
+                                          "Human Chr",
+                                          "Mb Start (hg19)",
+                                          "Literature Correlation",
+                                          "Gene Description"]
             else:
                 gene_table_header_list = ["",
                                           "Index",
@@ -3073,12 +3073,12 @@ class DisplayMappingResults:
                                         geneIdString,
                                         theGO["GeneSymbol"],
                                         target="_blank")
-                                    ),
+                                        ),
                                     str(HtmlGenWrapper.create_link_tag(
                                         mouseStartString,
                                         "{:.6f}".format(txStart),
                                         target="_blank")
-                                    ),
+                                        ),
                                     str(HtmlGenWrapper.create_link_tag(
                                         "javascript:rangeView('{}', {:f}, {:f})".format(
                                             str(chr_as_int),
diff --git a/wqflask/wqflask/marker_regression/gemma_mapping.py b/wqflask/wqflask/marker_regression/gemma_mapping.py
index 289f1d5c..f88c5ac8 100644
--- a/wqflask/wqflask/marker_regression/gemma_mapping.py
+++ b/wqflask/wqflask/marker_regression/gemma_mapping.py
@@ -150,7 +150,7 @@ def gen_covariates_file(this_dataset, covariates, samples):
         if dataset_name == "Temp":
             temp_group = trait_name.split("_")[2]
             dataset_ob = create_dataset(
-                dataset_name="Temp", dataset_type="Temp", group_name = temp_group)
+                dataset_name="Temp", dataset_type="Temp", group_name=temp_group)
         else:
             dataset_ob = create_dataset(covariate.split(":")[1])
         trait_ob = create_trait(dataset=dataset_ob,
diff --git a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
index 5d16abde..4d6715ba 100644
--- a/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
+++ b/wqflask/wqflask/marker_regression/qtlreaper_mapping.py
@@ -2,7 +2,8 @@ import os
 import math
 import string
 import random
-import json, re
+import json
+import re
 
 from base import webqtlConfig
 from base.trait import GeneralTrait
@@ -28,7 +29,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
         output_filename = (f"{this_dataset.group.name}_GWA_"
                            + ''.join(random.choice(string.ascii_uppercase + string.digits)
                                      for _ in range(6))
-        )
+                           )
         bootstrap_filename = None
         permu_filename = None
 
@@ -37,7 +38,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             bootstrap_filename = (f"{this_dataset.group.name}_BOOTSTRAP_"
                                   + ''.join(random.choice(string.ascii_uppercase + string.digits)
                                             for _ in range(6))
-            )
+                                  )
 
             opt_list.append("-b")
             opt_list.append(f"--n_bootstrap {str(num_bootstrap)}")
@@ -47,7 +48,7 @@ def run_reaper(this_trait, this_dataset, samples, vals, json_data, num_perm, boo
             permu_filename = ("{this_dataset.group.name}_PERM_"
                               + ''.join(random.choice(string.ascii_uppercase
                                                       + string.digits) for _ in range(6))
-            )
+                              )
             opt_list.append("-n " + str(num_perm))
             opt_list.append(
                 "--permu_output " + webqtlConfig.GENERATED_IMAGE_DIR + permu_filename + ".txt")
diff --git a/wqflask/wqflask/marker_regression/rqtl_mapping.py b/wqflask/wqflask/marker_regression/rqtl_mapping.py
index cf8cf514..1fa3dffe 100644
--- a/wqflask/wqflask/marker_regression/rqtl_mapping.py
+++ b/wqflask/wqflask/marker_regression/rqtl_mapping.py
@@ -110,7 +110,7 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
         if do_control == "true":
             logger.info("Using covariate")
             result_data_frame = scantwo(
-                cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method, n_cluster = 16)
+                cross_object, pheno="the_pheno", addcovar=covars, model=model, method=method, n_cluster=16)
         else:
             logger.info("No covariates")
             result_data_frame = scantwo(
@@ -140,14 +140,14 @@ def run_rqtl_geno(vals, samples, dataset, mapping_scale, method, model, permChec
                 cross_object, strata_ob = add_perm_strata(
                     cross_object, perm_strata_list)
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(
-                        num_perm), perm_strata = strata_ob, model=model, method=method)
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm=int(
+                        num_perm), perm_strata=strata_ob, model=model, method=method)
                 else:
                     perm_data_frame = scanone(
-                        cross_object, pheno_col="the_pheno", n_perm=num_perm, perm_strata = strata_ob, model=model, method=method)
+                        cross_object, pheno_col="the_pheno", n_perm=num_perm, perm_strata=strata_ob, model=model, method=method)
             else:
                 if do_control == "true" or cofactors != "":
-                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm = int(
+                    perm_data_frame = scanone(cross_object, pheno_col="the_pheno", addcovar=covars, n_perm=int(
                         num_perm), model=model, method=method)
                 else:
                     perm_data_frame = scanone(
diff --git a/wqflask/wqflask/marker_regression/run_mapping.py b/wqflask/wqflask/marker_regression/run_mapping.py
index 81e0a03f..32ccec48 100644
--- a/wqflask/wqflask/marker_regression/run_mapping.py
+++ b/wqflask/wqflask/marker_regression/run_mapping.py
@@ -67,7 +67,8 @@ class RunMapping:
         if 'genofile' in start_vars:
             if start_vars['genofile'] != "":
                 self.genofile_string = start_vars['genofile']
-                self.dataset.group.genofile = self.genofile_string.split(":")[0]
+                self.dataset.group.genofile = self.genofile_string.split(":")[
+                    0]
                 genofile_samplelist = get_genofile_samplelist(self.dataset)
 
         all_samples_ordered = self.dataset.group.all_samples_ordered()
diff --git a/wqflask/wqflask/model.py b/wqflask/wqflask/model.py
index 822900cc..a222b87c 100644
--- a/wqflask/wqflask/model.py
+++ b/wqflask/wqflask/model.py
@@ -36,7 +36,7 @@ class User(Base):
 
     # json detailing when they became a superuser, otherwise empty
     superuser = Column(Text)
-                       # if not superuser
+    # if not superuser
 
     logins = relationship("Login",
                           order_by="desc(Login.timestamp)",
@@ -47,7 +47,7 @@ class User(Base):
     user_collections = relationship("UserCollection",
                                     order_by="asc(UserCollection.name)",
                                     lazy='dynamic',
-                          )
+                                    )
 
     def display_num_collections(self):
         """
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index 61f3b202..b28c1b04 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -116,7 +116,7 @@ def add_group_to_resource():
             group_id = request.form['selected_group']
             resource_info = get_resource_info(resource_id)
             default_privileges = resource_info['default_mask']
-            return render_template("admin/set_group_privileges.html", resource_id=resource_id, group_id=group_id, default_privileges = default_privileges)
+            return render_template("admin/set_group_privileges.html", resource_id=resource_id, group_id=group_id, default_privileges=default_privileges)
         elif all(key in request.form for key in ('data_privilege', 'metadata_privilege', 'admin_privilege')):
             group_id = request.form['group_id']
             group_name = get_group_info(group_id)['name']
diff --git a/wqflask/wqflask/search_results.py b/wqflask/wqflask/search_results.py
index fc48959e..3cbda3dd 100644
--- a/wqflask/wqflask/search_results.py
+++ b/wqflask/wqflask/search_results.py
@@ -276,7 +276,7 @@ class SearchResultPage:
                                       search_operator,
                                       self.dataset,
                                       search_type['key']
-                                    )
+                                      )
             return the_search
         else:
             return None
diff --git a/wqflask/wqflask/snp_browser/snp_browser.py b/wqflask/wqflask/snp_browser/snp_browser.py
index 42fe339e..c4d0e135 100644
--- a/wqflask/wqflask/snp_browser/snp_browser.py
+++ b/wqflask/wqflask/snp_browser/snp_browser.py
@@ -28,10 +28,10 @@ class SnpBrowser:
 
             if self.limit_strains == "true":
                 self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(
-                    variant_type=self.variant_type, strains=self.chosen_strains, empty_columns = self.empty_columns)
+                    variant_type=self.variant_type, strains=self.chosen_strains, empty_columns=self.empty_columns)
             else:
                 self.header_fields, self.empty_field_count, self.header_data_names = get_header_list(
-                    variant_type=self.variant_type, strains=self.strain_lists, species = self.species_name, empty_columns = self.empty_columns)
+                    variant_type=self.variant_type, strains=self.strain_lists, species=self.species_name, empty_columns=self.empty_columns)
 
     def initialize_parameters(self, start_vars):
         if 'first_run' in start_vars:
diff --git a/wqflask/wqflask/user_login.py b/wqflask/wqflask/user_login.py
index 0d5f1f3e..ff77982f 100644
--- a/wqflask/wqflask/user_login.py
+++ b/wqflask/wqflask/user_login.py
@@ -65,7 +65,7 @@ def set_password(password):
         "salt": base64.b64encode(os.urandom(32)),
         "iterations": 100000,
         "keylength": 32,
-      "created_timestamp": timestamp()
+        "created_timestamp": timestamp()
     }
 
     assert len(password) >= 6, "Password shouldn't be shorter than 6 characters"
@@ -132,7 +132,7 @@ def send_email(toaddr, msg, fromaddr="no-reply@genenetwork.org"):
     logger.info("Successfully sent email to " + toaddr)
 
 
-def send_verification_email(user_details, template_name="email/user_verification.txt", key_prefix="verification_code", subject = "GeneNetwork e-mail verification"):
+def send_verification_email(user_details, template_name="email/user_verification.txt", key_prefix="verification_code", subject="GeneNetwork e-mail verification"):
     verification_code = str(uuid.uuid4())
     key = key_prefix + ":" + verification_code
 
@@ -147,7 +147,7 @@ def send_verification_email(user_details, template_name="email/user_verification
     return {"recipient": recipient, "subject": subject, "body": body}
 
 
-def send_invitation_email(user_email, temp_password, template_name="email/user_invitation.txt", subject= "You've been added to a GeneNetwork user group"):
+def send_invitation_email(user_email, temp_password, template_name="email/user_invitation.txt", subject="You've been added to a GeneNetwork user group"):
     recipient = user_email
     body = render_template(template_name, temp_password)
     send_email(recipient, subject, body)
diff --git a/wqflask/wqflask/user_manager.py b/wqflask/wqflask/user_manager.py
index fb26bfb1..cf84ea73 100644
--- a/wqflask/wqflask/user_manager.py
+++ b/wqflask/wqflask/user_manager.py
@@ -476,7 +476,7 @@ def set_password(password, user):
 
     user.password = json.dumps(pwfields.__dict__,
                                sort_keys=True,
-                                   )
+                               )
 
 
 class VerificationEmail:
@@ -677,7 +677,7 @@ def github_oauth2():
     user_details = get_user_by_unique_column("github_id", github_user["id"])
     if user_details == None:
         user_details = {
-            "user_id": str(uuid.uuid4()), "name": github_user["name"].encode("utf-8"), "github_id": github_user["id"], "user_url": github_user["html_url"].encode("utf-8")            , "login_type": "github"            , "organization": ""            , "active": 1            , "confirmed": 1
+            "user_id": str(uuid.uuid4()), "name": github_user["name"].encode("utf-8"), "github_id": github_user["id"], "user_url": github_user["html_url"].encode("utf-8"), "login_type": "github", "organization": "", "active": 1, "confirmed": 1
         }
         save_user(user_details, user_details["user_id"])
 
@@ -705,7 +705,7 @@ def orcid_oauth2():
             user_details = {
                 "user_id": str(uuid4()), "name": result_dict["name"], "orcid": result_dict["orcid"], "user_url": "%s/%s" % (
                     "/".join(ORCID_AUTH_URL.split("/")[:-2]),
-                    result_dict["orcid"]), "login_type": "orcid", "organization": "", "active": 1                , "confirmed": 1
+                    result_dict["orcid"]), "login_type": "orcid", "organization": "", "active": 1, "confirmed": 1
             }
             save_user(user_details, user_details["user_id"])
 
diff --git a/wqflask/wqflask/views.py b/wqflask/wqflask/views.py
index f75209ff..f9b8f310 100644
--- a/wqflask/wqflask/views.py
+++ b/wqflask/wqflask/views.py
@@ -141,7 +141,7 @@ def handle_bad_request(e):
     now = datetime.datetime.utcnow()
     time_str = now.strftime('%l:%M%p UTC %b %d, %Y')
     formatted_lines = [request.url
-                       + " (" + time_str + ")"]+traceback.format_exc().splitlines()
+                       + " (" + time_str + ")"] + traceback.format_exc().splitlines()
 
     # Handle random animations
     # Use a cookie to have one animation on refresh
-- 
cgit v1.2.3


From 7b8ffda6de6be67736074d707015ed22a55d1185 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 4 May 2021 22:17:56 +0300
Subject: tests: test_species: Add test cases for TestTheSpecies class

---
 wqflask/tests/unit/base/test_species.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 wqflask/tests/unit/base/test_species.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py
new file mode 100644
index 00000000..950909a1
--- /dev/null
+++ b/wqflask/tests/unit/base/test_species.py
@@ -0,0 +1,27 @@
+"""Tests wqflask/base/species.py"""
+
+import unittest
+from unittest import mock
+from base.species import TheSpecies
+
+
+class TestTheSpecies(unittest.TestCase):
+    """Tests for TheSpecies class"""
+    @mock.patch('base.species.Chromosomes')
+    def test_create_species_with_null_species_name(self, mock_chromosome):
+        """Test that TheSpecies is instantiated correctly when the
+species_name is provided."""
+        mock_chromosome.return_value = 1
+        test_species = TheSpecies(dataset="random_dataset", species_name="a")
+        self.assertEqual(test_species.name, "a")
+        self.assertEqual(test_species.chromosomes, 1)
+
+    @mock.patch('base.species.Chromosomes')
+    def test_create_species_with_species_name(self, mock_chromosome):
+        """Test that TheSpecies is instantiated correctly when the
+species_name is not provided."""
+        mock_chromosome.return_value = 1
+        test_species = TheSpecies(dataset="random_dataset")
+        self.assertEqual(test_species.dataset, "random_dataset")
+        self.assertEqual(test_species.chromosomes, 1)
+        mock_chromosome.assert_called_once_with(dataset="random_dataset")
-- 
cgit v1.2.3


From 31d447d5d70cf18a41c6e139a152fe4cfb864bb4 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 4 May 2021 22:24:02 +0300
Subject: tests: test_species: Test that IndChromosome instantiates correctly

---
 wqflask/tests/unit/base/test_species.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py
index 950909a1..42aa9092 100644
--- a/wqflask/tests/unit/base/test_species.py
+++ b/wqflask/tests/unit/base/test_species.py
@@ -3,6 +3,7 @@
 import unittest
 from unittest import mock
 from base.species import TheSpecies
+from base.species import IndChromosome
 
 
 class TestTheSpecies(unittest.TestCase):
@@ -25,3 +26,14 @@ species_name is not provided."""
         self.assertEqual(test_species.dataset, "random_dataset")
         self.assertEqual(test_species.chromosomes, 1)
         mock_chromosome.assert_called_once_with(dataset="random_dataset")
+
+
+class TestIndChromosome(unittest.TestCase):
+    """Tests for IndChromosome class"""
+
+    def test_create_ind_chromosome(self):
+        """Test that IndChromosome is instantiated correctly"""
+        test_ind_chromosome = IndChromosome(name="Test", length=10000000)
+        self.assertEqual(test_ind_chromosome.name, "Test")
+        self.assertEqual(test_ind_chromosome.length, 10000000)
+        self.assertEqual(test_ind_chromosome.mb_length, 10)
-- 
cgit v1.2.3


From b2b81942c6dda717ec8e7beeac61477f0e67a387 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 4 May 2021 23:27:00 +0300
Subject: templates: test_species: Add tests for instantiating Chromosomes

---
 wqflask/tests/unit/base/test_species.py | 77 +++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py
index 42aa9092..487bbd7f 100644
--- a/wqflask/tests/unit/base/test_species.py
+++ b/wqflask/tests/unit/base/test_species.py
@@ -4,6 +4,27 @@ import unittest
 from unittest import mock
 from base.species import TheSpecies
 from base.species import IndChromosome
+from base.species import Chromosomes
+from collections import OrderedDict
+from wqflask import app
+from dataclasses import dataclass
+
+
+@dataclass
+class MockChromosome:
+    OrderId: int
+    Name: str
+    Length: int
+
+
+@dataclass
+class MockGroup:
+    name: str
+
+
+@dataclass
+class MockDataset:
+    group: MockGroup
 
 
 class TestTheSpecies(unittest.TestCase):
@@ -37,3 +58,59 @@ class TestIndChromosome(unittest.TestCase):
         self.assertEqual(test_ind_chromosome.name, "Test")
         self.assertEqual(test_ind_chromosome.length, 10000000)
         self.assertEqual(test_ind_chromosome.mb_length, 10)
+
+
+class TestChromosomes(unittest.TestCase):
+    """Tests for Chromosomes class"""
+    maxDiff = None
+
+    def setUp(self):
+        self.app_context = app.app_context()
+        self.app_context.push()
+
+    def tearDown(self):
+        self.app_context.pop()
+
+    @mock.patch("base.species.g")
+    def test_create_chromosomes_with_no_species(self, mock_db):
+        """Test instantiating a chromosome without a species"""
+        mock_db.db.execute.return_value.fetchall.return_value = [
+            MockChromosome(1, "X", 100),
+            MockChromosome(2, "Y", 1000),
+            MockChromosome(3, "Z", 10000),
+        ]
+        mock_dataset = MockDataset(MockGroup("Random"))
+        test_chromosomes = Chromosomes(dataset=mock_dataset)
+        mock_db.db.execute.assert_called_with(
+            "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
+            "FROM Chr_Length, InbredSet WHERE "
+            "Chr_Length.SpeciesId = InbredSet.SpeciesId AND "
+            "InbredSet.Name = 'Random' ORDER BY OrderId"
+        )
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
+        self.assertEqual(test_chromosomes.dataset, mock_dataset)
+
+    @mock.patch("base.species.g")
+    def test_create_chromosomes_with_species(self, mock_db):
+        """Test instantiating a chromosome with a species"""
+        mock_db.db.execute.return_value.fetchall.return_value = [
+            MockChromosome(1, "X", 100),
+            MockChromosome(2, "Y", 1000),
+            MockChromosome(3, "Z", 10000),
+        ]
+        mock_dataset = MockDataset(MockGroup("Random"))
+        test_chromosomes = Chromosomes(dataset=mock_dataset,
+                                       species="testSpecies")
+        mock_db.db.execute.assert_called_with(
+            "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
+            "FROM Chr_Length, Species WHERE "
+            "Chr_Length.SpeciesId = Species.SpeciesId AND "
+            "Species.Name = 'Testspecies' ORDER BY OrderId"
+        )
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
-- 
cgit v1.2.3


From 3f0d45848280b77a35a569682e93291204769cc8 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 4 May 2021 23:56:32 +0300
Subject: tests: test_species: Update failing tests

---
 wqflask/tests/unit/base/test_species.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/base/test_species.py b/wqflask/tests/unit/base/test_species.py
index 487bbd7f..9b5c023c 100644
--- a/wqflask/tests/unit/base/test_species.py
+++ b/wqflask/tests/unit/base/test_species.py
@@ -81,17 +81,17 @@ class TestChromosomes(unittest.TestCase):
         ]
         mock_dataset = MockDataset(MockGroup("Random"))
         test_chromosomes = Chromosomes(dataset=mock_dataset)
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
+        self.assertEqual(test_chromosomes.dataset, mock_dataset)
         mock_db.db.execute.assert_called_with(
             "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
             "FROM Chr_Length, InbredSet WHERE "
             "Chr_Length.SpeciesId = InbredSet.SpeciesId AND "
             "InbredSet.Name = 'Random' ORDER BY OrderId"
         )
-        self.assertEqual(
-            list(test_chromosomes.chromosomes.keys()),
-            [1, 2, 3]
-        )
-        self.assertEqual(test_chromosomes.dataset, mock_dataset)
 
     @mock.patch("base.species.g")
     def test_create_chromosomes_with_species(self, mock_db):
@@ -104,13 +104,13 @@ class TestChromosomes(unittest.TestCase):
         mock_dataset = MockDataset(MockGroup("Random"))
         test_chromosomes = Chromosomes(dataset=mock_dataset,
                                        species="testSpecies")
+        self.assertEqual(
+            list(test_chromosomes.chromosomes.keys()),
+            [1, 2, 3]
+        )
         mock_db.db.execute.assert_called_with(
             "SELECT Chr_Length.Name, Chr_Length.OrderId, Length "
             "FROM Chr_Length, Species WHERE "
             "Chr_Length.SpeciesId = Species.SpeciesId AND "
             "Species.Name = 'Testspecies' ORDER BY OrderId"
         )
-        self.assertEqual(
-            list(test_chromosomes.chromosomes.keys()),
-            [1, 2, 3]
-        )
-- 
cgit v1.2.3


From 074d724bffff4a579fe0c862ce817651cfe59910 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 8 May 2021 13:55:47 +0300
Subject: tests: test_gen_menu: Update failing tests

Update tests to use (and mock) the injected MySQL connection object.
---
 wqflask/tests/unit/wqflask/api/test_gen_menu.py | 402 +++++++++++++-----------
 1 file changed, 216 insertions(+), 186 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index fd0fe52e..d0cd647a 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -73,209 +73,239 @@ class TestGenMenu(unittest.TestCase):
     def tearDown(self):
         self.app_context.pop()
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_species(self, db_mock):
+    def test_get_species(self):
         """Test that assertion is raised when dataset and dataset_name
         are defined"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('human', 'Human'),
-            ('mouse', 'Mouse'))
-        self.assertEqual(get_species(),
-                         [['human', 'Human'], ['mouse', 'Mouse']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT Name, MenuName FROM Species ORDER BY OrderId"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_get_groups(self, db_mock):
-        """Test that species groups are grouped correctly"""
-        db_mock.db.execute.return_value.fetchall.side_effect = [
-            # Mouse
-            (('BXD', 'BXD', None),
-             ('HLC', 'Liver: Normal Gene Expression with Genotypes (Merck)',
-              'Test')),
-            # Human
-            (('H_T1', "H_T", "DescriptionA"),
-             ('H_T2', "H_T'", None))
-        ]
-
-        self.assertEqual(get_groups([["human", "Human"], ["mouse", "Mouse"]]),
-                         self.test_group)
-
-        for name in ["mouse", "human"]:
-            db_mock.db.execute.assert_any_call(
-                ("SELECT InbredSet.Name, InbredSet.FullName, " +
-                 "IFNULL(InbredSet.Family, 'None') "
-                 + "FROM InbredSet, Species WHERE Species.Name "
-                 + "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by "
-                 + "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, "
-                 + "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, "
-                 + "InbredSet.FullName) ASC, InbredSet.FullName ASC, "
-                 + "InbredSet.MenuOrderId ASC").format(name)
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = (
+                ('human', 'Human'),
+                ('mouse', 'Mouse'))
+            self.assertEqual(get_species(db_mock),
+                             [['human', 'Human'], ['mouse', 'Mouse']])
+            cursor.execute.assert_called_once_with(
+                "SELECT Name, MenuName FROM Species ORDER BY OrderId"
             )
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_called_with_correct_query(self, db_mock):
+    def test_get_groups(self):
+        """Test that species groups are grouped correctly"""
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.side_effect = [
+                # Mouse
+                (('BXD', 'BXD', None),
+                 ('HLC', ('Liver: Normal Gene Expression '
+                          'with Genotypes (Merck)'),
+                  'Test')),
+                # Human
+                (('H_T1', "H_T", "DescriptionA"),
+                 ('H_T2', "H_T'", None))
+            ]
+            self.assertEqual(get_groups([["human", "Human"],
+                                         ["mouse", "Mouse"]],
+                                        db_mock),
+                             self.test_group)
+
+            for name in ["mouse", "human"]:
+                cursor.execute.assert_any_call(
+                    ("SELECT InbredSet.Name, InbredSet.FullName, "
+                     "IFNULL(InbredSet.Family, 'None') "
+                     "FROM InbredSet, Species WHERE Species.Name "
+                     "= '{}' AND InbredSet.SpeciesId = Species.Id GROUP by "
+                     "InbredSet.Name ORDER BY IFNULL(InbredSet.FamilyOrder, "
+                     "InbredSet.FullName) ASC, IFNULL(InbredSet.Family, "
+                     "InbredSet.FullName) ASC, InbredSet.FullName ASC, "
+                     "InbredSet.MenuOrderId ASC").format(name)
+                )
+
+    def test_phenotypes_exist_called_with_correct_query(self):
         """Test that phenotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        phenotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM PublishFreeze "
-            "WHERE PublishFreeze.Name = 'testPublish'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_falsy_values(self, db_mock):
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchone.return_value = None
+            phenotypes_exist("test", db_mock)
+            cursor.execute.assert_called_with(
+                "SELECT Name FROM PublishFreeze "
+                "WHERE PublishFreeze.Name = 'testPublish'"
+            )
+
+    def test_phenotypes_exist_with_falsy_values(self):
         """Test that phenotype check returns correctly when given
         a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_phenotypes_exist_with_truthy_value(self, db_mock):
-        """Test that phenotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_called_with_correct_query(self, db_mock):
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            for x in [None, False, (), [], ""]:
+                cursor.fetchone.return_value = x
+            self.assertFalse(phenotypes_exist("test", db_mock))
+
+    def test_phenotypes_exist_with_truthy_value(self):
+        """Test that phenotype check returns correctly when given Truthy"""
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as conn:
+            with conn.cursor() as cursor:
+                for x in ["x", ("result"), ["result"], [1]]:
+                    cursor.fetchone.return_value = (x)
+                self.assertTrue(phenotypes_exist("test", db_mock))
+
+    def test_genotypes_exist_called_with_correct_query(self):
         """Test that genotypes_exist is called with the correct query"""
-        db_mock.db.execute.return_value.fetchone.return_value = None
-        genotypes_exist("test")
-        db_mock.db.execute.assert_called_with(
-            "SELECT Name FROM GenoFreeze WHERE GenoFreeze.Name = 'testGeno'"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_falsy_values(self, db_mock):
-        """Test that genotype check returns correctly when given
-        a None value"""
-        for x in [None, False, (), [], ""]:
-            db_mock.db.execute.return_value.fetchone.return_value = x
-            self.assertFalse(genotypes_exist("test"))
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchone.return_value = None
+            genotypes_exist("test", db_mock)
+            cursor.execute.assert_called_with(
+                "SELECT Name FROM GenoFreeze WHERE "
+                "GenoFreeze.Name = 'testGeno'"
+            )
+
+    def test_genotypes_exist_with_falsy_values(self):
+        """Test that genotype check returns correctly when given a None value
+
+        """
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            for x in [None, False, (), [], ""]:
+                cursor.fetchone.return_value = x
+                self.assertFalse(genotypes_exist("test", db_mock))
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_genotypes_exist_with_truthy_value(self, db_mock):
+    def test_genotypes_exist_with_truthy_value(self):
         """Test that genotype check returns correctly when given Truthy """
-        for x in ["x", ("result"), ["result"], [1]]:
-            db_mock.db.execute.return_value.fetchone.return_value = (x)
-            self.assertTrue(phenotypes_exist("test"))
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            for x in ["x", ("result"), ["result"], [1]]:
+                cursor.fetchone.return_value = (x)
+                self.assertTrue(phenotypes_exist("test", db_mock))
 
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes(self, db_mock):
+    def test_build_datasets_with_type_phenotypes(self):
         """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (602, "BXDPublish", "BXD Published Phenotypes"),
-        )
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [['602', "BXDPublish", "BXD Published Phenotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, "
-            + "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, "
-            + "InbredSet WHERE InbredSet.Name = 'BXD' AND "
-            + "PublishFreeze.InbredSetId = InbredSet.Id AND "
-            + "InfoFiles.InfoPageName = PublishFreeze.Name "
-            + "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [['602', "BXDPublish", "Mouse Phenome Database"]])
-
-        db_mock.db.execute.return_value.fetchall.return_value = ()
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            "BXDPublish", "Mouse Phenome Database"
-        )
-        self.assertEqual(build_datasets("Mouse", "MDP", "Phenotypes"),
-                         [["None", "BXDPublish", "Mouse Phenome Database"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_phenotypes_and_no_results(self, db_mock):
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = (
+                (602, "BXDPublish", "BXD Published Phenotypes"),
+            )
+            self.assertEqual(build_datasets("Mouse", "BXD",
+                                            "Phenotypes", db_mock),
+                             [['602', "BXDPublish",
+                               "BXD Published Phenotypes"]])
+            cursor.execute.assert_called_with(
+                "SELECT InfoFiles.GN_AccesionId, PublishFreeze.Name, "
+                + "PublishFreeze.FullName FROM InfoFiles, PublishFreeze, "
+                + "InbredSet WHERE InbredSet.Name = 'BXD' AND "
+                + "PublishFreeze.InbredSetId = InbredSet.Id AND "
+                + "InfoFiles.InfoPageName = PublishFreeze.Name "
+                + "ORDER BY PublishFreeze.CreateTime ASC"
+            )
+            self.assertEqual(build_datasets("Mouse", "MDP",
+                                            "Phenotypes", db_mock),
+                             [['602', "BXDPublish",
+                               "Mouse Phenome Database"]])
+
+            cursor.fetchall.return_value = ()
+            cursor.fetchone.return_value = (
+                "BXDPublish", "Mouse Phenome Database"
+            )
+            self.assertEqual(build_datasets("Mouse", "MDP",
+                                            "Phenotypes", db_mock),
+                             [["None", "BXDPublish",
+                               "Mouse Phenome Database"]])
+
+    def test_build_datasets_with_type_phenotypes_and_no_results(self):
         """Test that correct dataset is returned for a phenotype type with no
         results
 
         """
-        db_mock.db.execute.return_value.fetchall.return_value = None
-        db_mock.db.execute.return_value.fetchone.return_value = (121,
-                                                                 "text value")
-        self.assertEqual(build_datasets("Mouse", "BXD", "Phenotypes"),
-                         [["None", "121", "text value"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT PublishFreeze.Name, PublishFreeze.FullName "
-            "FROM PublishFreeze, InbredSet "
-            "WHERE InbredSet.Name = 'BXD' AND "
-            "PublishFreeze.InbredSetId = InbredSet.Id "
-            "ORDER BY PublishFreeze.CreateTime ASC"
-        )
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_genotypes(self, db_mock):
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = None
+            cursor.fetchone.return_value = (121,
+                                            "text value")
+            self.assertEqual(build_datasets("Mouse", "BXD",
+                                            "Phenotypes", db_mock),
+                             [["None", "121",
+                               "text value"]])
+            cursor.execute.assert_called_with(
+                "SELECT PublishFreeze.Name, PublishFreeze.FullName "
+                "FROM PublishFreeze, InbredSet "
+                "WHERE InbredSet.Name = 'BXD' AND "
+                "PublishFreeze.InbredSetId = InbredSet.Id "
+                "ORDER BY PublishFreeze.CreateTime ASC"
+            )
+
+    def test_build_datasets_with_type_genotypes(self):
         """Test that correct dataset is returned for a phenotype type"""
-        db_mock.db.execute.return_value.fetchone.return_value = (
-            635, "HLCPublish", "HLC Published Genotypes"
-        )
-
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["635", "HLCGeno", "HLC Genotypes"]])
-        db_mock.db.execute.assert_called_with(
-            "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
-            "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
-            "GenoFreeze.InbredSetId = InbredSet.Id AND "
-            "InfoFiles.InfoPageName = GenoFreeze.ShortName "
-            + "ORDER BY GenoFreeze.CreateTime DESC"
-        )
-        db_mock.db.execute.return_value.fetchone.return_value = ()
-        self.assertEqual(build_datasets("Mouse", "HLC", "Genotypes"),
-                         [["None", "HLCGeno", "HLC Genotypes"]])
-
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_datasets_with_type_mrna(self, db_mock):
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchone.return_value = (
+                635, "HLCPublish", "HLC Published Genotypes"
+            )
+            self.assertEqual(build_datasets("Mouse", "HLC",
+                                            "Genotypes", db_mock),
+                             [["635", "HLCGeno", "HLC Genotypes"]])
+            cursor.execute.assert_called_with(
+                "SELECT InfoFiles.GN_AccesionId FROM InfoFiles, "
+                "GenoFreeze, InbredSet WHERE InbredSet.Name = 'HLC' AND "
+                "GenoFreeze.InbredSetId = InbredSet.Id AND "
+                "InfoFiles.InfoPageName = GenoFreeze.ShortName "
+                "ORDER BY GenoFreeze.CreateTime DESC"
+            )
+            cursor.fetchone.return_value = ()
+            self.assertEqual(build_datasets("Mouse", "HLC",
+                                            "Genotypes", db_mock),
+                             [["None", "HLCGeno", "HLC Genotypes"]])
+
+    def test_build_datasets_with_type_mrna(self):
         """Test that correct dataset is returned for a mRNA
         expression/ Probeset"""
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            (112, "HC_M2_0606_P",
-             "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
-        self.assertEqual(build_datasets("Mouse", "HLC", "mRNA"), [[
-            "112", 'HC_M2_0606_P', "Hippocampus Consortium M430v2 (Jun06) PDNN"
-        ]])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
-            + "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
-            + "ProbeFreeze, InbredSet, Tissue, Species WHERE "
-            + "Species.Name = 'Mouse' AND Species.Id = "
-            + "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND "
-            + "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND "
-            + "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = "
-            + "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND "
-            + "ProbeSetFreeze.public > 0 "
-            + "ORDER BY -ProbeSetFreeze.OrderList DESC, ProbeSetFreeze.CreateTime DESC")
+        db_mock = mock.MagicMock()
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = (
+                (112, "HC_M2_0606_P",
+                 "Hippocampus Consortium M430v2 (Jun06) PDNN"), )
+            self.assertEqual(build_datasets("Mouse",
+                                            "HLC", "mRNA", db_mock),
+                             [["112", 'HC_M2_0606_P',
+                               "Hippocampus Consortium M430v2 (Jun06) PDNN"
+                               ]])
+            cursor.execute.assert_called_once_with(
+                "SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, "
+                "ProbeSetFreeze.FullName FROM ProbeSetFreeze, "
+                "ProbeFreeze, InbredSet, Tissue, Species WHERE "
+                "Species.Name = 'Mouse' AND Species.Id = "
+                "InbredSet.SpeciesId AND InbredSet.Name = 'HLC' AND "
+                "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id AND "
+                "Tissue.Name = 'mRNA' AND ProbeFreeze.TissueId = "
+                "Tissue.Id AND ProbeFreeze.InbredSetId = InbredSet.Id AND "
+                "ProbeSetFreeze.public > 0 "
+                "ORDER BY -ProbeSetFreeze.OrderList DESC, "
+                "ProbeSetFreeze.CreateTime DESC")
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
-    @mock.patch('wqflask.api.gen_menu.g')
-    def test_build_types(self, db_mock, datasets_mock):
+    def test_build_types(self, datasets_mock):
         """Test that correct tissue metadata is returned"""
+        db_mock = mock.MagicMock()
         datasets_mock.return_value = [
             ["112", 'HC_M2_0606_P',
                 "Hippocampus Consortium M430v2 (Jun06) PDNN"]
         ]
-        db_mock.db.execute.return_value.fetchall.return_value = (
-            ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
-        )
-        self.assertEqual(build_types('mouse', 'random group'),
-                         [['M', 'M', 'Molecular Traits'],
-                          ['H', 'H', 'Molecular Traits'],
-                          ['R', 'R', 'Molecular Traits']])
-        db_mock.db.execute.assert_called_once_with(
-            "SELECT DISTINCT Tissue.Name "
-            + "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, "
-            + "Tissue, Species WHERE Species.Name = 'mouse' "
-            + "AND Species.Id = InbredSet.SpeciesId AND "
-            + "InbredSet.Name = 'random group' AND "
-            + "ProbeFreeze.TissueId = Tissue.Id AND "
-            + "ProbeFreeze.InbredSetId = InbredSet.Id AND "
-            + "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
-            + "ORDER BY Tissue.Name"
-        )
+        with db_mock.cursor() as cursor:
+            cursor.fetchall.return_value = (
+                ('Mouse Tissue'), ('Human Tissue'), ('Rat Tissue')
+            )
+            self.assertEqual(build_types('mouse', 'random group', db_mock),
+                             [['M', 'M', 'Molecular Traits'],
+                              ['H', 'H', 'Molecular Traits'],
+                              ['R', 'R', 'Molecular Traits']])
+            cursor.execute.assert_called_once_with(
+                "SELECT DISTINCT Tissue.Name "
+                "FROM ProbeFreeze, ProbeSetFreeze, InbredSet, "
+                "Tissue, Species WHERE Species.Name = 'mouse' "
+                "AND Species.Id = InbredSet.SpeciesId AND "
+                "InbredSet.Name = 'random group' AND "
+                "ProbeFreeze.TissueId = Tissue.Id AND "
+                "ProbeFreeze.InbredSetId = InbredSet.Id AND "
+                "ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id "
+                "ORDER BY Tissue.Name"
+            )
 
     @mock.patch('wqflask.api.gen_menu.build_types')
     @mock.patch('wqflask.api.gen_menu.genotypes_exist')
@@ -297,7 +327,9 @@ class TestGenMenu(unittest.TestCase):
         build_types_mock.return_value = [
             ['M', 'M', 'Molecular Trait Datasets']
         ]
-        self.assertEqual(get_types(self.test_group), expected_result)
+        self.assertEqual(get_types(self.test_group,
+                                   mock.MagicMock()),
+                         expected_result)
 
     @mock.patch('wqflask.api.gen_menu.build_types')
     @mock.patch('wqflask.api.gen_menu.genotypes_exist')
@@ -315,10 +347,8 @@ class TestGenMenu(unittest.TestCase):
         genotypes_exist_mock.return_value = False
 
         build_types_mock.return_value = []
-        self.assertEqual(get_types(self.test_group), {
-            'mouse': {},
-            'human': {}
-        })
+        self.assertEqual(get_types(self.test_group, mock.MagicMock()),
+                         {'mouse': {}, 'human': {}})
 
     @mock.patch('wqflask.api.gen_menu.build_types')
     @mock.patch('wqflask.api.gen_menu.genotypes_exist')
@@ -345,7 +375,7 @@ class TestGenMenu(unittest.TestCase):
             'human': {
                 'HLC': [['M', 'M', 'Molecular Trait Datasets']],
                 'BXD': [['M', 'M', 'Molecular Trait Datasets']]}}
-        self.assertEqual(get_types(self.test_group),
+        self.assertEqual(get_types(self.test_group, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
@@ -367,7 +397,7 @@ class TestGenMenu(unittest.TestCase):
                       'BXD': {'Genotypes': 'Test',
                               'M': 'Test',
                               'Phenotypes': 'Test'}}}
-        self.assertEqual(get_datasets(self.test_type),
+        self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.build_datasets')
@@ -381,7 +411,7 @@ class TestGenMenu(unittest.TestCase):
                 'H_T1': {}},
             'human': {'HLC': {},
                       'BXD': {}}}
-        self.assertEqual(get_datasets(self.test_type),
+        self.assertEqual(get_datasets(self.test_type, mock.MagicMock()),
                          expected_result)
 
     @mock.patch('wqflask.api.gen_menu.get_datasets')
@@ -411,4 +441,4 @@ class TestGenMenu(unittest.TestCase):
             'groups': ['groupA', 'groupB', 'groupC', 'groupD'],
             'species': ['speciesA', 'speciesB', 'speciesC', 'speciesD']}
 
-        self.assertEqual(gen_dropdown_json(), expected_result)
+        self.assertEqual(gen_dropdown_json(mock.MagicMock()), expected_result)
-- 
cgit v1.2.3


From 1afece5464520700901cbde19599ac45222ea58f Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 8 May 2021 16:11:20 +0300
Subject: tests: test_gen_menu: Remove app_context initialisation

This is no longer required since the global object "Flask.g.db" is no
longer coupled to the gen_menu module.
---
 wqflask/tests/unit/wqflask/api/test_gen_menu.py | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index d0cd647a..743b3bde 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -2,7 +2,6 @@
 import unittest
 from unittest import mock
 
-from wqflask import app
 from wqflask.api.gen_menu import gen_dropdown_json
 from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
@@ -18,8 +17,6 @@ class TestGenMenu(unittest.TestCase):
     """Tests for the gen_menu module"""
 
     def setUp(self):
-        self.app_context = app.app_context()
-        self.app_context.push()
         self.test_group = {
             'mouse': [
                 ['H_T1',
@@ -70,9 +67,6 @@ class TestGenMenu(unittest.TestCase):
             }
         }
 
-    def tearDown(self):
-        self.app_context.pop()
-
     def test_get_species(self):
         """Test that assertion is raised when dataset and dataset_name
         are defined"""
-- 
cgit v1.2.3


From 579ec56e488db19e7cd489b906ae6da7cd453239 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Sat, 22 May 2021 22:31:51 +0000
Subject: Rewrote test_rqtl_mapping.py, though haven't done tests for all
 functions yet

---
 .../wqflask/marker_regression/test_rqtl_mapping.py | 76 ++++++++++++----------
 1 file changed, 40 insertions(+), 36 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 91d2c587..5c679c05 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -1,42 +1,46 @@
 import unittest
 from unittest import mock
-from wqflask import app
-from wqflask.marker_regression.rqtl_mapping import get_trait_data_type
-from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_phenotype
-from wqflask.marker_regression.rqtl_mapping import sanitize_rqtl_names
+from wqflask.marker_regression.rqtl_mapping import run_rqtl
 
+class AttributeSetter:
+    def __init__(self, obj):
+        for key, val in obj.items():
+            setattr(self, key, val)
+
+class MockGroup(AttributeSetter):
+    def get_samplelist(self):
+        return None
 
 class TestRqtlMapping(unittest.TestCase):
 
-    def setUp(self):
-        self.app_context = app.app_context()
-        self.app_context.push()
-
-    def tearDown(self):
-        self.app_context.pop()
-
-    @mock.patch("wqflask.marker_regression.rqtl_mapping.g")
-    @mock.patch("wqflask.marker_regression.rqtl_mapping.logger")
-    def test_get_trait_data(self, mock_logger, mock_db):
-        """test for getting trait data_type return True"""
-        query_value = """SELECT value FROM TraitMetadata WHERE type='trait_data_type'"""
-        mock_db.db.execute.return_value.fetchone.return_value = [
-            """{"type":"trait_data_type","name":"T1","traid_id":"fer434f"}"""]
-        results = get_trait_data_type("traid_id")
-        mock_db.db.execute.assert_called_with(query_value)
-        self.assertEqual(results, "fer434f")
-
-    def test_sanitize_rqtl_phenotype(self):
-        """test for sanitizing rqtl phenotype"""
-        vals = ['f', "x", "r", "x", "x"]
-        results = sanitize_rqtl_phenotype(vals)
-        expected_phenotype_string = 'c(f,NA,r,NA,NA)'
-
-        self.assertEqual(results, expected_phenotype_string)
-
-    def test_sanitize_rqtl_names(self):
-        """test for sanitzing rqtl names"""
-        vals = ['f', "x", "r", "x", "x"]
-        expected_sanitized_name = "c('f',NA,'r',NA,NA)"
-        results = sanitize_rqtl_names(vals)
-        self.assertEqual(expected_sanitized_name, results)
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.process_rqtl_results")
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.process_perm_results")
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post")
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.locate")
+    @mock.patch("wqflask.marker_regression.gemma_mapping.write_phenotype_file")
+    def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post, mock_process_perm, mock_process_rqtl):
+        """Test for run_rqtl with permutations > 0"""
+        dataset_group = MockGroup(
+            {"name": "GP1", "genofile": "file_geno"})
+
+        dataset = AttributeSetter({"group": dataset_group})
+
+        mock_write_pheno_file.return_value = "pheno_filename"
+        mock_locate.return_value = "geno_filename"
+
+        mock_post.return_value = "output_filename"
+
+        mock_process_perm.return_value = [[], 3, 4]
+        mock_process_rqtl.return_value = []
+
+        results = run_rqtl(trait_name="the_trait", vals=[], samples=[],
+        dataset=dataset, mapping_scale="cM", model="normal", method="hk",
+        num_perm=5, perm_strata_list=[], do_control="false", control_marker="",
+        manhattan_plot=True, cofactors="")
+
+        mock_write_pheno_file.assert_called_once()
+        mock_locate.assert_called_once()
+        mock_post.assert_called_once()
+        mock_process_perm.assert_called_once()
+        mock_process_rqtl.assert_called_once()
+        self.assertEqual(results, ([], 3, 4, []))
\ No newline at end of file
-- 
cgit v1.2.3


From 1ec1219eae75f1cf9a1b20ea479ea6e2934eaa68 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Sat, 22 May 2021 22:43:58 +0000
Subject: Fixed a couple broken tests

---
 wqflask/tests/unit/wqflask/api/test_mapping.py                    | 2 +-
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_mapping.py b/wqflask/tests/unit/wqflask/api/test_mapping.py
index b094294a..159c982b 100644
--- a/wqflask/tests/unit/wqflask/api/test_mapping.py
+++ b/wqflask/tests/unit/wqflask/api/test_mapping.py
@@ -58,7 +58,7 @@ class TestMapping(unittest.TestCase):
 
         self.assertEqual(results_2, expected_results)
 
-    @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl_geno")
+    @mock.patch("wqflask.api.mapping.rqtl_mapping.run_rqtl")
     @mock.patch("wqflask.api.mapping.gemma_mapping.run_gemma")
     @mock.patch("wqflask.api.mapping.initialize_parameters")
     @mock.patch("wqflask.api.mapping.retrieve_sample_data")
diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 5c679c05..626869b8 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -17,7 +17,7 @@ class TestRqtlMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.rqtl_mapping.process_perm_results")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.locate")
-    @mock.patch("wqflask.marker_regression.gemma_mapping.write_phenotype_file")
+    @mock.patch("wqflask.marker_regression.rqtl_mapping.write_phenotype_file")
     def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post, mock_process_perm, mock_process_rqtl):
         """Test for run_rqtl with permutations > 0"""
         dataset_group = MockGroup(
-- 
cgit v1.2.3


From cf9f0bef4454f97270bcacd16080f9d7f6bbb5e6 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Sat, 22 May 2021 22:51:19 +0000
Subject: Fixed the mocked return_value for requests.post to fix broken test

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 626869b8..6853c021 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -28,7 +28,8 @@ class TestRqtlMapping(unittest.TestCase):
         mock_write_pheno_file.return_value = "pheno_filename"
         mock_locate.return_value = "geno_filename"
 
-        mock_post.return_value = "output_filename"
+        mock_post.return_value = {"output_file": "output_filename",
+                                  "rqtl_cmd": "the_command"}
 
         mock_process_perm.return_value = [[], 3, 4]
         mock_process_rqtl.return_value = []
-- 
cgit v1.2.3


From 919a2ee38412270cd5baf1e490b2f733f81cacec Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Thu, 13 May 2021 12:49:31 +0300
Subject: tests: test_gen_menu: Remove get_species

---
 wqflask/tests/unit/wqflask/api/test_gen_menu.py | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_gen_menu.py b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
index 743b3bde..7e477da2 100644
--- a/wqflask/tests/unit/wqflask/api/test_gen_menu.py
+++ b/wqflask/tests/unit/wqflask/api/test_gen_menu.py
@@ -3,7 +3,6 @@ import unittest
 from unittest import mock
 
 from wqflask.api.gen_menu import gen_dropdown_json
-from wqflask.api.gen_menu import get_species
 from wqflask.api.gen_menu import get_groups
 from wqflask.api.gen_menu import get_types
 from wqflask.api.gen_menu import get_datasets
@@ -67,20 +66,6 @@ class TestGenMenu(unittest.TestCase):
             }
         }
 
-    def test_get_species(self):
-        """Test that assertion is raised when dataset and dataset_name
-        are defined"""
-        db_mock = mock.MagicMock()
-        with db_mock.cursor() as cursor:
-            cursor.fetchall.return_value = (
-                ('human', 'Human'),
-                ('mouse', 'Mouse'))
-            self.assertEqual(get_species(db_mock),
-                             [['human', 'Human'], ['mouse', 'Mouse']])
-            cursor.execute.assert_called_once_with(
-                "SELECT Name, MenuName FROM Species ORDER BY OrderId"
-            )
-
     def test_get_groups(self):
         """Test that species groups are grouped correctly"""
         db_mock = mock.MagicMock()
@@ -411,7 +396,7 @@ class TestGenMenu(unittest.TestCase):
     @mock.patch('wqflask.api.gen_menu.get_datasets')
     @mock.patch('wqflask.api.gen_menu.get_types')
     @mock.patch('wqflask.api.gen_menu.get_groups')
-    @mock.patch('wqflask.api.gen_menu.get_species')
+    @mock.patch('wqflask.api.gen_menu.get_all_species')
     def test_gen_dropdown_json(self,
                                species_mock,
                                groups_mock,
-- 
cgit v1.2.3


From 2c2e1dc3d4be635dbf73aab380e22acca6a2014b Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:18:36 +0000
Subject: Improved test_rqtl_mapping.py with Bonface's recommendation of uses
 dataclasses

---
 .../wqflask/marker_regression/test_rqtl_mapping.py | 23 ++++++++++------------
 1 file changed, 10 insertions(+), 13 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 6853c021..bd97b2d2 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -2,17 +2,17 @@ import unittest
 from unittest import mock
 from wqflask.marker_regression.rqtl_mapping import run_rqtl
 
-class AttributeSetter:
-    def __init__(self, obj):
-        for key, val in obj.items():
-            setattr(self, key, val)
+@dataclass
+class MockGroup:
+    name: str,
+    genofile: str
 
-class MockGroup(AttributeSetter):
-    def get_samplelist(self):
-        return None
+@dataclass
+class MockDataset:
+    group: MockGroup
 
 class TestRqtlMapping(unittest.TestCase):
-
+    """Tests for functions in rqtl_mapping.py"""
     @mock.patch("wqflask.marker_regression.rqtl_mapping.process_rqtl_results")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.process_perm_results")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post")
@@ -22,15 +22,12 @@ class TestRqtlMapping(unittest.TestCase):
         """Test for run_rqtl with permutations > 0"""
         dataset_group = MockGroup(
             {"name": "GP1", "genofile": "file_geno"})
-
-        dataset = AttributeSetter({"group": dataset_group})
+        dataset = MockDataset(dataset_group)
 
         mock_write_pheno_file.return_value = "pheno_filename"
         mock_locate.return_value = "geno_filename"
-
         mock_post.return_value = {"output_file": "output_filename",
                                   "rqtl_cmd": "the_command"}
-
         mock_process_perm.return_value = [[], 3, 4]
         mock_process_rqtl.return_value = []
 
@@ -44,4 +41,4 @@ class TestRqtlMapping(unittest.TestCase):
         mock_post.assert_called_once()
         mock_process_perm.assert_called_once()
         mock_process_rqtl.assert_called_once()
-        self.assertEqual(results, ([], 3, 4, []))
\ No newline at end of file
+        self.assertEqual(results, ([], 3, 4, []))
-- 
cgit v1.2.3


From 37941d2724aaf22c1aeca18a77e4c17248c5b7bc Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:27:26 +0000
Subject: Updated test_run_mapping.py to account for attribute keys being
 checked as lowercase, though not sure if this will fully fix the test

---
 .../unit/wqflask/marker_regression/test_run_mapping.py     | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 78cd3be9..c220a072 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -229,20 +229,20 @@ class TestRunMapping(unittest.TestCase):
         used_samples = ["S1", "S2"]
         sample_list = AttributeSetter({"sample_attribute_values": {
             "S1": {
-                "C1": "c1_value",
-                "C2": "c2_value",
-                "W1": "w1_value"
+                "c1": "c1_value",
+                "c2": "c2_value",
+                "w1": "w1_value"
 
             },
             "S2": {
-                "W1": "w2_value",
-                "W2": "w2_value"
+                "w1": "w2_value",
+                "w2": "w2_value"
 
             },
             "S3": {
 
-                "C1": "c1_value",
-                "C2": "c2_value"
+                "c1": "c1_value",
+                "c2": "c2_value"
 
             },
 
-- 
cgit v1.2.3


From 09768ed9c255cdd10561eeba28bf3752747bf378 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:29:57 +0000
Subject: Removed parts of test_rqtl_mapping.py referring to
 process_perm_results and process_rqtl_results since that functionality was
 moved to GN3

---
 .../tests/unit/wqflask/marker_regression/test_rqtl_mapping.py    | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index bd97b2d2..00a05d2d 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -13,12 +13,10 @@ class MockDataset:
 
 class TestRqtlMapping(unittest.TestCase):
     """Tests for functions in rqtl_mapping.py"""
-    @mock.patch("wqflask.marker_regression.rqtl_mapping.process_rqtl_results")
-    @mock.patch("wqflask.marker_regression.rqtl_mapping.process_perm_results")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.requests.post")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.locate")
     @mock.patch("wqflask.marker_regression.rqtl_mapping.write_phenotype_file")
-    def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post, mock_process_perm, mock_process_rqtl):
+    def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post):
         """Test for run_rqtl with permutations > 0"""
         dataset_group = MockGroup(
             {"name": "GP1", "genofile": "file_geno"})
@@ -28,8 +26,6 @@ class TestRqtlMapping(unittest.TestCase):
         mock_locate.return_value = "geno_filename"
         mock_post.return_value = {"output_file": "output_filename",
                                   "rqtl_cmd": "the_command"}
-        mock_process_perm.return_value = [[], 3, 4]
-        mock_process_rqtl.return_value = []
 
         results = run_rqtl(trait_name="the_trait", vals=[], samples=[],
         dataset=dataset, mapping_scale="cM", model="normal", method="hk",
@@ -39,6 +35,5 @@ class TestRqtlMapping(unittest.TestCase):
         mock_write_pheno_file.assert_called_once()
         mock_locate.assert_called_once()
         mock_post.assert_called_once()
-        mock_process_perm.assert_called_once()
-        mock_process_rqtl.assert_called_once()
+
         self.assertEqual(results, ([], 3, 4, []))
-- 
cgit v1.2.3


From 0cc4376462b7f136e59d99dba1975d6023326126 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:32:58 +0000
Subject: Fixed syntax mistake when creating dataclass in test_rqtl_mapping.py

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 00a05d2d..31a2c9e4 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -4,7 +4,7 @@ from wqflask.marker_regression.rqtl_mapping import run_rqtl
 
 @dataclass
 class MockGroup:
-    name: str,
+    name: str
     genofile: str
 
 @dataclass
-- 
cgit v1.2.3


From 97df46292e8322f01466d36b1e1e3ecdad64e5c0 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:50:03 +0000
Subject: Forgot to import dataclass

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 31a2c9e4..ff451230 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -1,5 +1,7 @@
 import unittest
 from unittest import mock
+from dataclasses import dataclass
+
 from wqflask.marker_regression.rqtl_mapping import run_rqtl
 
 @dataclass
-- 
cgit v1.2.3


From 767ff7e97a751f164da610b2f9c536b6660ec420 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 20:53:22 +0000
Subject: Fixed way MockGroup was initialized

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index ff451230..a7f708e1 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -20,8 +20,7 @@ class TestRqtlMapping(unittest.TestCase):
     @mock.patch("wqflask.marker_regression.rqtl_mapping.write_phenotype_file")
     def test_run_rqtl_with_perm(self, mock_write_pheno_file, mock_locate, mock_post):
         """Test for run_rqtl with permutations > 0"""
-        dataset_group = MockGroup(
-            {"name": "GP1", "genofile": "file_geno"})
+        dataset_group = MockGroup("GP1", "file_geno")
         dataset = MockDataset(dataset_group)
 
         mock_write_pheno_file.return_value = "pheno_filename"
-- 
cgit v1.2.3


From f69eb61c5f58b008233f7bee0e551fe9151c7724 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 21:09:18 +0000
Subject: Change test_rqtl_mapping.py to account for full results being
 returned from the GN3 request

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index a7f708e1..9a5162ae 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -25,8 +25,11 @@ class TestRqtlMapping(unittest.TestCase):
 
         mock_write_pheno_file.return_value = "pheno_filename"
         mock_locate.return_value = "geno_filename"
-        mock_post.return_value = {"output_file": "output_filename",
-                                  "rqtl_cmd": "the_command"}
+        mock_post.return_value = Mock(ok=True)
+        mock_post.return_value.json.return_value = {"perm_results": [],
+                                                    "suggestive": 3,
+                                                    "significant": 4,
+                                                    "results" : []}
 
         results = run_rqtl(trait_name="the_trait", vals=[], samples=[],
         dataset=dataset, mapping_scale="cM", model="normal", method="hk",
-- 
cgit v1.2.3


From e78c84aa10849465e0272daa6d94bfbd3419b072 Mon Sep 17 00:00:00 2001
From: zsloan
Date: Thu, 27 May 2021 21:11:16 +0000
Subject: Fix the way Mock is initialized

---
 wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
index 9a5162ae..9d13e943 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_rqtl_mapping.py
@@ -25,7 +25,7 @@ class TestRqtlMapping(unittest.TestCase):
 
         mock_write_pheno_file.return_value = "pheno_filename"
         mock_locate.return_value = "geno_filename"
-        mock_post.return_value = Mock(ok=True)
+        mock_post.return_value = mock.Mock(ok=True)
         mock_post.return_value.json.return_value = {"perm_results": [],
                                                     "suggestive": 3,
                                                     "significant": 4,
-- 
cgit v1.2.3


From 3a9ef933faec1f14560b1f6ced9fcd4413089770 Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Tue, 6 Jul 2021 21:10:20 +0300
Subject: replace rpy2 for tissue corr

---
 .../correlation/test_correlation_functions.py      | 20 +++++++++++
 .../wqflask/correlation/correlation_functions.py   | 39 +++++-----------------
 wqflask/wqflask/correlation/show_corr_results.py   |  3 +-
 3 files changed, 30 insertions(+), 32 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
index 2bbeab1f..a8cf6006 100644
--- a/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
+++ b/wqflask/tests/unit/wqflask/correlation/test_correlation_functions.py
@@ -1,10 +1,30 @@
+"""module contains tests for correlation functions"""
+
 import unittest
 from unittest import mock
+
 from wqflask.correlation.correlation_functions import get_trait_symbol_and_tissue_values
 from wqflask.correlation.correlation_functions import cal_zero_order_corr_for_tiss
 
 
 class TestCorrelationFunctions(unittest.TestCase):
+    """test for correlation helper functions"""
+
+    @mock.patch("wqflask.correlation.correlation_functions.compute_corr_coeff_p_value")
+    def test_tissue_corr_computation(self, mock_tiss_corr_computation):
+        """test for cal_zero_order_corr_for_tiss"""
+
+        primary_values = [9.288, 9.313, 8.988, 9.660, 8.21]
+        target_values = [9.586, 8.498, 9.362, 8.820, 8.786]
+
+        mock_tiss_corr_computation.return_value = (0.51, 0.7)
+
+        results = cal_zero_order_corr_for_tiss(primary_values, target_values)
+        mock_tiss_corr_computation.assert_called_once_with(
+            primary_values=primary_values, target_values=target_values,
+            corr_method="pearson")
+
+        self.assertEqual(len(results), 3)
 
     @mock.patch("wqflask.correlation.correlation_functions.MrnaAssayTissueData")
     def test_get_trait_symbol_and_tissue_values(self, mock_class):
diff --git a/wqflask/wqflask/correlation/correlation_functions.py b/wqflask/wqflask/correlation/correlation_functions.py
index c8b9da0e..85b25d60 100644
--- a/wqflask/wqflask/correlation/correlation_functions.py
+++ b/wqflask/wqflask/correlation/correlation_functions.py
@@ -21,15 +21,10 @@
 # This module is used by GeneNetwork project (www.genenetwork.org)
 #
 # Created by GeneNetwork Core Team 2010/08/10
-#
-# Last updated by NL 2011/03/23
 
-import math
-import string
 
 from base.mrna_assay_tissue_data import MrnaAssayTissueData
-
-from flask import Flask, g
+from gn3.computations.correlations import compute_corr_coeff_p_value
 
 
 #####################################################################################
@@ -45,31 +40,14 @@ from flask import Flask, g
 # the same tissue order
 #####################################################################################
 
-def cal_zero_order_corr_for_tiss(primaryValue=[], targetValue=[], method='pearson'):
-
-    N = len(primaryValue)
-    # R_primary = rpy2.robjects.FloatVector(list(range(len(primaryValue))))
-    # for i in range(len(primaryValue)):
-    #     R_primary[i] = primaryValue[i]
 
-    # R_target = rpy2.robjects.FloatVector(list(range(len(targetValue))))
-    # for i in range(len(targetValue)):
-    #     R_target[i] = targetValue[i]
+def cal_zero_order_corr_for_tiss(primary_values, target_values, method="pearson"):
+    """function use calls gn3 to compute corr,p_val"""
 
-    # R_corr_test = rpy2.robjects.r['cor.test']
-    # if method == 'spearman':
-    #     R_result = R_corr_test(R_primary, R_target, method='spearman')
-    # else:
-    #     R_result = R_corr_test(R_primary, R_target)
-
-    # corr_result = []
-    # corr_result.append(R_result[3][0])
-    # corr_result.append(N)
-    # corr_result.append(R_result[2][0])
-
-    return [None, N, None]
-    # return corr_result
+    (corr_coeff, p_val) = compute_corr_coeff_p_value(
+        primary_values=primary_values, target_values=target_values, corr_method=method)
 
+    return (corr_coeff, len(primary_values), p_val)
 
 ########################################################################################################
 # input: cursor, symbolList (list), dataIdDict(Dict): key is symbol
@@ -80,8 +58,9 @@ def cal_zero_order_corr_for_tiss(primaryValue=[], targetValue=[], method='pearso
 #          then call getSymbolValuePairDict function and merge the results.
 ########################################################################################################
 
+
 def get_trait_symbol_and_tissue_values(symbol_list=None):
     tissue_data = MrnaAssayTissueData(gene_symbols=symbol_list)
-    if len(tissue_data.gene_symbols) >0:
+    if len(tissue_data.gene_symbols) > 0:
         results = tissue_data.get_symbol_values_pairs()
-        return results 
+        return results
diff --git a/wqflask/wqflask/correlation/show_corr_results.py b/wqflask/wqflask/correlation/show_corr_results.py
index f1cf3733..b0496bfe 100644
--- a/wqflask/wqflask/correlation/show_corr_results.py
+++ b/wqflask/wqflask/correlation/show_corr_results.py
@@ -34,6 +34,7 @@ from utility import corr_result_helpers
 from utility import hmac
 
 from wqflask.correlation import correlation_functions
+
 from utility.benchmark import Bench
 
 from utility.type_checking import is_str
@@ -93,7 +94,6 @@ class CorrelationResults:
             self.p_range_lower = get_float(start_vars, 'p_range_lower', -1.0)
             self.p_range_upper = get_float(start_vars, 'p_range_upper', 1.0)
 
-
             if ('loc_chr' in start_vars
                 and 'min_loc_mb' in start_vars
                     and 'max_loc_mb' in start_vars):
@@ -198,7 +198,6 @@ class CorrelationResults:
                         if chr_info.name == trait_object.chr:
                             chr_as_int = order_id
 
-
                 if (float(self.correlation_data[trait][0]) >= self.p_range_lower
                         and float(self.correlation_data[trait][0]) <= self.p_range_upper):
 
-- 
cgit v1.2.3


From 344d6a86d2e468249ec7b583e8c0751f99cd6a5b Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Mon, 12 Jul 2021 11:40:40 +0300
Subject: tests: test_markdown_routes: Remove stubbed out tests

---
 wqflask/tests/integration/test_markdown_routes.py | 21 ---------------------
 1 file changed, 21 deletions(-)
 delete mode 100644 wqflask/tests/integration/test_markdown_routes.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/integration/test_markdown_routes.py b/wqflask/tests/integration/test_markdown_routes.py
deleted file mode 100644
index 5e3e5045..00000000
--- a/wqflask/tests/integration/test_markdown_routes.py
+++ /dev/null
@@ -1,21 +0,0 @@
-"Integration tests for markdown routes"
-import unittest
-
-from bs4 import BeautifulSoup
-
-from wqflask import app
-
-
-class TestGenMenu(unittest.TestCase):
-    """Tests for glossary"""
-
-    def setUp(self):
-        self.app = app.test_client()
-
-    def tearDown(self):
-        pass
-
-    def test_glossary_page(self):
-        """Test that the glossary page is rendered properly"""
-        response = self.app.get('/glossary', follow_redirects=True)
-        pass
-- 
cgit v1.2.3


From 2236508f24c8c266a6a9dff28a1307bb3d0dd31e Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 5 Oct 2021 11:07:09 +0300
Subject: tests: test_run_mapping: Add missing positional argument "vals_hash"

---
 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index c220a072..31f56c07 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -181,7 +181,8 @@ class TestRunMapping(unittest.TestCase):
             with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
                 export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
                                        results_path="~/results", mapping_scale="physic", score_type="-log(p)",
-                                       transform="qnorm", covariates="Dataset1:Trait1,Dataset2:Trait2", n_samples="100")
+                                       transform="qnorm", covariates="Dataset1:Trait1,Dataset2:Trait2", n_samples="100",
+                                       vals_hash="")
 
                 write_calls = [
                     mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
-- 
cgit v1.2.3


From 321632bf70c72ed987ba7c4f605dd92deaa62380 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 5 Oct 2021 11:10:04 +0300
Subject: tests: test_run_mapping: Add missing attribute to "self.trait"

---
 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 31f56c07..26903eed 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -47,7 +47,7 @@ class TestRunMapping(unittest.TestCase):
 
         self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
         self.trait = AttributeSetter(
-            {"symbol": "IGFI", "chr": "X1", "mb": 123313})
+            {"symbol": "IGFI", "chr": "X1", "mb": 123313, "display_name": "Test Name"})
 
     def tearDown(self):
         self.dataset = AttributeSetter(
-- 
cgit v1.2.3


From e97719eea27ede1b3e943e6d21d18e5d383679f0 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 5 Oct 2021 11:12:29 +0300
Subject: tests: test_run_mapping: Fix failing assert when getting perm strata

---
 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 26903eed..3e9e4ef3 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -233,25 +233,20 @@ class TestRunMapping(unittest.TestCase):
                 "c1": "c1_value",
                 "c2": "c2_value",
                 "w1": "w1_value"
-
             },
             "S2": {
                 "w1": "w2_value",
                 "w2": "w2_value"
-
             },
             "S3": {
 
                 "c1": "c1_value",
                 "c2": "c2_value"
-
             },
-
         }})
-
         results = get_perm_strata(this_trait={}, sample_list=sample_list,
                                   categorical_vars=categorical_vars, used_samples=used_samples)
-        self.assertEqual(results, [2, 1])
+        self.assertEqual(results, [1, 1])
 
     def test_get_chr_length(self):
         """test for getting chromosome length"""
-- 
cgit v1.2.3


From 1f5be42d8f090fd4fe77a9275b12a9c9b1383d09 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 5 Oct 2021 11:19:52 +0300
Subject: tests: test_run_mapping: Add missing calls

After adding the missing attribute to "self.trait", we need to also
need to update some missing calls.
---
 wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 3e9e4ef3..3747aeb8 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -188,6 +188,8 @@ class TestRunMapping(unittest.TestCase):
                     mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
                     mock.call('Population: Human GP1_\n'), mock.call(
                         'Data Set: dataser_1\n'),
+                    mock.call('Trait: Test Name\n'),
+                    mock.call('Trait Hash: \n'),
                     mock.call('N Samples: 100\n'), mock.call(
                         'Transform - Quantile Normalized\n'),
                     mock.call('Gene Symbol: IGFI\n'), mock.call(
-- 
cgit v1.2.3


From a4ec2505fb9dd6f0480c9b452fd623e038c07939 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Tue, 5 Oct 2021 11:28:33 +0300
Subject: tests: test_run_mapping: Add missing "name" attribute to tests

---
 .../unit/wqflask/marker_regression/test_gemma_mapping.py     | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
index 4003d68f..58a44b2a 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_gemma_mapping.py
@@ -81,10 +81,12 @@ class TestGemmaMapping(unittest.TestCase):
     def test_gen_pheno_txt_file(self):
         """add tests for generating pheno txt file"""
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
-            gen_pheno_txt_file(this_dataset={}, genofile_name="", vals=[
-                               "x", "w", "q", "we", "R"], trait_filename="fitr.re")
+            gen_pheno_txt_file(
+                this_dataset=AttributeSetter({"name": "A"}),
+                genofile_name="", vals=[
+                    "x", "w", "q", "we", "R"])
             mock_open.assert_called_once_with(
-                '/home/user/data/gn2/fitr.re.txt', 'w')
+                '/home/user/data/gn2/PHENO_KiAEKlCvM6iGTM9Kh_TAlQ.txt', 'w')
             filehandler = mock_open()
             values = ["x", "w", "q", "we", "R"]
             write_calls = [mock.call('NA\n'), mock.call('w\n'), mock.call(
@@ -112,7 +114,7 @@ class TestGemmaMapping(unittest.TestCase):
         create_trait.side_effect = create_trait_side_effect
 
         group = MockGroup({"name": "group_X", "samplelist": samplelist})
-        this_dataset = AttributeSetter({"group": group})
+        this_dataset = AttributeSetter({"group": group, "name": "A"})
         flat_files.return_value = "Home/Genenetwork"
 
         with mock.patch("builtins.open", mock.mock_open())as mock_open:
@@ -132,7 +134,7 @@ class TestGemmaMapping(unittest.TestCase):
 
             flat_files.assert_called_once_with('mapping')
             mock_open.assert_called_once_with(
-                'Home/Genenetwork/group_X_covariates.txt', 'w')
+                'Home/Genenetwork/COVAR_anFZ_LfZYV0Ulywo+7tRCw.txt', 'w')
             filehandler = mock_open()
             filehandler.write.assert_has_calls([mock.call(
                 '-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('-9\t'), mock.call('\n')])
-- 
cgit v1.2.3


From ef80c72194dd8a0b8868ece15589e0a3cf04516f Mon Sep 17 00:00:00 2001
From: Alexander Kabui
Date: Sat, 9 Oct 2021 21:55:39 +0300
Subject: unittest for processing wgcna output

---
 wqflask/tests/unit/wqflask/wgcna/__init__.py   |  0
 wqflask/tests/unit/wqflask/wgcna/test_wgcna.py | 50 ++++++++++++++++++++++++++
 2 files changed, 50 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/wgcna/__init__.py
 create mode 100644 wqflask/tests/unit/wqflask/wgcna/test_wgcna.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/wgcna/__init__.py b/wqflask/tests/unit/wqflask/wgcna/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py b/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py
new file mode 100644
index 00000000..8e947e2f
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/wgcna/test_wgcna.py
@@ -0,0 +1,50 @@
+
+"""module contains for processing gn3 wgcna data"""
+from unittest import TestCase
+
+from wqflask.wgcna.gn3_wgcna import process_wgcna_data
+
+
+class DataProcessingTests(TestCase):
+    """class contains data processing tests"""
+
+    def test_data_processing(self):
+        """test for parsing data for datatable"""
+        output = {
+            "input": {
+                "sample_names": ["BXD1", "BXD2", "BXD3", "BXD4", "BXD5", "BXD6"],
+
+            },
+            "output": {
+                "ModEigens": {
+                    "MEturquoise": [
+                        0.0646677768085351,
+                        0.137200224277058,
+                        0.63451113720732,
+                        -0.544002665501479,
+                        -0.489487590361863,
+                        0.197111117570427
+                    ],
+                    "MEgrey": [
+                        0.213,
+                        0.214,
+                        0.3141,
+                        -0.545,
+                        -0.423,
+                        0.156,
+                    ]
+                }}}
+
+        row_data = [['BXD1', 0.065, 0.213],
+                    ['BXD2', 0.137, 0.214],
+                    ['BXD3', 0.635, 0.314],
+                    ['BXD4', -0.544, -0.545],
+                    ['BXD5', -0.489, -0.423],
+                    ['BXD6', 0.197, 0.156]]
+
+        expected_results = {
+            "col_names": ["sample_names", "MEturquoise", "MEgrey"],
+            "mod_dataset": row_data
+        }
+
+        self.assertEqual(process_wgcna_data(output), expected_results)
-- 
cgit v1.2.3


From a212ad123f902b6a9c74bcac1d98bc274cebbdda Mon Sep 17 00:00:00 2001
From: zsloan
Date: Tue, 12 Oct 2021 17:36:02 +0000
Subject: Fixed export_mapping_results test in test_run_mapping.py

---
 .../wqflask/marker_regression/test_run_mapping.py  | 33 +++++++++++-----------
 1 file changed, 16 insertions(+), 17 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
index 3747aeb8..868b0b0b 100644
--- a/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
+++ b/wqflask/tests/unit/wqflask/marker_regression/test_run_mapping.py
@@ -43,7 +43,7 @@ class TestRunMapping(unittest.TestCase):
             })
         }
         self.dataset = AttributeSetter(
-            {"fullname": "dataser_1", "group": self.group, "type": "ProbeSet"})
+            {"fullname": "dataset_1", "group": self.group, "type": "ProbeSet"})
 
         self.chromosomes = AttributeSetter({"chromosomes": chromosomes})
         self.trait = AttributeSetter(
@@ -180,37 +180,36 @@ class TestRunMapping(unittest.TestCase):
 
             with mock.patch("wqflask.marker_regression.run_mapping.datetime.datetime", new=datetime_mock):
                 export_mapping_results(dataset=self.dataset, trait=self.trait, markers=markers,
-                                       results_path="~/results", mapping_scale="physic", score_type="-log(p)",
-                                       transform="qnorm", covariates="Dataset1:Trait1,Dataset2:Trait2", n_samples="100",
-                                       vals_hash="")
+                                       results_path="~/results", mapping_method="gemma", mapping_scale="physic",
+                                       score_type="-logP", transform="qnorm",
+                                       covariates="Dataset1:Trait1,Dataset2:Trait2",
+                                       n_samples="100", vals_hash="")
 
                 write_calls = [
                     mock.call('Time/Date: 09/01/19 / 10:12:12\n'),
                     mock.call('Population: Human GP1_\n'), mock.call(
-                        'Data Set: dataser_1\n'),
+                        'Data Set: dataset_1\n'),
                     mock.call('Trait: Test Name\n'),
                     mock.call('Trait Hash: \n'),
-                    mock.call('N Samples: 100\n'), mock.call(
-                        'Transform - Quantile Normalized\n'),
+                    mock.call('N Samples: 100\n'),
+                    mock.call('Mapping Tool: gemma\n'),
+                    mock.call('Transform - Quantile Normalized\n'),
                     mock.call('Gene Symbol: IGFI\n'), mock.call(
                         'Location: X1 @ 123313 Mb\n'),
                     mock.call('Cofactors (dataset - trait):\n'),
                     mock.call('Trait1 - Dataset1\n'),
                     mock.call('Trait2 - Dataset2\n'),
                     mock.call('\n'), mock.call('Name,Chr,'),
-                    mock.call('Mb,-log(p)'), mock.call('Cm,-log(p)'),
+                    mock.call('Mb,-logP'),
                     mock.call(',Additive'), mock.call(',Dominance'),
                     mock.call('\n'), mock.call('MK1,C1,'),
-                    mock.call('12000,'), mock.call('1,'),
-                    mock.call('3'), mock.call(',VA'),
-                    mock.call(',TT'), mock.call('\n'),
-                    mock.call('MK2,C2,'), mock.call('10000,'),
-                    mock.call('15,'), mock.call('7'),
+                    mock.call('12000,'), mock.call('3'),
+                    mock.call(',VA'), mock.call(',TT'),
+                    mock.call('\n'), mock.call('MK2,C2,'),
+                    mock.call('10000,'), mock.call('7'),
                     mock.call('\n'), mock.call('MK1,C3,'),
-                    mock.call('1,'), mock.call('45,'),
-                    mock.call('7'), mock.call(',VE'),
-                    mock.call(',Tt')
-
+                    mock.call('1,'), mock.call('7'),
+                    mock.call(',VE'), mock.call(',Tt')
                 ]
                 mock_open.assert_called_once_with("~/results", "w+")
                 filehandler = mock_open()
-- 
cgit v1.2.3


From 0c6ad845e6f461e880b423bd8f79156754658f8a Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Sat, 9 Oct 2021 09:43:40 +0300
Subject: Move markdown_routes to api/markdown

All new API definitions should be migrated to "wqflask/ api"
---
 .../tests/unit/wqflask/api/test_markdown_routes.py |  54 ++++++
 wqflask/tests/unit/wqflask/test_markdown_routes.py |  54 ------
 wqflask/wqflask/__init__.py                        |  16 +-
 wqflask/wqflask/api/correlation.py                 |   6 -
 wqflask/wqflask/api/markdown.py                    | 186 +++++++++++++++++++++
 wqflask/wqflask/markdown_routes.py                 | 186 ---------------------
 6 files changed, 248 insertions(+), 254 deletions(-)
 create mode 100644 wqflask/tests/unit/wqflask/api/test_markdown_routes.py
 delete mode 100644 wqflask/tests/unit/wqflask/test_markdown_routes.py
 create mode 100644 wqflask/wqflask/api/markdown.py
 delete mode 100644 wqflask/wqflask/markdown_routes.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/api/test_markdown_routes.py b/wqflask/tests/unit/wqflask/api/test_markdown_routes.py
new file mode 100644
index 00000000..1c513ac5
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/api/test_markdown_routes.py
@@ -0,0 +1,54 @@
+"""Test functions for wqflask/api/markdown.py"""
+
+import unittest
+from unittest import mock
+
+from dataclasses import dataclass
+from wqflask.api.markdown import render_markdown
+
+
+@dataclass
+class MockRequests404:
+    status_code: int = 404
+
+
+@dataclass
+class MockRequests200:
+    status_code: int = 200
+    content: str = b"""
+# Glossary
+This is some content
+
+## Sub-heading
+This is another sub-heading"""
+
+
+class TestMarkdownRoutesFunctions(unittest.TestCase):
+    """Test cases for functions in markdown"""
+
+    @mock.patch('wqflask.api.markdown.requests.get')
+    def test_render_markdown_when_fetching_locally(self, requests_mock):
+        requests_mock.return_value = MockRequests404()
+        markdown_content = render_markdown("general/glossary/glossary.md")
+        requests_mock.assert_called_with(
+            "https://raw.githubusercontent.com"
+            "/genenetwork/gn-docs/"
+            "master/general/"
+            "glossary/glossary.md")
+        self.assertRegexpMatches(markdown_content,
+                                 "Content for general/glossary/glossary.md not available.")
+
+    @mock.patch('wqflask.api.markdown.requests.get')
+    def test_render_markdown_when_fetching_remotely(self, requests_mock):
+        requests_mock.return_value = MockRequests200()
+        markdown_content = render_markdown("general/glossary/glossary.md")
+        requests_mock.assert_called_with(
+            "https://raw.githubusercontent.com"
+            "/genenetwork/gn-docs/"
+            "master/general/"
+            "glossary/glossary.md")
+        self.assertEqual("""<h1>Glossary</h1>
+<p>This is some content</p>
+<h2>Sub-heading</h2>
+<p>This is another sub-heading</p>""",
+                         markdown_content)
diff --git a/wqflask/tests/unit/wqflask/test_markdown_routes.py b/wqflask/tests/unit/wqflask/test_markdown_routes.py
deleted file mode 100644
index 90e0f17c..00000000
--- a/wqflask/tests/unit/wqflask/test_markdown_routes.py
+++ /dev/null
@@ -1,54 +0,0 @@
-"""Test functions in markdown utils"""
-
-import unittest
-from unittest import mock
-
-from dataclasses import dataclass
-from wqflask.markdown_routes import render_markdown
-
-
-@dataclass
-class MockRequests404:
-    status_code: int = 404
-
-
-@dataclass
-class MockRequests200:
-    status_code: int = 200
-    content: str = b"""
-# Glossary
-This is some content
-
-## Sub-heading
-This is another sub-heading"""
-
-
-class TestMarkdownRoutesFunctions(unittest.TestCase):
-    """Test cases for functions in markdown_routes"""
-
-    @mock.patch('wqflask.markdown_routes.requests.get')
-    def test_render_markdown_when_fetching_locally(self, requests_mock):
-        requests_mock.return_value = MockRequests404()
-        markdown_content = render_markdown("general/glossary/glossary.md")
-        requests_mock.assert_called_with(
-            "https://raw.githubusercontent.com"
-            "/genenetwork/gn-docs/"
-            "master/general/"
-            "glossary/glossary.md")
-        self.assertRegexpMatches(markdown_content,
-                                 "Content for general/glossary/glossary.md not available.")
-
-    @mock.patch('wqflask.markdown_routes.requests.get')
-    def test_render_markdown_when_fetching_remotely(self, requests_mock):
-        requests_mock.return_value = MockRequests200()
-        markdown_content = render_markdown("general/glossary/glossary.md")
-        requests_mock.assert_called_with(
-            "https://raw.githubusercontent.com"
-            "/genenetwork/gn-docs/"
-            "master/general/"
-            "glossary/glossary.md")
-        self.assertEqual("""<h1>Glossary</h1>
-<p>This is some content</p>
-<h2>Sub-heading</h2>
-<p>This is another sub-heading</p>""",
-                         markdown_content)
diff --git a/wqflask/wqflask/__init__.py b/wqflask/wqflask/__init__.py
index 8b2055cd..5758b13e 100644
--- a/wqflask/wqflask/__init__.py
+++ b/wqflask/wqflask/__init__.py
@@ -8,14 +8,14 @@ from flask import Flask
 from typing import Tuple
 from urllib.parse import urlparse
 from utility import formatting
-from wqflask.markdown_routes import glossary_blueprint
-from wqflask.markdown_routes import references_blueprint
-from wqflask.markdown_routes import links_blueprint
-from wqflask.markdown_routes import policies_blueprint
-from wqflask.markdown_routes import environments_blueprint
-from wqflask.markdown_routes import facilities_blueprint
-from wqflask.markdown_routes import blogs_blueprint
-from wqflask.markdown_routes import news_blueprint
+from wqflask.api.markdown import glossary_blueprint
+from wqflask.api.markdown import references_blueprint
+from wqflask.api.markdown import links_blueprint
+from wqflask.api.markdown import policies_blueprint
+from wqflask.api.markdown import environments_blueprint
+from wqflask.api.markdown import facilities_blueprint
+from wqflask.api.markdown import blogs_blueprint
+from wqflask.api.markdown import news_blueprint
 
 app = Flask(__name__)
 
diff --git a/wqflask/wqflask/api/correlation.py b/wqflask/wqflask/api/correlation.py
index a135ecc8..9b875c99 100644
--- a/wqflask/wqflask/api/correlation.py
+++ b/wqflask/wqflask/api/correlation.py
@@ -9,7 +9,6 @@ from utility.db_tools import escape
 from wqflask.correlation import correlation_functions
 
 
-
 def do_correlation(start_vars):
     assert('db' in start_vars)
     assert('target_db' in start_vars)
@@ -26,7 +25,6 @@ def do_correlation(start_vars):
 
     corr_results = calculate_results(
         this_trait, this_dataset, target_dataset, corr_params)
-    #corr_results = collections.OrderedDict(sorted(corr_results.items(), key=lambda t: -abs(t[1][0])))
 
     final_results = []
     for _trait_counter, trait in enumerate(list(corr_results.keys())[:corr_params['return_count']]):
@@ -54,11 +52,7 @@ def do_correlation(start_vars):
                 "#_strains": num_overlap,
                 "p_value": sample_p
             }
-
         final_results.append(result_dict)
-
-    # json_corr_results = generate_corr_json(final_corr_results, this_trait, this_dataset, target_dataset, for_api = True)
-
     return final_results
 
 
diff --git a/wqflask/wqflask/api/markdown.py b/wqflask/wqflask/api/markdown.py
new file mode 100644
index 00000000..580b9ac0
--- /dev/null
+++ b/wqflask/wqflask/api/markdown.py
@@ -0,0 +1,186 @@
+"""Markdown routes
+
+Render pages from github, or if they are unavailable, look for it else where
+"""
+
+import requests
+import markdown
+import os
+import sys
+
+from bs4 import BeautifulSoup  # type: ignore
+
+from flask import send_from_directory
+from flask import Blueprint
+from flask import render_template
+
+from typing import Dict
+from typing import List
+
+glossary_blueprint = Blueprint('glossary_blueprint', __name__)
+references_blueprint = Blueprint("references_blueprint", __name__)
+environments_blueprint = Blueprint("environments_blueprint", __name__)
+links_blueprint = Blueprint("links_blueprint", __name__)
+policies_blueprint = Blueprint("policies_blueprint", __name__)
+facilities_blueprint = Blueprint("facilities_blueprint", __name__)
+news_blueprint = Blueprint("news_blueprint", __name__)
+
+blogs_blueprint = Blueprint("blogs_blueprint", __name__)
+
+
+def render_markdown(file_name, is_remote_file=True):
+    """Try to fetch the file name from Github and if that fails, try to
+look for it inside the file system """
+    github_url = ("https://raw.githubusercontent.com/"
+                  "genenetwork/gn-docs/master/")
+
+    if not is_remote_file:
+        text = ""
+        with open(file_name, "r", encoding="utf-8") as input_file:
+            text = input_file.read()
+        return markdown.markdown(text,
+                                 extensions=['tables'])
+
+    md_content = requests.get(f"{github_url}{file_name}")
+
+    if md_content.status_code == 200:
+        return markdown.markdown(md_content.content.decode("utf-8"),
+                                 extensions=['tables'])
+
+    return (f"\nContent for {file_name} not available. "
+            "Please check "
+            "(here to see where content exists)"
+            "[https://github.com/genenetwork/gn-docs]. "
+            "Please reach out to the gn2 team to have a look at this")
+
+
+def get_file_from_python_search_path(pathname_suffix):
+    cands = [os.path.join(d, pathname_suffix) for d in sys.path]
+    try:
+        return list(filter(os.path.exists, cands))[0]
+    except IndexError:
+        return None
+
+
+def get_blogs(user: str = "genenetwork",
+              repo_name: str = "gn-docs") -> dict:
+
+    blogs: Dict[int, List] = {}
+    github_url = f"https://api.github.com/repos/{user}/{repo_name}/git/trees/master?recursive=1"
+
+    repo_tree = requests.get(github_url).json()["tree"]
+
+    for data in repo_tree:
+        path_name = data["path"]
+        if path_name.startswith("blog") and path_name.endswith(".md"):
+            split_path = path_name.split("/")[1:]
+            try:
+                year, title, file_name = split_path
+            except Exception as e:
+                year, file_name = split_path
+                title = ""
+
+            subtitle = os.path.splitext(file_name)[0]
+
+            blog = {
+                "title": title,
+                "subtitle": subtitle,
+                "full_path": path_name
+            }
+
+            if year in blogs:
+                blogs[int(year)].append(blog)
+            else:
+                blogs[int(year)] = [blog]
+
+    return dict(sorted(blogs.items(), key=lambda x: x[0], reverse=True))
+
+
+@glossary_blueprint.route('/')
+def glossary():
+    return render_template(
+        "glossary.html",
+        rendered_markdown=render_markdown("general/glossary/glossary.md")), 200
+
+
+@references_blueprint.route('/')
+def references():
+    return render_template(
+        "references.html",
+        rendered_markdown=render_markdown("general/references/references.md")), 200
+
+
+@news_blueprint.route('/')
+def news():
+    return render_template(
+        "news.html",
+        rendered_markdown=render_markdown("general/news/news.md")), 200
+
+
+@environments_blueprint.route("/")
+def environments():
+
+    md_file = get_file_from_python_search_path("wqflask/DEPENDENCIES.md")
+    svg_file = get_file_from_python_search_path(
+        "wqflask/dependency-graph.html")
+    svg_data = None
+    if svg_file:
+        with open(svg_file, 'r') as f:
+            svg_data = "".join(
+                BeautifulSoup(f.read(),
+                              'lxml').body.script.contents)
+
+    if md_file is not None:
+        return (
+            render_template("environment.html",
+                            svg_data=svg_data,
+                            rendered_markdown=render_markdown(
+                                md_file,
+                                is_remote_file=False)),
+            200
+        )
+    # Fallback: Fetch file from server
+    return (render_template(
+        "environment.html",
+        svg_data=None,
+        rendered_markdown=render_markdown(
+            "general/environments/environments.md")),
+            200)
+
+
+@environments_blueprint.route('/svg-dependency-graph')
+def svg_graph():
+    directory, file_name, _ = get_file_from_python_search_path(
+        "wqflask/dependency-graph.svg").partition("dependency-graph.svg")
+    return send_from_directory(directory, file_name)
+
+
+@links_blueprint.route("/")
+def links():
+    return render_template(
+        "links.html",
+        rendered_markdown=render_markdown("general/links/links.md")), 200
+
+
+@policies_blueprint.route("/")
+def policies():
+    return render_template(
+        "policies.html",
+        rendered_markdown=render_markdown("general/policies/policies.md")), 200
+
+
+@facilities_blueprint.route("/")
+def facilities():
+    return render_template("facilities.html", rendered_markdown=render_markdown("general/help/facilities.md")), 200
+
+
+@blogs_blueprint.route("/<path:blog_path>")
+def display_blog(blog_path):
+    return render_template("blogs.html", rendered_markdown=render_markdown(blog_path))
+
+
+@blogs_blueprint.route("/")
+def blogs_list():
+    blogs = get_blogs()
+
+    return render_template("blogs_list.html", blogs=blogs)
diff --git a/wqflask/wqflask/markdown_routes.py b/wqflask/wqflask/markdown_routes.py
deleted file mode 100644
index 580b9ac0..00000000
--- a/wqflask/wqflask/markdown_routes.py
+++ /dev/null
@@ -1,186 +0,0 @@
-"""Markdown routes
-
-Render pages from github, or if they are unavailable, look for it else where
-"""
-
-import requests
-import markdown
-import os
-import sys
-
-from bs4 import BeautifulSoup  # type: ignore
-
-from flask import send_from_directory
-from flask import Blueprint
-from flask import render_template
-
-from typing import Dict
-from typing import List
-
-glossary_blueprint = Blueprint('glossary_blueprint', __name__)
-references_blueprint = Blueprint("references_blueprint", __name__)
-environments_blueprint = Blueprint("environments_blueprint", __name__)
-links_blueprint = Blueprint("links_blueprint", __name__)
-policies_blueprint = Blueprint("policies_blueprint", __name__)
-facilities_blueprint = Blueprint("facilities_blueprint", __name__)
-news_blueprint = Blueprint("news_blueprint", __name__)
-
-blogs_blueprint = Blueprint("blogs_blueprint", __name__)
-
-
-def render_markdown(file_name, is_remote_file=True):
-    """Try to fetch the file name from Github and if that fails, try to
-look for it inside the file system """
-    github_url = ("https://raw.githubusercontent.com/"
-                  "genenetwork/gn-docs/master/")
-
-    if not is_remote_file:
-        text = ""
-        with open(file_name, "r", encoding="utf-8") as input_file:
-            text = input_file.read()
-        return markdown.markdown(text,
-                                 extensions=['tables'])
-
-    md_content = requests.get(f"{github_url}{file_name}")
-
-    if md_content.status_code == 200:
-        return markdown.markdown(md_content.content.decode("utf-8"),
-                                 extensions=['tables'])
-
-    return (f"\nContent for {file_name} not available. "
-            "Please check "
-            "(here to see where content exists)"
-            "[https://github.com/genenetwork/gn-docs]. "
-            "Please reach out to the gn2 team to have a look at this")
-
-
-def get_file_from_python_search_path(pathname_suffix):
-    cands = [os.path.join(d, pathname_suffix) for d in sys.path]
-    try:
-        return list(filter(os.path.exists, cands))[0]
-    except IndexError:
-        return None
-
-
-def get_blogs(user: str = "genenetwork",
-              repo_name: str = "gn-docs") -> dict:
-
-    blogs: Dict[int, List] = {}
-    github_url = f"https://api.github.com/repos/{user}/{repo_name}/git/trees/master?recursive=1"
-
-    repo_tree = requests.get(github_url).json()["tree"]
-
-    for data in repo_tree:
-        path_name = data["path"]
-        if path_name.startswith("blog") and path_name.endswith(".md"):
-            split_path = path_name.split("/")[1:]
-            try:
-                year, title, file_name = split_path
-            except Exception as e:
-                year, file_name = split_path
-                title = ""
-
-            subtitle = os.path.splitext(file_name)[0]
-
-            blog = {
-                "title": title,
-                "subtitle": subtitle,
-                "full_path": path_name
-            }
-
-            if year in blogs:
-                blogs[int(year)].append(blog)
-            else:
-                blogs[int(year)] = [blog]
-
-    return dict(sorted(blogs.items(), key=lambda x: x[0], reverse=True))
-
-
-@glossary_blueprint.route('/')
-def glossary():
-    return render_template(
-        "glossary.html",
-        rendered_markdown=render_markdown("general/glossary/glossary.md")), 200
-
-
-@references_blueprint.route('/')
-def references():
-    return render_template(
-        "references.html",
-        rendered_markdown=render_markdown("general/references/references.md")), 200
-
-
-@news_blueprint.route('/')
-def news():
-    return render_template(
-        "news.html",
-        rendered_markdown=render_markdown("general/news/news.md")), 200
-
-
-@environments_blueprint.route("/")
-def environments():
-
-    md_file = get_file_from_python_search_path("wqflask/DEPENDENCIES.md")
-    svg_file = get_file_from_python_search_path(
-        "wqflask/dependency-graph.html")
-    svg_data = None
-    if svg_file:
-        with open(svg_file, 'r') as f:
-            svg_data = "".join(
-                BeautifulSoup(f.read(),
-                              'lxml').body.script.contents)
-
-    if md_file is not None:
-        return (
-            render_template("environment.html",
-                            svg_data=svg_data,
-                            rendered_markdown=render_markdown(
-                                md_file,
-                                is_remote_file=False)),
-            200
-        )
-    # Fallback: Fetch file from server
-    return (render_template(
-        "environment.html",
-        svg_data=None,
-        rendered_markdown=render_markdown(
-            "general/environments/environments.md")),
-            200)
-
-
-@environments_blueprint.route('/svg-dependency-graph')
-def svg_graph():
-    directory, file_name, _ = get_file_from_python_search_path(
-        "wqflask/dependency-graph.svg").partition("dependency-graph.svg")
-    return send_from_directory(directory, file_name)
-
-
-@links_blueprint.route("/")
-def links():
-    return render_template(
-        "links.html",
-        rendered_markdown=render_markdown("general/links/links.md")), 200
-
-
-@policies_blueprint.route("/")
-def policies():
-    return render_template(
-        "policies.html",
-        rendered_markdown=render_markdown("general/policies/policies.md")), 200
-
-
-@facilities_blueprint.route("/")
-def facilities():
-    return render_template("facilities.html", rendered_markdown=render_markdown("general/help/facilities.md")), 200
-
-
-@blogs_blueprint.route("/<path:blog_path>")
-def display_blog(blog_path):
-    return render_template("blogs.html", rendered_markdown=render_markdown(blog_path))
-
-
-@blogs_blueprint.route("/")
-def blogs_list():
-    blogs = get_blogs()
-
-    return render_template("blogs_list.html", blogs=blogs)
-- 
cgit v1.2.3


From 212d19c29a42bd6966965b166cdbb4dd642e5eb4 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 13 Oct 2021 13:05:26 +0300
Subject: Add test-cases for `get_user_membership`

---
 .../tests/unit/wqflask/test_resource_manager.py    | 51 ++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 wqflask/tests/unit/wqflask/test_resource_manager.py

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_resource_manager.py b/wqflask/tests/unit/wqflask/test_resource_manager.py
new file mode 100644
index 00000000..a27f40e1
--- /dev/null
+++ b/wqflask/tests/unit/wqflask/test_resource_manager.py
@@ -0,0 +1,51 @@
+"""Test cases for wqflask/resource_manager.py"""
+import unittest
+
+from unittest import mock
+from wqflask.resource_manager import get_user_membership
+
+
+class TestGetUserMembership(unittest.TestCase):
+    """Test cases for `get_user_membership`"""
+
+    def setUp(self):
+        conn = mock.MagicMock()
+        conn.hgetall.return_value = {
+            '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': (
+                '{"name": "editors", '
+                '"admins": ["8ad942fe-490d-453e-bd37-56f252e41604", "rand"], '
+                '"members": ["8ad942fe-490d-453e-bd37-56f252e41603", '
+                '"rand"], '
+                '"changed_timestamp": "Oct 06 2021 06:39PM", '
+                '"created_timestamp": "Oct 06 2021 06:39PM"}')}
+        self.conn = conn
+
+    def test_user_is_group_member_only(self):
+        """Test that a user is only a group member"""
+        self.assertEqual(
+            get_user_membership(
+                conn=self.conn,
+                user_id="8ad942fe-490d-453e-bd37-56f252e41603",
+                group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+            {"member": True,
+             "admin": False})
+
+    def test_user_is_group_admin_only(self):
+        """Test that a user is a group admin only"""
+        self.assertEqual(
+            get_user_membership(
+                conn=self.conn,
+                user_id="8ad942fe-490d-453e-bd37-56f252e41604",
+                group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+            {"member": False,
+             "admin": True})
+
+    def test_user_is_both_group_member_and_admin(self):
+        """Test that a user is both an admin and member of a group"""
+        self.assertEqual(
+            get_user_membership(
+                conn=self.conn,
+                user_id="rand",
+                group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
+            {"member": True,
+             "admin": True})
-- 
cgit v1.2.3


From 610335cb3c3030cf39e91ad3232d468b388fc340 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 15 Oct 2021 08:51:46 +0300
Subject: Get a users access mask

If a user has several access roles, select the highest role.
---
 .../tests/unit/wqflask/test_resource_manager.py    | 59 ++++++++++++++++++++++
 wqflask/wqflask/resource_manager.py                | 48 ++++++++++++++++++
 2 files changed, 107 insertions(+)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_resource_manager.py b/wqflask/tests/unit/wqflask/test_resource_manager.py
index a27f40e1..b0b7e6a3 100644
--- a/wqflask/tests/unit/wqflask/test_resource_manager.py
+++ b/wqflask/tests/unit/wqflask/test_resource_manager.py
@@ -3,6 +3,9 @@ import unittest
 
 from unittest import mock
 from wqflask.resource_manager import get_user_membership
+from wqflask.resource_manager import get_user_access_roles
+from wqflask.resource_manager import DataRole
+from wqflask.resource_manager import AdminRole
 
 
 class TestGetUserMembership(unittest.TestCase):
@@ -49,3 +52,59 @@ class TestGetUserMembership(unittest.TestCase):
                 group_id="7fa95d07-0e2d-4bc5-b47c-448fdc1260b2"),
             {"member": True,
              "admin": True})
+
+
+class TestCheckUserAccessRole(unittest.TestCase):
+    """Test cases for `get_user_access_roles`"""
+
+    def setUp(self):
+        conn = mock.MagicMock()
+        conn.hget.return_value = (
+            '{"owner_id": "8ad942fe-490d-453e-bd37", '
+            '"default_mask": {"data": "no-access", '
+            '"metadata": "no-access", '
+            '"admin": "not-admin"}, '
+            '"group_masks": '
+            '{"7fa95d07-0e2d-4bc5-b47c-448fdc1260b2": '
+            '{"metadata": "edit", "data": "edit"}}, '
+            '"name": "_14329", "'
+            'data": {"dataset": 1, "trait": 14329}, '
+            '"type": "dataset-publish"}')
+
+        conn.hgetall.return_value = {
+            '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': (
+                '{"name": "editors", '
+                '"admins": ["8ad942fe-490d-453e-bd37-56f252e41604", "rand"], '
+                '"members": ["8ad942fe-490d-453e-bd37-56f252e41603", '
+                '"rand"], '
+                '"changed_timestamp": "Oct 06 2021 06:39PM", '
+                '"created_timestamp": "Oct 06 2021 06:39PM"}')}
+        self.conn = conn
+
+    def test_get_user_access_when_owner(self):
+        """Test that the right access roles are set"""
+        self.assertEqual(get_user_access_roles(
+            conn=self.conn,
+            resource_id="",  # Can be anything
+            user_id="8ad942fe-490d-453e-bd37"),
+                         {"data": DataRole.EDIT,
+                          "metadata": DataRole.EDIT,
+                          "admin": AdminRole.EDIT_ACCESS})
+
+    def test_get_user_access_default_mask(self):
+        self.assertEqual(get_user_access_roles(
+            conn=self.conn,
+            resource_id="",  # Can be anything
+            user_id=""),
+                         {"data": DataRole.NO_ACCESS,
+                          "metadata": DataRole.NO_ACCESS,
+                          "admin": AdminRole.NOT_ADMIN})
+
+    def test_get_user_access_group_mask(self):
+        self.assertEqual(get_user_access_roles(
+            conn=self.conn,
+            resource_id="",  # Can be anything
+            user_id="8ad942fe-490d-453e-bd37-56f252e41603"),
+                         {"data": DataRole.EDIT,
+                          "metadata": DataRole.EDIT,
+                          "admin": AdminRole.NOT_ADMIN})
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index 7f4718f0..a3a94f9e 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -63,4 +63,52 @@ def get_user_membership(conn: redis.Redis, user_id: str,
                 results["member"] = True
             break
     return results
+
+
+def get_user_access_roles(conn: redis.Redis,
+                          resource_id: str,
+                          user_id: str) -> Dict:
+    """Get the highest access roles for a given user
+
+    Args:
+      - conn: A redis connection with `decoded_responses == True`.
+      - resource_id: The unique id of a given resource.
+
+    Returns:
+      A dict indicating the highest access role the user has.
+    """
+    # This is the default access role
+    access_role = {
+        "data": [DataRole.NO_ACCESS],
+        "metadata": [DataRole.NO_ACCESS],
+        "admin": [AdminRole.NOT_ADMIN],
+    }
+    resource_info = json.loads(conn.hget('resources', resource_id))
+
+    # Check the resource's default mask
+    if default_mask := resource_info.get("default_mask"):
+        access_role["data"].append(DataRole(default_mask.get("data")))
+        access_role["metadata"].append(DataRole(default_mask.get("metadata")))
+        access_role["admin"].append(AdminRole(default_mask.get("admin")))
+
+    # Then check if the user is the owner Check with Zach and Rob if
+    # the owner, be default should, as the lowest access_roles, edit
+    # access
+    if resource_info.get("owner_id") == user_id:
+        access_role["data"].append(DataRole.EDIT)
+        access_role["metadata"].append(DataRole.EDIT)
+        access_role["admin"].append(AdminRole.EDIT_ACCESS)
+
+    # Check the group mask. If the user is in that group mask, use the
+    # access roles for that group
+    if group_masks := resource_info.get("group_masks"):
+        for group_id, roles in group_masks.items():
+            user_membership = get_user_membership(conn=conn,
+                                                  user_id=user_id,
+                                                  group_id=group_id)
+            if any(user_membership.values()):
+                access_role["data"].append(DataRole(roles.get("data")))
+                access_role["metadata"].append(
+                    DataRole(roles.get("metadata")))
+    return {k: max(v) for k, v in access_role.items()}
     admin_status = check_owner_or_admin(resource_id=resource_id)
-- 
cgit v1.2.3


From da86bc79798c05ec469d76f375741f306213e4d0 Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Fri, 15 Oct 2021 13:01:38 +0300
Subject: Replace "resource_id" with "resource_info" dict

This avoids calling Redis twice when fetching metadata about the
resource.
---
 .../tests/unit/wqflask/test_resource_manager.py    | 36 +++++++++++++---------
 wqflask/wqflask/resource_manager.py                | 10 +++---
 2 files changed, 28 insertions(+), 18 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_resource_manager.py b/wqflask/tests/unit/wqflask/test_resource_manager.py
index b0b7e6a3..9d5aaf0b 100644
--- a/wqflask/tests/unit/wqflask/test_resource_manager.py
+++ b/wqflask/tests/unit/wqflask/test_resource_manager.py
@@ -58,18 +58,26 @@ class TestCheckUserAccessRole(unittest.TestCase):
     """Test cases for `get_user_access_roles`"""
 
     def setUp(self):
+        self.resource_info = {
+            "owner_id": "8ad942fe-490d-453e-bd37",
+            "default_mask": {
+                "data": "no-access",
+                "metadata": "no-access",
+                "admin": "not-admin",
+            },
+            "group_masks": {
+                "7fa95d07-0e2d-4bc5-b47c-448fdc1260b2": {
+                    "metadata": "edit",
+                    "data": "edit",
+                }},
+            "name": "_14329",
+            "data": {
+                "dataset": 1,
+                "trait": 14329,
+            },
+            "type": "dataset-publish",
+            }
         conn = mock.MagicMock()
-        conn.hget.return_value = (
-            '{"owner_id": "8ad942fe-490d-453e-bd37", '
-            '"default_mask": {"data": "no-access", '
-            '"metadata": "no-access", '
-            '"admin": "not-admin"}, '
-            '"group_masks": '
-            '{"7fa95d07-0e2d-4bc5-b47c-448fdc1260b2": '
-            '{"metadata": "edit", "data": "edit"}}, '
-            '"name": "_14329", "'
-            'data": {"dataset": 1, "trait": 14329}, '
-            '"type": "dataset-publish"}')
 
         conn.hgetall.return_value = {
             '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': (
@@ -85,7 +93,7 @@ class TestCheckUserAccessRole(unittest.TestCase):
         """Test that the right access roles are set"""
         self.assertEqual(get_user_access_roles(
             conn=self.conn,
-            resource_id="",  # Can be anything
+            resource_info=self.resource_info,
             user_id="8ad942fe-490d-453e-bd37"),
                          {"data": DataRole.EDIT,
                           "metadata": DataRole.EDIT,
@@ -94,7 +102,7 @@ class TestCheckUserAccessRole(unittest.TestCase):
     def test_get_user_access_default_mask(self):
         self.assertEqual(get_user_access_roles(
             conn=self.conn,
-            resource_id="",  # Can be anything
+            resource_info=self.resource_info,
             user_id=""),
                          {"data": DataRole.NO_ACCESS,
                           "metadata": DataRole.NO_ACCESS,
@@ -103,7 +111,7 @@ class TestCheckUserAccessRole(unittest.TestCase):
     def test_get_user_access_group_mask(self):
         self.assertEqual(get_user_access_roles(
             conn=self.conn,
-            resource_id="",  # Can be anything
+            resource_info=self.resource_info,
             user_id="8ad942fe-490d-453e-bd37-56f252e41603"),
                          {"data": DataRole.EDIT,
                           "metadata": DataRole.EDIT,
diff --git a/wqflask/wqflask/resource_manager.py b/wqflask/wqflask/resource_manager.py
index a3a94f9e..57b99296 100644
--- a/wqflask/wqflask/resource_manager.py
+++ b/wqflask/wqflask/resource_manager.py
@@ -66,16 +66,19 @@ def get_user_membership(conn: redis.Redis, user_id: str,
 
 
 def get_user_access_roles(conn: redis.Redis,
-                          resource_id: str,
+                          resource_info: Dict,
                           user_id: str) -> Dict:
     """Get the highest access roles for a given user
 
     Args:
-      - conn: A redis connection with `decoded_responses == True`.
-      - resource_id: The unique id of a given resource.
+      - conn: A redis connection with the responses decoded.
+      - resource_info: A dict containing details(metadata) about a
+        given resource.
+      - user_id: The unique id of a given user.
 
     Returns:
       A dict indicating the highest access role the user has.
+
     """
     # This is the default access role
     access_role = {
@@ -83,7 +86,6 @@ def get_user_access_roles(conn: redis.Redis,
         "metadata": [DataRole.NO_ACCESS],
         "admin": [AdminRole.NOT_ADMIN],
     }
-    resource_info = json.loads(conn.hget('resources', resource_id))
 
     # Check the resource's default mask
     if default_mask := resource_info.get("default_mask"):
-- 
cgit v1.2.3


From fbffb2e4f7538cc34332f37064d4b67cd52588fb Mon Sep 17 00:00:00 2001
From: BonfaceKilz
Date: Wed, 20 Oct 2021 13:43:57 +0300
Subject: Update failing tests when testing `get_user_access_roles`

---
 .../tests/unit/wqflask/test_resource_manager.py    | 82 ++++++++--------------
 1 file changed, 29 insertions(+), 53 deletions(-)

(limited to 'wqflask/tests')

diff --git a/wqflask/tests/unit/wqflask/test_resource_manager.py b/wqflask/tests/unit/wqflask/test_resource_manager.py
index 9d5aaf0b..01fb2021 100644
--- a/wqflask/tests/unit/wqflask/test_resource_manager.py
+++ b/wqflask/tests/unit/wqflask/test_resource_manager.py
@@ -1,4 +1,5 @@
 """Test cases for wqflask/resource_manager.py"""
+import json
 import unittest
 
 from unittest import mock
@@ -57,62 +58,37 @@ class TestGetUserMembership(unittest.TestCase):
 class TestCheckUserAccessRole(unittest.TestCase):
     """Test cases for `get_user_access_roles`"""
 
-    def setUp(self):
-        self.resource_info = {
-            "owner_id": "8ad942fe-490d-453e-bd37",
-            "default_mask": {
-                "data": "no-access",
-                "metadata": "no-access",
-                "admin": "not-admin",
-            },
-            "group_masks": {
-                "7fa95d07-0e2d-4bc5-b47c-448fdc1260b2": {
-                    "metadata": "edit",
-                    "data": "edit",
-                }},
-            "name": "_14329",
-            "data": {
-                "dataset": 1,
-                "trait": 14329,
-            },
-            "type": "dataset-publish",
-            }
-        conn = mock.MagicMock()
-
-        conn.hgetall.return_value = {
-            '7fa95d07-0e2d-4bc5-b47c-448fdc1260b2': (
-                '{"name": "editors", '
-                '"admins": ["8ad942fe-490d-453e-bd37-56f252e41604", "rand"], '
-                '"members": ["8ad942fe-490d-453e-bd37-56f252e41603", '
-                '"rand"], '
-                '"changed_timestamp": "Oct 06 2021 06:39PM", '
-                '"created_timestamp": "Oct 06 2021 06:39PM"}')}
-        self.conn = conn
-
-    def test_get_user_access_when_owner(self):
+    @mock.patch("wqflask.resource_manager.requests.get")
+    def test_edit_access(self, requests_mock):
         """Test that the right access roles are set"""
+        response = mock.PropertyMock(return_value=json.dumps(
+            {
+                'data': ['no-access', 'view', 'edit', ],
+                'metadata': ['no-access', 'view', 'edit', ],
+                'admin': ['not-admin', 'edit-access', ],
+            }
+        ))
+        type(requests_mock.return_value).content = response
         self.assertEqual(get_user_access_roles(
-            conn=self.conn,
-            resource_info=self.resource_info,
+            resource_id="0196d92e1665091f202f",
             user_id="8ad942fe-490d-453e-bd37"),
-                         {"data": DataRole.EDIT,
-                          "metadata": DataRole.EDIT,
-                          "admin": AdminRole.EDIT_ACCESS})
+            {"data": DataRole.EDIT,
+             "metadata": DataRole.EDIT,
+             "admin": AdminRole.EDIT_ACCESS})
 
-    def test_get_user_access_default_mask(self):
+    @mock.patch("wqflask.resource_manager.requests.get")
+    def test_no_access(self, requests_mock):
+        response = mock.PropertyMock(return_value=json.dumps(
+            {
+                'data': ['no-access', ],
+                'metadata': ['no-access', ],
+                'admin': ['not-admin', ],
+            }
+        ))
+        type(requests_mock.return_value).content = response
         self.assertEqual(get_user_access_roles(
-            conn=self.conn,
-            resource_info=self.resource_info,
+            resource_id="0196d92e1665091f202f",
             user_id=""),
-                         {"data": DataRole.NO_ACCESS,
-                          "metadata": DataRole.NO_ACCESS,
-                          "admin": AdminRole.NOT_ADMIN})
-
-    def test_get_user_access_group_mask(self):
-        self.assertEqual(get_user_access_roles(
-            conn=self.conn,
-            resource_info=self.resource_info,
-            user_id="8ad942fe-490d-453e-bd37-56f252e41603"),
-                         {"data": DataRole.EDIT,
-                          "metadata": DataRole.EDIT,
-                          "admin": AdminRole.NOT_ADMIN})
+            {"data": DataRole.NO_ACCESS,
+             "metadata": DataRole.NO_ACCESS,
+             "admin": AdminRole.NOT_ADMIN})
-- 
cgit v1.2.3