Merge branch 'build/python3-migration' of github.com:BonfaceKilz/genenetwork2 into build/python3-migration

20 files changed, 483 insertions, 456 deletions

diff --git a/wqflask/utility/Plot.py b/wqflask/utility/Plot.py
index b9b71129..61f408d2 100644
--- a/wqflask/utility/Plot.py
+++ b/wqflask/utility/Plot.py
@@ -24,15 +24,13 @@
 #
 # Last updated by GeneNetwork Core Team 2010/10/20
 
-from __future__ import print_function
-
 from PIL import ImageColor
 from PIL import ImageDraw
 from PIL import ImageFont
 
 from math import *
 
-import corestats
+import utility.corestats as corestats
 from base import webqtlConfig
 from utility.pillow_utils import draw_rotated_text
 import utility.logger
@@ -54,7 +52,7 @@ def cformat(d, rank=0):
     strD = "%2.6f" % d
 
     if rank == 0:
-        while strD[-1] in ('0','.'):
+        while strD[-1] in ('0', '.'):
             if strD[-1] == '0' and strD[-2] == '.' and len(strD) <= 4:
                 break
             elif strD[-1] == '.':
@@ -82,7 +80,7 @@ def frange(start, end=None, inc=1.0):
     # Need to adjust the count. AFAICT, it always comes up one short.
         count += 1
     L = [start] * count
-    for i in xrange(1, count):
+    for i in range(1, count):
         L[i] = start + i * inc
     return L
 
@@ -93,7 +91,7 @@ def find_outliers(vals):
     >>> find_outliers([3.504, 5.234, 6.123, 7.234, 3.542, 5.341, 7.852, 4.555, 12.537])
     (11.252500000000001, 0.5364999999999993)
 
-    >>> >>> find_outliers([9,12,15,17,31,50,7,5,6,8])
+    >>> find_outliers([9,12,15,17,31,50,7,5,6,8])
     (32.0, -8.0)
 
     If there are no vals, returns None for the upper and lower bounds,
@@ -158,7 +156,7 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
        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)
@@ -170,7 +168,7 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
            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
@@ -179,81 +177,81 @@ def plotBar(canvas, data, barColor=BLUE, axesColor=BLACK, labelColor=BLACK, XLab
     )
 
     #draw scale
-    scaleFont=ImageFont.truetype(font=COUR_FILE,size=11)
+    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)
+           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)
+       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
 
     #draw label
-    labelFont=ImageFont.truetype(font=TAHOMA_FILE,size=17)
+    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,
+               plotWidth-im_drawer.textsize(XLabel, font=labelFont)[0])/2.0,
                yTopOffset+plotHeight+yBottomOffset-10),
-           font=labelFont,fill=labelColor)
+           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),
+                                      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,
+               title, font=labelFont)[0])/2.0,
                20),
-           font=labelFont,fill=labelColor)
+           font=labelFont, fill=labelColor)
 
 # This function determines the scale of the plot
-def detScaleOld(min,max):
+def detScaleOld(min, max):
     if min>=max:
         return None
     elif min == -1.0 and max == 1.0:
-        return [-1.2,1.2,12]
+        return [-1.2, 1.2, 12]
     else:
         a=max-min
         b=floor(log10(a))
-        c=pow(10.0,b)
+        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)]
+        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]
+        return [-1.2, 1.2, 12]
     else:
         a=max-min
         if max != 0:
@@ -265,7 +263,7 @@ def detScale(min=0,max=0):
                 min -= 0.1*a
         a=max-min
         b=floor(log10(a))
-        c=pow(10.0,b)
+        c=pow(10.0, b)
         low=c*floor(min/c)
         high=c*ceil(max/c)
         n = round((high-low)/c)
@@ -283,7 +281,7 @@ def detScale(min=0,max=0):
             high=c*ceil(max/c)
             n = round((high-low)/c)
 
-        return [low,high,n]
+        return [low, high, n]
 
 def bluefunc(x):
     return 1.0 / (1.0 + exp(-10*(x-0.6)))
@@ -292,7 +290,7 @@ 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)
+    return 1 - pow(redfunc(x+0.2), 2) - bluefunc(x-0.3)
 
 def colorSpectrum(n=100):
     multiple = 10
diff --git a/wqflask/utility/__init__.py b/wqflask/utility/__init__.py
index d9856eed..204ff59a 100644
--- a/wqflask/utility/__init__.py
+++ b/wqflask/utility/__init__.py
@@ -19,7 +19,7 @@ class Struct(object):
     '''
 
     def __init__(self, obj):
-        for k, v in obj.iteritems():
+        for k, v in list(obj.items()):
             if isinstance(v, dict):
                 setattr(self, k, Struct(v))
             else:
@@ -30,6 +30,6 @@ class Struct(object):
 
     def __repr__(self):
         return '{%s}' % str(', '.join('%s : %s' % (k, repr(v)) for
-            (k, v) in self.__dict__.iteritems()))
+            (k, v) in list(self.__dict__.items())))
 
 
diff --git a/wqflask/utility/after.py b/wqflask/utility/after.py
index b628a0a4..06091ecb 100644
--- a/wqflask/utility/after.py
+++ b/wqflask/utility/after.py
@@ -1,5 +1,3 @@
-from __future__ import print_function, division, absolute_import
-
 """
 See: http://flask.pocoo.org/docs/patterns/deferredcallbacks/#deferred-callbacks
 
@@ -13,4 +11,4 @@ def after_this_request(f):
     if not hasattr(g, 'after_request_callbacks'):
         g.after_request_callbacks = []
     g.after_request_callbacks.append(f)
-    return f
\ No newline at end of file
+    return f
diff --git a/wqflask/utility/authentication_tools.py b/wqflask/utility/authentication_tools.py
index 239b08e3..ce0c0749 100644
--- a/wqflask/utility/authentication_tools.py
+++ b/wqflask/utility/authentication_tools.py
@@ -1,34 +1,37 @@
-from __future__ import absolute_import, print_function, division
-import logging
-from flask import Flask, g, redirect, url_for
-
 import json
 import requests
 
-from base import data_set, webqtlConfig
-
-from utility import hmac
-from utility.redis_tools import get_redis_conn, get_resource_info, get_resource_id, add_resource
-Redis = get_redis_conn()
+from flask import g
+from base import webqtlConfig
 
 
-logger = logging.getLogger(__name__)
+from utility.redis_tools import (get_redis_conn,
+                                 get_resource_info,
+                                 get_resource_id,
+                                 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":
         return webqtlConfig.DEFAULT_PRIVILEGES
 
     resource_id = get_resource_id(dataset, trait_id)
 
-    if resource_id:  # ZS: This should never be false, but it's technically possible if a non-Temp dataset somehow had a type other than Publish/ProbeSet/Geno
+    # ZS: This should never be false, but it's technically possible if
+    # a non-Temp dataset somehow had a type other than
+    # Publish/ProbeSet/Geno
+    if resource_id:
         resource_info = get_resource_info(resource_id)
-        if not resource_info:  # ZS: If resource isn't already in redis, add it with default privileges
+
+        # ZS: If resource isn't already in redis, add it with default
+        # privileges
+        if not resource_info:
             resource_info = add_new_resource(dataset, trait_id)
 
-    # ZS: Check if super-user - we should probably come up with some way to integrate this into the proxy
+    # ZS: Check if super-user - we should probably come up with some
+    # way to integrate this into the proxy
     if g.user_session.user_id in Redis.smembers("super_users"):
         return webqtlConfig.SUPER_PRIVILEGES
 
@@ -52,7 +55,10 @@ def add_new_resource(dataset, trait_id=None):
     }
 
     if dataset.type == "Publish":
-        resource_ob['name'] = get_group_code(dataset) + "_" + str(trait_id)
+        group_code = get_group_code(dataset)
+        if group_code is None:
+            group_code = ""
+        resource_ob['name'] = group_code + "_" + str(trait_id)
         resource_ob['data'] = {
             'dataset': dataset.id,
             'trait': trait_id
@@ -77,8 +83,9 @@ def add_new_resource(dataset, trait_id=None):
 
 
 def get_group_code(dataset):
-    results = g.db.execute("SELECT InbredSetCode from InbredSet where Name='{}'".format(
-        dataset.group.name)).fetchone()
+    results = g.db.execute(
+        "SELECT InbredSetCode from InbredSet where Name='{}'".format(
+            dataset.group.name)).fetchone()
     if results[0]:
         return results[0]
     else:
diff --git a/wqflask/utility/benchmark.py b/wqflask/utility/benchmark.py
index 8f1c916b..ea5a0ab6 100644
--- a/wqflask/utility/benchmark.py
+++ b/wqflask/utility/benchmark.py
@@ -1,5 +1,3 @@
-from __future__ import print_function, division, absolute_import
-
 import collections
 import inspect
 import time
@@ -38,9 +36,9 @@ class Bench(object):
 
     @classmethod
     def report(cls):
-        total_time = sum((time_taken for time_taken in cls.entries.itervalues()))
+        total_time = sum((time_taken for time_taken in list(cls.entries.values())))
         print("\nTiming report\n")
-        for name, time_taken in cls.entries.iteritems():
+        for name, time_taken in list(cls.entries.items()):
             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 d91b9bf4..9a7db102 100644
--- a/wqflask/utility/chunks.py
+++ b/wqflask/utility/chunks.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, print_function, division
-
 import math
 import time
 
diff --git a/wqflask/utility/db_tools.py b/wqflask/utility/db_tools.py
index 4034f39c..6e19778f 100644
--- a/wqflask/utility/db_tools.py
+++ b/wqflask/utility/db_tools.py
@@ -1,6 +1,5 @@
-from __future__ import absolute_import, print_function, division
+from MySQLdb import escape_string as escape_
 
-from MySQLdb import escape_string as escape
 
 def create_in_clause(items):
     """Create an in clause for mysql"""
@@ -8,8 +7,11 @@ def create_in_clause(items):
     in_clause = '( {} )'.format(in_clause)
     return in_clause
 
+
 def mescape(*items):
     """Multiple escape"""
-    escaped = [escape(str(item)) for item in items]
-    #print("escaped is:", escaped)
-    return escaped
+    return [escape_(str(item)).decode('utf8') for item in items]
+
+
+def escape(string_):
+    return escape_(string_).decode('utf8')
diff --git a/wqflask/utility/elasticsearch_tools.py b/wqflask/utility/elasticsearch_tools.py
index 15cdd0bc..a5580811 100644
--- a/wqflask/utility/elasticsearch_tools.py
+++ b/wqflask/utility/elasticsearch_tools.py
@@ -59,7 +59,7 @@ def get_elasticsearch_connection(for_user=True):
     try:
         assert(ELASTICSEARCH_HOST)
         assert(ELASTICSEARCH_PORT)
-        logger.info("ES HOST",ELASTICSEARCH_HOST)
+        logger.info("ES HOST", ELASTICSEARCH_HOST)
 
         es = Elasticsearch([{
             "host": ELASTICSEARCH_HOST, "port": ELASTICSEARCH_PORT
diff --git a/wqflask/utility/gen_geno_ob.py b/wqflask/utility/gen_geno_ob.py
index 23b0b650..81085ffe 100644
--- a/wqflask/utility/gen_geno_ob.py
+++ b/wqflask/utility/gen_geno_ob.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, division, print_function
-
 import utility.logger
 logger = utility.logger.getLogger(__name__ )
 
@@ -175,7 +173,7 @@ class Locus(object):
                 start_pos = 3
 
             for allele in marker_row[start_pos:]:
-                if allele in geno_table.keys():
+                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
-                    self.genotype.append("U")
\ No newline at end of file
+                    self.genotype.append("U")
diff --git a/wqflask/utility/genofile_parser.py b/wqflask/utility/genofile_parser.py
index af306731..0b736176 100644
--- a/wqflask/utility/genofile_parser.py
+++ b/wqflask/utility/genofile_parser.py
@@ -1,7 +1,6 @@
 # CTL analysis for GN2
 # Author / Maintainer: Danny Arends <Danny.Arends@gmail.com>
 
-from __future__ import print_function, division, absolute_import
 import sys
 import os
 import glob
diff --git a/wqflask/utility/helper_functions.py b/wqflask/utility/helper_functions.py
index 9ce809b6..7eb7f013 100644
--- a/wqflask/utility/helper_functions.py
+++ b/wqflask/utility/helper_functions.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, print_function, division
-
 from base import data_set
 from base.trait import create_trait
 from base.species import TheSpecies
@@ -13,7 +11,7 @@ logger = logging.getLogger(__name__ )
 
 def get_species_dataset_trait(self, start_vars):
     #assert type(read_genotype) == type(bool()), "Expecting boolean value for read_genotype"
-    if "temp_trait" in start_vars.keys():
+    if "temp_trait" in list(start_vars.keys()):
       if start_vars['temp_trait'] == "True":
         self.dataset = data_set.create_dataset(dataset_name = "Temp", dataset_type = "Temp", group_name = start_vars['group'])
       else:
@@ -34,7 +32,7 @@ def get_species_dataset_trait(self, start_vars):
     #self.genotype = self.dataset.group.genotype
 
 def get_trait_db_obs(self, trait_db_list):
-    if isinstance(trait_db_list, basestring):
+    if isinstance(trait_db_list, str):
         trait_db_list = trait_db_list.split(",")
 
     self.trait_list = []
diff --git a/wqflask/utility/hmac.py b/wqflask/utility/hmac.py
index fd75803e..6623f69a 100644
--- a/wqflask/utility/hmac.py
+++ b/wqflask/utility/hmac.py
@@ -1,5 +1,3 @@
-from __future__ import print_function, division, absolute_import
-
 import hmac
 import hashlib
 
@@ -12,7 +10,9 @@ def hmac_creation(stringy):
     """Helper function to create the actual hmac"""
 
     secret = app.config['SECRET_HMAC_CODE']
-    hmaced = hmac.new(secret, stringy, hashlib.sha1)
+    hmaced = hmac.new(bytearray(secret, "utf-8"),
+                      bytearray(stringy, "utf-8"),
+                      hashlib.sha1)
     hm = hmaced.hexdigest()
     # ZS: Leaving the below comment here to ask Pjotr about
     # "Conventional wisdom is that you don't lose much in terms of security if you throw away up to half of the output."
diff --git a/wqflask/utility/logger.py b/wqflask/utility/logger.py
index 510b1041..e904eb94 100644
--- a/wqflask/utility/logger.py
+++ b/wqflask/utility/logger.py
@@ -42,10 +42,10 @@ class GNLogger:
 
     """
 
-    def __init__(self,name):
+    def __init__(self, name):
         self.logger = logging.getLogger(name)
 
-    def setLevel(self,value):
+    def setLevel(self, value):
         """Set the undelying log level"""
         self.logger.setLevel(value)
 
@@ -54,7 +54,7 @@ class GNLogger:
 level=num to filter on LOG_LEVEL_DEBUG.
 
         """
-        self.collect(self.logger.debug,*args)
+        self.collect(self.logger.debug, *args)
 
     def debug20(self,*args):
         """Call logging.debug for multiple args. Use level=num to filter on
@@ -63,15 +63,15 @@ LOG_LEVEL_DEBUG (NYI).
         """
         if level <= LOG_LEVEL_DEBUG:
             if self.logger.getEffectiveLevel() < 20:
-                self.collect(self.logger.debug,*args)
+                self.collect(self.logger.debug, *args)
 
     def info(self,*args):
         """Call logging.info for multiple args"""
-        self.collect(self.logger.info,*args)
+        self.collect(self.logger.info, *args)
 
     def warning(self,*args):
         """Call logging.warning for multiple args"""
-        self.collect(self.logger.warning,*args)
+        self.collect(self.logger.warning, *args)
         # self.logger.warning(self.collect(*args))
 
     def error(self,*args):
@@ -79,13 +79,13 @@ LOG_LEVEL_DEBUG (NYI).
         now = datetime.datetime.utcnow()
         time_str = now.strftime('%H:%M:%S UTC %Y%m%d')
         l = [time_str]+list(args)
-        self.collect(self.logger.error,*l)
+        self.collect(self.logger.error, *l)
 
     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)
+            self.collectf(self.logger.debug, *args)
 
     def debugf(self,level=0,*args):
         """Call logging.debug for multiple args lazily and handle
@@ -95,15 +95,15 @@ LOG_LEVEL_DEBUG (NYI).
         # only evaluate function when logging
         if level <= LOG_LEVEL_DEBUG:
             if self.logger.getEffectiveLevel() < 20:
-                self.collectf(self.logger.debug,*args)
+                self.collectf(self.logger.debug, *args)
 
     def sql(self, sqlcommand, fun = None):
         """Log SQL command, optionally invoking a timed fun"""
         if LOG_SQL:
             caller = stack()[1][3]
-            if caller in ['fetchone','fetch1','fetchall']:
+            if caller in ['fetchone', 'fetch1', 'fetchall']:
                 caller = stack()[2][3]
-            self.info(caller,sqlcommand)
+            self.info(caller, sqlcommand)
         if fun:
             result = fun(sqlcommand)
             if LOG_SQL:
@@ -119,7 +119,7 @@ LOG_LEVEL_DEBUG (NYI).
             if isinstance(a, str):
                 out = out + a
             else:
-                out = out + pf(a,width=160)
+                out = out + pf(a, width=160)
         fun(out)
 
     def collectf(self,fun,*args):
@@ -134,7 +134,7 @@ LOG_LEVEL_DEBUG (NYI).
                     if isinstance(a, str):
                         out = out + a
                     else:
-                        out = out + pf(a,width=160)
+                        out = out + pf(a, width=160)
         fun(out)
 
 # Get the module logger. You can override log levels at the
diff --git a/wqflask/utility/pillow_utils.py b/wqflask/utility/pillow_utils.py
index 0c2ce7af..c486abba 100644
--- a/wqflask/utility/pillow_utils.py
+++ b/wqflask/utility/pillow_utils.py
@@ -12,9 +12,9 @@ WHITE = ImageColor.getrgb("white")
 def draw_rotated_text(canvas, text, font, xy, fill=BLACK, angle=-90):
     # type: (Image, str, ImageFont, tuple, ImageColor, int)
     """Utility function draw rotated text"""
-    tmp_img = Image.new("RGBA", font.getsize(text), color=(0,0,0,0))
+    tmp_img = Image.new("RGBA", font.getsize(text), color=(0, 0, 0, 0))
     draw_text = ImageDraw.Draw(tmp_img)
-    draw_text.text(text=text, xy=(0,0), font=font, fill=fill)
+    draw_text.text(text=text, xy=(0, 0), font=font, fill=fill)
     tmp_img2 = tmp_img.rotate(angle, expand=1)
     tmp_img2.save("/{0}/{1}.png".format(TEMPDIR, text), format="png")
     canvas.paste(im=tmp_img2, box=tuple([int(i) for i in xy]))
diff --git a/wqflask/utility/redis_tools.py b/wqflask/utility/redis_tools.py
index ef02268e..d855a7fa 100644
--- a/wqflask/utility/redis_tools.py
+++ b/wqflask/utility/redis_tools.py
@@ -1,5 +1,3 @@
-from __future__ import print_function, division, absolute_import
-
 import uuid
 import simplejson as json
 import datetime
diff --git a/wqflask/utility/startup_config.py b/wqflask/utility/startup_config.py
index 817284dd..f1aaebb6 100644
--- a/wqflask/utility/startup_config.py
+++ b/wqflask/utility/startup_config.py
@@ -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:
@@ -36,4 +36,4 @@ 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 db13b9d1..b92cc2d1 100644
--- a/wqflask/utility/svg.py
+++ b/wqflask/utility/svg.py
@@ -25,54 +25,56 @@
 # Last updated by GeneNetwork Core Team 2010/10/20
 
 #!/usr/bin/env python
-##Copyright (c) 2002, Fedor Baart & Hans de Wit (Stichting Farmaceutische Kengetallen)
-##All rights reserved.
+# Copyright (c) 2002, Fedor Baart & Hans de Wit (Stichting Farmaceutische Kengetallen)
+# All rights reserved.
 ##
-##Redistribution and use in source and binary forms, with or without modification,
-##are permitted provided that the following conditions are met:
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
 ##
-##Redistributions of source code must retain the above copyright notice, this
-##list of conditions and the following disclaimer.
+# Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
 ##
-##Redistributions in binary form must reproduce the above copyright notice,
-##this list of conditions and the following disclaimer in the documentation and/or
-##other materials provided with the distribution.
+# Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
 ##
-##Neither the name of the Stichting Farmaceutische Kengetallen nor the names of
-##its contributors may be used to endorse or promote products derived from this
-##software without specific prior written permission.
+# Neither the name of the Stichting Farmaceutische Kengetallen nor the names of
+# its contributors may be used to endorse or promote products derived from this
+# software without specific prior written permission.
 ##
-##THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-##AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-##IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-##DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
-##FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-##DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-##SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-##CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-##OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-##OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Thanks to Gerald Rosennfellner for his help and useful comments.
 
-##Thanks to Gerald Rosennfellner for his help and useful comments.
-
-__doc__="""Use SVGdraw to generate your SVGdrawings.
+import sys
+import exceptions
+__doc__ = """Use SVGdraw to generate your SVGdrawings.
 
 SVGdraw uses an object model drawing and a method toXML to create SVG graphics
 by using easy to use classes and methods usualy you start by creating a drawing eg
 
     d=drawing()
-    #then you create a SVG root element
+    # then you create a SVG root element
     s=svg()
-    #then you add some elements eg a circle and add it to the svg root element
+    # then you add some elements eg a circle and add it to the svg root element
     c=circle()
-    #you can supply attributes by using named arguments.
+    # you can supply attributes by using named arguments.
     c=circle(fill='red',stroke='blue')
-    #or by updating the attributes attribute:
+    # or by updating the attributes attribute:
     c.attributes['stroke-width']=1
     s.addElement(c)
-    #then you add the svg root element to the drawing
+    # then you add the svg root element to the drawing
     d.setSVG(s)
-    #and finaly you xmlify the drawing
+    # and finaly you xmlify the drawing
     d.toXml()
 
 
@@ -82,7 +84,7 @@ This module was created using the SVG specification of www.w3c.org and the
 O'Reilly (www.oreilly.com) python books as information sources. A svg viewer
 is available from www.adobe.com"""
 
-__version__="1.0"
+__version__ = "1.0"
 
 # there are two possibilities to generate svg:
 # via a dom implementation and directly using <element>text</element> strings
@@ -93,33 +95,34 @@ __version__="1.0"
 # Note that PyXML is required for using the dom implementation.
 # It is also possible to use the standard minidom. But I didn't try that one.
 # Anyway the text based approach is about 60 times faster than using the full dom implementation.
-use_dom_implementation=0
+use_dom_implementation = 0
 
 
-import exceptions
-if use_dom_implementation<>0:
+if use_dom_implementation != 0:
     try:
         from xml.dom import implementation
         from xml.dom.ext import PrettyPrint
     except:
-        raise exceptions.ImportError, "PyXML is required for using the dom implementation"
-#The implementation is used for the creating the XML document.
-#The prettyprint module is used for converting the xml document object to a xml file
+        raise exceptions.ImportError(
+            "PyXML is required for using the dom implementation")
+# The implementation is used for the creating the XML document.
+# The prettyprint module is used for converting the xml document object to a xml file
+
+assert sys.version_info[0] >= 2
+if sys.version_info[1] < 2:
+    True = 1
+    False = 0
+    file = open
+
+sys.setrecursionlimit = 50
+# The recursion limit is set conservative so mistakes like s=svg() s.addElement(s)
+# won't eat up too much processor time.
+
+# the following code is pasted form xml.sax.saxutils
+# it makes it possible to run the code without the xml sax package installed
+# To make it possible to have <rubbish> in your text elements, it is necessary to escape the texts
+
 
-import sys
-assert sys.version_info[0]>=2
-if sys.version_info[1]<2:
-    True=1
-    False=0
-    file=open
-
-sys.setrecursionlimit=50
-#The recursion limit is set conservative so mistakes like s=svg() s.addElement(s)
-#won't eat up too much processor time.
-
-#the following code is pasted form xml.sax.saxutils
-#it makes it possible to run the code without the xml sax package installed
-#To make it possible to have <rubbish> in your text elements, it is necessary to escape the texts
 def _escape(data, entities={}):
     """Escape &, <, and > in a string of data.
 
@@ -127,13 +130,14 @@ def _escape(data, entities={}):
     the optional entities parameter.  The keys and values must all be
     strings; each key will be replaced with its corresponding value.
     """
-    #data = data.replace("&", "&amp;")
+    # data = data.replace("&", "&amp;")
     data = data.replace("<", "&lt;")
     data = data.replace(">", "&gt;")
-    for chars, entity in entities.items():
+    for chars, entity in list(entities.items()):
         data = data.replace(chars, entity)
     return data
 
+
 def _quoteattr(data, entities={}):
     """Escape and quote an attribute value.
 
@@ -156,96 +160,121 @@ def _quoteattr(data, entities={}):
     return data
 
 
-
 def _xypointlist(a):
     """formats a list of xy pairs"""
-    s=''
-    for e in a: #this could be done more elegant
-        s+=str(e)[1:-1] +'  '
+    s = ''
+    for e in a:  # this could be done more elegant
+        s += str(e)[1:-1] + '  '
     return s
 
+
 def _viewboxlist(a):
     """formats a tuple"""
-    s=''
+    s = ''
     for e in a:
-        s+=str(e)+' '
+        s += str(e)+' '
     return s
 
+
 def _pointlist(a):
     """formats a list of numbers"""
     return str(a)[1:-1]
 
+
 class pathdata:
     """class used to create a pathdata object which can be used for a path.
     although most methods are pretty straightforward it might be useful to look at the SVG specification."""
-    #I didn't test the methods below.
-    def __init__(self,x=None,y=None):
-        self.path=[]
+    # I didn't test the methods below.
+
+    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))
+
     def closepath(self):
         """ends the path"""
         self.path.append('z')
-    def move(self,x,y):
+
+    def move(self, x, y):
         """move to absolute"""
         self.path.append('M '+str(x)+' '+str(y))
-    def relmove(self,x,y):
+
+    def relmove(self, x, y):
         """move to relative"""
         self.path.append('m '+str(x)+' '+str(y))
-    def line(self,x,y):
+
+    def line(self, x, y):
         """line to absolute"""
         self.path.append('L '+str(x)+' '+str(y))
-    def relline(self,x,y):
+
+    def relline(self, x, y):
         """line to relative"""
         self.path.append('l '+str(x)+' '+str(y))
-    def hline(self,x):
+
+    def hline(self, x):
         """horizontal line to absolute"""
         self.path.append('H'+str(x))
-    def relhline(self,x):
+
+    def relhline(self, x):
         """horizontal line to relative"""
         self.path.append('h'+str(x))
-    def vline(self,y):
+
+    def vline(self, y):
         """verical line to absolute"""
         self.path.append('V'+str(y))
-    def relvline(self,y):
+
+    def relvline(self, y):
         """vertical line to relative"""
         self.path.append('v'+str(y))
-    def bezier(self,x1,y1,x2,y2,x,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))
-    def relbezier(self,x1,y1,x2,y2,x,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))
-    def smbezier(self,x2,y2,x,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))
-    def relsmbezier(self,x2,y2,x,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))
-    def qbezier(self,x1,y1,x,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))
-    def relqbezier(self,x1,y1,x,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))
-    def smqbezier(self,x,y):
+
+    def smqbezier(self, x, y):
         """smooth quadratic bezier to xy absolut"""
         self.path.append('T'+str(x)+','+str(y))
-    def relsmqbezier(self,x,y):
+
+    def relsmqbezier(self, x, y):
         """smooth quadratic bezier to xy relative"""
         self.path.append('t'+str(x)+','+str(y))
-    def ellarc(self,rx,ry,xrot,laf,sf,x,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))
-    def relellarc(self,rx,ry,xrot,laf,sf,x,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)
 
 
-
-
 class SVGelement:
     """SVGelement(type,attributes,elements,text,namespace,**args)
     Creates a arbitrary svg element and is intended to be subclassed not used on its own.
@@ -256,52 +285,56 @@ class SVGelement:
     namespace. Note the elements==None, if elements = None:self.elements=[] construction.
     This is done because if you default to elements=[] every object has a reference
     to the same empty list."""
-    def __init__(self,type='',attributes=None,elements=None,text='',namespace='',cdata=None, **args):
-        self.type=type
-        if attributes==None:
-            self.attributes={}
+
+    def __init__(self, type='', attributes=None, elements=None, text='', namespace='', cdata=None, **args):
+        self.type = type
+        if attributes == None:
+            self.attributes = {}
         else:
-            self.attributes=attributes
-        if elements==None:
-            self.elements=[]
+            self.attributes = attributes
+        if elements == None:
+            self.elements = []
         else:
-            self.elements=elements
-        self.text=text
-        self.namespace=namespace
-        self.cdata=cdata
-        for arg in args.keys():
+            self.elements = elements
+        self.text = text
+        self.namespace = namespace
+        self.cdata = cdata
+        for arg in list(args.keys()):
             arg2 = arg.replace("__", ":")
             arg2 = arg2.replace("_", "-")
-            self.attributes[arg2]=args[arg]
-    def addElement(self,SVGelement):
+            self.attributes[arg2] = args[arg]
+
+    def addElement(self, SVGelement):
         """adds an element to a SVGelement
 
         SVGelement.addElement(SVGelement)
         """
         self.elements.append(SVGelement)
 
-    def toXml(self,level,f):
+    def toXml(self, level, f):
         f.write('\t'*level)
         f.write('<'+self.type)
-        for attkey in self.attributes.keys():
-            f.write(' '+_escape(str(attkey))+'='+_quoteattr(str(self.attributes[attkey])))
+        for attkey in list(self.attributes.keys()):
+            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:
             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[')
             for line in self.cdata.splitlines():
                 f.write('\n'+'\t'*(level+2)+line)
             f.write('\n'+'\t'*(level+1)+']]>\n')
         if self.text:
-            if type(self.text)==type(''): #If the text is only 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
+            else:  # If the text is a spannedtext class
                 f.write(str(self.text))
         if self.elements:
             f.write('\t'*level+'</'+self.type+'>\n')
@@ -312,6 +345,7 @@ class SVGelement:
         else:
             f.write('/>\n')
 
+
 class tspan(SVGelement):
     """ts=tspan(text='',**args)
 
@@ -323,19 +357,22 @@ class tspan(SVGelement):
     st.addtspan(ts)
     t=text(3,5,st)
     """
-    def __init__(self,text=None,**args):
-        SVGelement.__init__(self,'tspan',**args)
-        if self.text<>None:
-            self.text=text
+
+    def __init__(self, text=None, **args):
+        SVGelement.__init__(self, 'tspan', **args)
+        if self.text != None:
+            self.text = text
+
     def __repr__(self):
-        s="<tspan"
-        for key,value in self.attributes.items():
-            s+= ' %s="%s"' % (key,value)
-        s+='>'
-        s+=self.text
-        s+='</tspan>'
+        s = "<tspan"
+        for key, value in list(self.attributes.items()):
+            s += ' %s="%s"' % (key, value)
+        s += '>'
+        s += self.text
+        s += '</tspan>'
         return s
 
+
 class tref(SVGelement):
     """tr=tref(link='',**args)
 
@@ -346,16 +383,19 @@ class tref(SVGelement):
     st.addtref(tr)
     t=text(3,5,st)
     """
-    def __init__(self,link,**args):
-        SVGelement.__init__(self,'tref',{'xlink:href':link},**args)
+
+    def __init__(self, link, **args):
+        SVGelement.__init__(self, 'tref', {'xlink:href': link}, **args)
+
     def __repr__(self):
-        s="<tref"
+        s = "<tref"
 
-        for key,value in self.attributes.items():
-            s+= ' %s="%s"' % (key,value)
-        s+='/>'
+        for key, value in list(self.attributes.items()):
+            s += ' %s="%s"' % (key, value)
+        s += '/>'
         return s
 
+
 class spannedtext:
     """st=spannedtext(textlist=[])
 
@@ -374,46 +414,49 @@ class spannedtext:
     st.addtext('This text is not bold')
     t=text(3,5,st)
     """
-    def __init__(self,textlist=None):
-        if textlist==None:
-            self.textlist=[]
+
+    def __init__(self, textlist=None):
+        if textlist == None:
+            self.textlist = []
         else:
-            self.textlist=textlist
-    def addtext(self,text=''):
+            self.textlist = textlist
+
+    def addtext(self, text=''):
         self.textlist.append(text)
-    def addtspan(self,tspan):
+
+    def addtspan(self, tspan):
         self.textlist.append(tspan)
-    def addtref(self,tref):
+
+    def addtref(self, tref):
         self.textlist.append(tref)
+
     def __repr__(self):
-        s=""
+        s = ""
         for element in self.textlist:
-            s+=str(element)
+            s += str(element)
         return s
 
+
 class rect(SVGelement):
     """r=rect(width,height,x,y,fill,stroke,stroke_width,**args)
 
     a rectangle is defined by a width and height and a xy pair
     """
-    def __init__(self,x=None,y=None,width=None,height=None,fill=None,stroke=None,stroke_width=None,**args):
-        if width==None or height==None:
-            if width<>None:
-                raise ValueError, 'height is required'
-            if height<>None:
-                raise ValueError, 'width is required'
-            else:
-                raise ValueError, 'both height and width are required'
-        SVGelement.__init__(self,'rect',{'width':width,'height':height},**args)
-        if x<>None:
+
+    def __init__(self, x=None, y=None, width=None, height=None, fill=None, stroke=None, stroke_width=None, **args):
+        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:
+        if y!=None:
             self.attributes['y']=y
-        if fill<>None:
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
 
 class ellipse(SVGelement):
@@ -423,22 +466,18 @@ class ellipse(SVGelement):
     """
     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:
-            if rx<>None:
-                raise ValueError, 'rx is required'
-            if ry<>None:
-                raise ValueError, 'ry is required'
-            else:
-                raise ValueError, 'both rx and ry are required'
-        SVGelement.__init__(self,'ellipse',{'rx':rx,'ry':ry},**args)
-        if cx<>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:
+        if cy!=None:
             self.attributes['cy']=cy
-        if fill<>None:
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
 
 
@@ -449,17 +488,17 @@ class circle(SVGelement):
     """
     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:
+            raise ValueError('r is required')
+        SVGelement.__init__(self, 'circle', {'r':r}, **args)
+        if cx!=None:
             self.attributes['cx']=cx
-        if cy<>None:
+        if cy!=None:
             self.attributes['cy']=cy
-        if fill<>None:
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
 
 class point(circle):
@@ -469,7 +508,7 @@ class point(circle):
     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)
+        circle.__init__(self, x, y, 1, fill, **args)
 
 class line(SVGelement):
     """l=line(x1,y1,x2,y2,stroke,stroke_width,**args)
@@ -477,18 +516,18 @@ 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):
-        SVGelement.__init__(self,'line',**args)
-        if x1<>None:
+        SVGelement.__init__(self, 'line', **args)
+        if x1!=None:
             self.attributes['x1']=x1
-        if y1<>None:
+        if y1!=None:
             self.attributes['y1']=y1
-        if x2<>None:
+        if x2!=None:
             self.attributes['x2']=x2
-        if y2<>None:
+        if y2!=None:
             self.attributes['y2']=y2
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
 
 class polyline(SVGelement):
@@ -497,12 +536,12 @@ 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):
-        SVGelement.__init__(self,'polyline',{'points':_xypointlist(points)},**args)
-        if fill<>None:
+        SVGelement.__init__(self, 'polyline', {'points':_xypointlist(points)}, **args)
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
 
 class polygon(SVGelement):
@@ -511,12 +550,12 @@ 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):
-        SVGelement.__init__(self,'polygon',{'points':_xypointlist(points)},**args)
-        if fill<>None:
+        SVGelement.__init__(self, 'polygon', {'points':_xypointlist(points)}, **args)
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
-        if stroke<>None:
+        if stroke!=None:
             self.attributes['stroke']=stroke
 
 class path(SVGelement):
@@ -525,14 +564,14 @@ 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):
-        SVGelement.__init__(self,'path',{'d':str(pathdata)},**args)
-        if stroke<>None:
+        SVGelement.__init__(self, 'path', {'d':str(pathdata)}, **args)
+        if stroke!=None:
             self.attributes['stroke']=stroke
-        if fill<>None:
+        if fill!=None:
             self.attributes['fill']=fill
-        if stroke_width<>None:
+        if stroke_width!=None:
             self.attributes['stroke-width']=stroke_width
-        if id<>None:
+        if id!=None:
             self.attributes['id']=id
 
 
@@ -542,18 +581,18 @@ 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:
+        SVGelement.__init__(self, 'text', **args)
+        if x!=None:
             self.attributes['x']=x
-        if y<>None:
+        if y!=None:
             self.attributes['y']=y
-        if font_size<>None:
+        if font_size!=None:
             self.attributes['font-size']=font_size
-        if font_family<>None:
+        if font_family!=None:
             self.attributes['font-family']=font_family
-        if text<>None:
+        if text!=None:
             self.text=text
-        if text_anchor<>None:
+        if text_anchor!=None:
             self.attributes['text-anchor']=text_anchor
 
 
@@ -563,8 +602,8 @@ 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:
+        SVGelement.__init__(self, 'textPath', {'xlink:href':link}, **args)
+        if text!=None:
             self.text=text
 
 class pattern(SVGelement):
@@ -575,16 +614,16 @@ 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):
-        SVGelement.__init__(self,'pattern',**args)
-        if x<>None:
+        SVGelement.__init__(self, 'pattern', **args)
+        if x!=None:
             self.attributes['x']=x
-        if y<>None:
+        if y!=None:
             self.attributes['y']=y
-        if width<>None:
+        if width!=None:
             self.attributes['width']=width
-        if height<>None:
+        if height!=None:
             self.attributes['height']=height
-        if patternUnits<>None:
+        if patternUnits!=None:
             self.attributes['patternUnits']=patternUnits
 
 class title(SVGelement):
@@ -594,8 +633,8 @@ class title(SVGelement):
     add at least one to the root svg element
     """
     def __init__(self,text=None,**args):
-        SVGelement.__init__(self,'title',**args)
-        if text<>None:
+        SVGelement.__init__(self, 'title', **args)
+        if text!=None:
             self.text=text
 
 class description(SVGelement):
@@ -605,8 +644,8 @@ class description(SVGelement):
     Add this element before adding other elements.
     """
     def __init__(self,text=None,**args):
-        SVGelement.__init__(self,'desc',**args)
-        if text<>None:
+        SVGelement.__init__(self, 'desc', **args)
+        if text!=None:
             self.text=text
 
 class lineargradient(SVGelement):
@@ -616,16 +655,16 @@ 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):
-        SVGelement.__init__(self,'linearGradient',**args)
-        if x1<>None:
+        SVGelement.__init__(self, 'linearGradient', **args)
+        if x1!=None:
             self.attributes['x1']=x1
-        if y1<>None:
+        if y1!=None:
             self.attributes['y1']=y1
-        if x2<>None:
+        if x2!=None:
             self.attributes['x2']=x2
-        if y2<>None:
+        if y2!=None:
             self.attributes['y2']=y2
-        if id<>None:
+        if id!=None:
             self.attributes['id']=id
 
 class radialgradient(SVGelement):
@@ -635,18 +674,18 @@ 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):
-        SVGelement.__init__(self,'radialGradient',**args)
-        if cx<>None:
+        SVGelement.__init__(self, 'radialGradient', **args)
+        if cx!=None:
             self.attributes['cx']=cx
-        if cy<>None:
+        if cy!=None:
             self.attributes['cy']=cy
-        if r<>None:
+        if r!=None:
             self.attributes['r']=r
-        if fx<>None:
+        if fx!=None:
             self.attributes['fx']=fx
-        if fy<>None:
+        if fy!=None:
             self.attributes['fy']=fy
-        if id<>None:
+        if id!=None:
             self.attributes['id']=id
 
 class stop(SVGelement):
@@ -655,8 +694,8 @@ class stop(SVGelement):
     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:
+        SVGelement.__init__(self, 'stop', {'offset':offset}, **args)
+        if stop_color!=None:
             self.attributes['stop-color']=stop_color
 
 class style(SVGelement):
@@ -665,7 +704,7 @@ class style(SVGelement):
     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)
+        SVGelement.__init__(self, 'style', {'type':type}, cdata=cdata, **args)
 
 
 class image(SVGelement):
@@ -675,16 +714,11 @@ class image(SVGelement):
     """
     def __init__(self,url,x=None,y=None,width=None,height=None,**args):
         if width==None or height==None:
-            if width<>None:
-                raise ValueError, 'height is required'
-            if height<>None:
-                raise ValueError, 'width is required'
-            else:
-                raise ValueError, 'both height and width are required'
-        SVGelement.__init__(self,'image',{'xlink:href':url,'width':width,'height':height},**args)
-        if x<>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:
+        if y!=None:
             self.attributes['y']=y
 
 class cursor(SVGelement):
@@ -693,7 +727,7 @@ class cursor(SVGelement):
     defines a custom cursor for a element or a drawing
     """
     def __init__(self,url,**args):
-        SVGelement.__init__(self,'cursor',{'xlink:href':url},**args)
+        SVGelement.__init__(self, 'cursor', {'xlink:href':url}, **args)
 
 
 class marker(SVGelement):
@@ -703,18 +737,18 @@ 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):
-        SVGelement.__init__(self,'marker',**args)
-        if id<>None:
+        SVGelement.__init__(self, 'marker', **args)
+        if id!=None:
             self.attributes['id']=id
-        if viewBox<>None:
+        if viewBox!=None:
             self.attributes['viewBox']=_viewboxlist(viewBox)
-        if refx<>None:
+        if refx!=None:
             self.attributes['refX']=refx
-        if refy<>None:
+        if refy!=None:
             self.attributes['refY']=refy
-        if markerWidth<>None:
+        if markerWidth!=None:
             self.attributes['markerWidth']=markerWidth
-        if markerHeight<>None:
+        if markerHeight!=None:
             self.attributes['markerHeight']=markerHeight
 
 class group(SVGelement):
@@ -724,8 +758,8 @@ class group(SVGelement):
     g.addElement(SVGelement)
     """
     def __init__(self,id=None,**args):
-        SVGelement.__init__(self,'g',**args)
-        if id<>None:
+        SVGelement.__init__(self, 'g', **args)
+        if id!=None:
             self.attributes['id']=id
 
 class symbol(SVGelement):
@@ -738,10 +772,10 @@ class symbol(SVGelement):
     """
 
     def __init__(self,id=None,viewBox=None,**args):
-        SVGelement.__init__(self,'symbol',**args)
-        if id<>None:
+        SVGelement.__init__(self, 'symbol', **args)
+        if id!=None:
             self.attributes['id']=id
-        if viewBox<>None:
+        if viewBox!=None:
             self.attributes['viewBox']=_viewboxlist(viewBox)
 
 class defs(SVGelement):
@@ -750,7 +784,7 @@ class defs(SVGelement):
     container for defining elements
     """
     def __init__(self,**args):
-        SVGelement.__init__(self,'defs',**args)
+        SVGelement.__init__(self, 'defs', **args)
 
 class switch(SVGelement):
     """sw=switch(**args)
@@ -760,7 +794,7 @@ class switch(SVGelement):
     Refer to the SVG specification for details.
     """
     def __init__(self,**args):
-        SVGelement.__init__(self,'switch',**args)
+        SVGelement.__init__(self, 'switch', **args)
 
 
 class use(SVGelement):
@@ -769,15 +803,15 @@ 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:
+        SVGelement.__init__(self, 'use', {'xlink:href':link}, **args)
+        if x!=None:
             self.attributes['x']=x
-        if y<>None:
+        if y!=None:
             self.attributes['y']=y
 
-        if width<>None:
+        if width!=None:
             self.attributes['width']=width
-        if height<>None:
+        if height!=None:
             self.attributes['height']=height
 
 
@@ -788,15 +822,15 @@ class link(SVGelement):
     a.addElement(SVGelement)
     """
     def __init__(self,link='',**args):
-        SVGelement.__init__(self,'a',{'xlink:href':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:
+        SVGelement.__init__(self, 'view', **args)
+        if id!=None:
             self.attributes['id']=id
 
 class script(SVGelement):
@@ -806,7 +840,7 @@ 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):
     """an=animate(attribute,from,to,during,**args)
@@ -814,12 +848,12 @@ class animate(SVGelement):
     animates an attribute.
     """
     def __init__(self,attribute,fr=None,to=None,dur=None,**args):
-        SVGelement.__init__(self,'animate',{'attributeName':attribute},**args)
-        if fr<>None:
+        SVGelement.__init__(self, 'animate', {'attributeName':attribute}, **args)
+        if fr!=None:
             self.attributes['from']=fr
-        if to<>None:
+        if to!=None:
             self.attributes['to']=to
-        if dur<>None:
+        if dur!=None:
             self.attributes['dur']=dur
 
 class animateMotion(SVGelement):
@@ -828,10 +862,10 @@ class animateMotion(SVGelement):
     animates a SVGelement over the given path in dur seconds
     """
     def __init__(self,pathdata,dur,**args):
-        SVGelement.__init__(self,'animateMotion',**args)
-        if pathdata<>None:
+        SVGelement.__init__(self, 'animateMotion', **args)
+        if pathdata!=None:
             self.attributes['path']=str(pathdata)
-        if dur<>None:
+        if dur!=None:
             self.attributes['dur']=dur
 
 class animateTransform(SVGelement):
@@ -840,15 +874,15 @@ class animateTransform(SVGelement):
     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
-        if type<>None:
+        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:
+        if fr!=None:
             self.attributes['from']=fr
-        if to<>None:
+        if to!=None:
             self.attributes['to']=to
-        if dur<>None:
+        if dur!=None:
             self.attributes['dur']=dur
 class animateColor(SVGelement):
     """ac=animateColor(attribute,type,from,to,dur,**args)
@@ -856,14 +890,14 @@ class animateColor(SVGelement):
     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:
+        SVGelement.__init__(self, 'animateColor', {'attributeName':attribute}, **args)
+        if type!=None:
             self.attributes['type']=type
-        if fr<>None:
+        if fr!=None:
             self.attributes['from']=fr
-        if to<>None:
+        if to!=None:
             self.attributes['to']=to
-        if dur<>None:
+        if dur!=None:
             self.attributes['dur']=dur
 class set(SVGelement):
     """st=set(attribute,to,during,**args)
@@ -871,10 +905,10 @@ class set(SVGelement):
     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:
+        SVGelement.__init__(self, 'set', {'attributeName':attribute}, **args)
+        if to!=None:
             self.attributes['to']=to
-        if dur<>None:
+        if dur!=None:
             self.attributes['dur']=dur
 
 
@@ -895,12 +929,12 @@ class svg(SVGelement):
     d.toXml()
     """
     def __init__(self,viewBox=None, width=None, height=None,**args):
-        SVGelement.__init__(self,'svg',**args)
-        if viewBox<>None:
+        SVGelement.__init__(self, 'svg', **args)
+        if viewBox!=None:
             self.attributes['viewBox']=_viewboxlist(viewBox)
-        if width<>None:
+        if width!=None:
             self.attributes['width']=width
-        if height<>None:
+        if height!=None:
             self.attributes['height']=height
         self.namespace="http://www.w3.org/2000/svg"
 
@@ -918,27 +952,27 @@ class drawing:
     def __init__(self, entity={}):
         self.svg=None
         self.entity = entity
-    def setSVG(self,svg):
+    def setSVG(self, svg):
         self.svg=svg
-        #Voeg een element toe aan de grafiek toe.
+        # Voeg een element toe aan de grafiek toe.
     if use_dom_implementation==0:
         def toXml(self, filename='',compress=False):
-            import cStringIO
-            xml=cStringIO.StringIO()
+            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\"")
             if self.entity:
                 xml.write(" [\n")
-                for item in self.entity.keys():
+                for item in list(self.entity.keys()):
                     xml.write("<!ENTITY %s \"%s\">\n" % (item, self.entity[item]))
                 xml.write("]")
             xml.write(">\n")
-            self.svg.toXml(0,xml)
+            self.svg.toXml(0, xml)
             if not filename:
                 if compress:
                     import gzip
-                    f=cStringIO.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)
@@ -948,11 +982,11 @@ 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:
-                    f=file(filename,'w')
+                    f=file(filename, 'w')
                     f.write(xml.getvalue())
                     f.close()
 
@@ -963,40 +997,40 @@ 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
-            #that is a bit messy.
-            root=implementation.createDocument(None,None,doctype)
-            #Create the xml document.
+            # 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)
+            # Create the xml document.
             global appender
-            def appender(element,elementroot):
+            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)
                 if element.text:
                     textnode=root.createTextNode(element.text)
                     e.appendChild(textnode)
-                for attribute in element.attributes.keys():   #in element.attributes is supported from python 2.2
-                    e.setAttribute(attribute,str(element.attributes[attribute]))
+                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 cStringIO
-                xml=cStringIO.StringIO()
-                PrettyPrint(root,xml)
+                import io
+                xml=io.StringIO()
+                PrettyPrint(root, xml)
                 if compress:
                     import gzip
-                    f=cStringIO.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)
@@ -1007,23 +1041,23 @@ class drawing:
                 try:
                     if filename[-4:]=='svgz':
                         import gzip
-                        import cStringIO
-                        xml=cStringIO.StringIO()
-                        PrettyPrint(root,xml)
-                        f=gzip.GzipFile(filename=filename,mode='wb',compresslevel=9)
+                        import io
+                        xml=io.StringIO()
+                        PrettyPrint(root, xml)
+                        f=gzip.GzipFile(filename=filename, mode='wb', compresslevel=9)
                         f.write(xml.getvalue())
                         f.close()
                     else:
-                        f=open(filename,'w')
-                        PrettyPrint(root,f)
+                        f=open(filename, 'w')
+                        PrettyPrint(root, f)
                         f.close()
                 except:
-                    print "Cannot write SVG file: " + filename
+                    print(("Cannot write SVG file: " + filename))
     def validate(self):
         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:
@@ -1031,38 +1065,38 @@ class drawing:
         except:
             raise Exception("SVG is not well formed, see messages above")
         else:
-            print "SVG well formed"
+            print("SVG well formed")
 if __name__=='__main__':
 
 
     d=drawing()
-    s=svg((0,0,100,100))
-    r=rect(-100,-100,300,300,'cyan')
+    s=svg((0, 0, 100, 100))
+    r=rect(-100, -100, 300, 300, 'cyan')
     s.addElement(r)
 
     t=title('SVGdraw Demo')
     s.addElement(t)
     g=group('animations')
-    e=ellipse(0,0,5,2)
+    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)
+        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"
     g.addElement(an)
     s.addElement(g)
-    for i in range(20,120,20):
-        u=use('#animations',i,0)
+    for i in range(20, 120, 20):
+        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)
+    for i in range(0, 120, 20):
+        for j in range(5, 105, 10):
+            c=circle(i, j, 1, 'red', 'black', .5)
             s.addElement(c)
     d.setSVG(s)
 
-    print d.toXml()
+    print((d.toXml()))
diff --git a/wqflask/utility/temp_data.py b/wqflask/utility/temp_data.py
index 5bf700c9..4144ae00 100644
--- a/wqflask/utility/temp_data.py
+++ b/wqflask/utility/temp_data.py
@@ -1,4 +1,3 @@
-from __future__ import print_function, division, absolute_import
 from redis import Redis
 
 import simplejson as json
@@ -20,6 +19,6 @@ class TempData(object):
 
 if __name__ == "__main__":
     redis = Redis()
-    for key in redis.keys():
+    for key in list(redis.keys()):
         for field in redis.hkeys(key):
             print("{}.{}={}".format(key, field, redis.hget(key, field)))
diff --git a/wqflask/utility/tools.py b/wqflask/utility/tools.py
index 77db5d53..68ef0f04 100644
--- a/wqflask/utility/tools.py
+++ b/wqflask/utility/tools.py
@@ -15,7 +15,7 @@ OVERRIDES = {}
 
 def app_set(command_id, value):
     """Set application wide value"""
-    app.config.setdefault(command_id,value)
+    app.config.setdefault(command_id, value)
     return value
 
 def get_setting(command_id,guess=None):
@@ -45,7 +45,7 @@ def get_setting(command_id,guess=None):
     def value(command):
         if command:
             # sys.stderr.write("Found "+command+"\n")
-            app_set(command_id,command)
+            app_set(command_id, command)
             return command
         else:
             return None
@@ -68,7 +68,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]:
+    if v not in [0, False, 'False', 'FALSE', None]:
       return True
     return False
 
@@ -108,16 +108,16 @@ def js_path(module=None):
     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)
+    return get_setting("REAPER_COMMAND", guess)
 
 def gemma_command(guess=None):
-    return assert_bin(get_setting("GEMMA_COMMAND",guess))
+    return assert_bin(get_setting("GEMMA_COMMAND", guess))
 
 def gemma_wrapper_command(guess=None):
-    return assert_bin(get_setting("GEMMA_WRAPPER_COMMAND",guess))
+    return assert_bin(get_setting("GEMMA_WRAPPER_COMMAND", guess))
 
 def plink_command(guess=None):
-    return assert_bin(get_setting("PLINK_COMMAND",guess))
+    return assert_bin(get_setting("PLINK_COMMAND", guess))
 
 def flat_file_exists(subdir):
     base = get_setting("GENENETWORK_FILES")
@@ -180,7 +180,7 @@ def locate(name, subdir=None):
     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):
     """
@@ -204,7 +204,7 @@ def tempdir():
     """
     Get UNIX TMPDIR by default
     """
-    return valid_path(get_setting("TMPDIR","/tmp"))
+    return valid_path(get_setting("TMPDIR", "/tmp"))
 
 BLUE  = '\033[94m'
 GREEN = '\033[92m'
@@ -214,20 +214,20 @@ 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)
-    print "runserver.py: ****** Webserver configuration - k,v pairs from app.config ******"
-    keylist = app.config.keys()
+    keylist = list(app.config.keys())
+    print("runserver.py: ****** Webserver configuration - k,v pairs from app.config ******")
     keylist.sort()
     for k in keylist:
         try:
-            print("%s: %s%s%s%s" % (k,BLUE,BOLD,get_setting(k),ENDC))
+            print(("%s: %s%s%s%s" % (k, BLUE, BOLD, get_setting(k), ENDC)))
         except:
-            print("%s: %s%s%s%s" % (k,GREEN,BOLD,app.config[k],ENDC))
+            print(("%s: %s%s%s%s" % (k, GREEN, BOLD, app.config[k], ENDC)))
 
 
 # Cached values
@@ -279,10 +279,10 @@ 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
 assert_dir(TEMPDIR)
@@ -295,11 +295,11 @@ 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")
 
-JS_CYTOSCAPE_PATH = get_setting("JS_CYTOSCAPE_PATH",js_path("cytoscape"))
+JS_CYTOSCAPE_PATH = get_setting("JS_CYTOSCAPE_PATH", js_path("cytoscape"))
 assert_dir(JS_CYTOSCAPE_PATH)
 assert_file(JS_CYTOSCAPE_PATH+'/cytoscape.min.js')
 
diff --git a/wqflask/utility/webqtlUtil.py b/wqflask/utility/webqtlUtil.py
index 53661ae4..5681fadf 100644
--- a/wqflask/utility/webqtlUtil.py
+++ b/wqflask/utility/webqtlUtil.py
@@ -41,22 +41,22 @@ ParInfo ={
 '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'],
+'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'],
+'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'],
+'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']
 }
 
@@ -64,7 +64,7 @@ ParInfo ={
 #      Accessory Functions
 #########################################
 
-def genRandStr(prefix = "", length=8, chars=string.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):
@@ -91,7 +91,7 @@ def readLineCSV(line): ### dcrowell July 2008
     returnList[0]=returnList[0][1:]
     return returnList
 
-def cmpEigenValue(A,B):
+def cmpEigenValue(A, B):
     try:
         if A[0] > B[0]:
             return -1
@@ -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=map(string.strip, string.split(authorized_users, ','))
-        if AuthorizedUsersList.__contains__(userName):
+        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
\ No newline at end of file
+    return access_to_confidential_phenotype_trait