style: Fix PEP8 whitespace issues in Python files

Done with `autopep8 --select=E2,W2`, fixes:

- E201 - Remove extraneous whitespace.
- E202 - Remove extraneous whitespace.
- E203 - Remove extraneous whitespace.
- E211 - Remove extraneous whitespace.
- E221 - Fix extraneous whitespace around keywords.
- E222 - Fix extraneous whitespace around keywords.
- E223 - Fix extraneous whitespace around keywords.
- E224 - Remove extraneous whitespace around operator.
- E225 - Fix missing whitespace around operator.
- E226 - Fix missing whitespace around operator.
- E227 - Fix missing whitespace around operator.
- E228 - Fix missing whitespace around operator.
- E231 - Add missing whitespace.
- E231 - Fix various deprecated code (via lib2to3).
- E241 - Fix extraneous whitespace around keywords.
- E242 - Remove extraneous whitespace around operator.
- E251 - Remove whitespace around parameter '=' sign.
- E261 - Fix spacing after comment hash.
- E262 - Fix spacing after comment hash.
- E265 - Format block comments.
- E271 - Fix extraneous whitespace around keywords.
- E272 - Fix extraneous whitespace around keywords.
- E273 - Fix extraneous whitespace around keywords.
- E274 - Fix extraneous whitespace around keywords.
- W291 - Remove trailing whitespace.
- W293 - Remove trailing whitespace.

6 files changed, 696 insertions, 696 deletions

diff --git a/doc/tools/doc_merge.py b/doc/tools/doc_merge.py
index 27f46960be..747a870378 100644
--- a/doc/tools/doc_merge.py
+++ b/doc/tools/doc_merge.py
@@ -6,17 +6,17 @@ import xml.etree.ElementTree as ET
 
 
 tree = ET.parse(sys.argv[1])
-old_doc=tree.getroot()
+old_doc = tree.getroot()
 
 tree = ET.parse(sys.argv[2])
-new_doc=tree.getroot()
+new_doc = tree.getroot()
 
-f = file(sys.argv[3],"wb")
-tab=0
+f = file(sys.argv[3], "wb")
+tab = 0
 
-old_classes={}
+old_classes = {}
 
-def write_string(_f, text,newline=True):
+def write_string(_f, text, newline=True):
     for t in range(tab):
         _f.write("\t")
     _f.write(text)
@@ -24,188 +24,188 @@ def write_string(_f, text,newline=True):
         _f.write("\n")
 
 def escape(ret):
-    ret=ret.replace("&","&");
-    ret=ret.replace("<","&gt;");
-    ret=ret.replace(">","&lt;");
-    ret=ret.replace("'","&apos;");
-    ret=ret.replace("\"","&quot;");
+    ret = ret.replace("&", "&amp;");
+    ret = ret.replace("<", "&gt;");
+    ret = ret.replace(">", "&lt;");
+    ret = ret.replace("'", "&apos;");
+    ret = ret.replace("\"", "&quot;");
     return ret
 
 
 def inc_tab():
     global tab
-    tab+=1
+    tab += 1
 
 def dec_tab():
     global tab
-    tab-=1
+    tab -= 1
 
-write_string(f,'<?xml version="1.0" encoding="UTF-8" ?>')
-write_string(f,'<doc version="'+new_doc.attrib["version"]+'">')
+write_string(f, '<?xml version="1.0" encoding="UTF-8" ?>')
+write_string(f, '<doc version="' + new_doc.attrib["version"] + '">')
 
-def get_tag(node,name):
-    tag=""
+def get_tag(node, name):
+    tag = ""
     if (name in node.attrib):
-        tag=' '+name+'="'+escape(node.attrib[name])+'" '
+        tag = ' ' + name + '="' + escape(node.attrib[name]) + '" '
     return tag
 
-def find_method_descr(old_class,name):
+def find_method_descr(old_class, name):
 
     methods = old_class.find("methods")
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         for m in list(methods):
-            if (m.attrib["name"]==name):
-                description=m.find("description")
-                if (description!=None and description.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                description = m.find("description")
+                if (description != None and description.text.strip() != ""):
                     return description.text
 
     return None
 
-def find_signal_descr(old_class,name):
+def find_signal_descr(old_class, name):
 
     signals = old_class.find("signals")
-    if(signals!=None and len(list(signals))>0):
+    if(signals != None and len(list(signals)) > 0):
         for m in list(signals):
-            if (m.attrib["name"]==name):
-                description=m.find("description")
-                if (description!=None and description.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                description = m.find("description")
+                if (description != None and description.text.strip() != ""):
                     return description.text
 
     return None
 
-def find_constant_descr(old_class,name):
+def find_constant_descr(old_class, name):
 
-    if (old_class==None):
+    if (old_class == None):
         return None
     constants = old_class.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
         for m in list(constants):
-            if (m.attrib["name"]==name):
-                if (m.text.strip()!=""):
+            if (m.attrib["name"] == name):
+                if (m.text.strip() != ""):
                     return m.text
     return None
 
 def write_class(c):
     class_name = c.attrib["name"]
-    print("Parsing Class: "+class_name)
+    print("Parsing Class: " + class_name)
     if (class_name in old_classes):
-        old_class=old_classes[class_name]
+        old_class = old_classes[class_name]
     else:
-        old_class=None
+        old_class = None
 
 
-    category=get_tag(c,"category")
-    inherits=get_tag(c,"inherits")
-    write_string(f,'<class name="'+class_name+'" '+category+inherits+'>')
+    category = get_tag(c, "category")
+    inherits = get_tag(c, "inherits")
+    write_string(f, '<class name="' + class_name + '" ' + category + inherits + '>')
     inc_tab()
 
-    write_string(f,"<brief_description>")
+    write_string(f, "<brief_description>")
 
-    if (old_class!=None):
-        old_brief_descr=old_class.find("brief_description")
-        if (old_brief_descr!=None):
-            write_string(f,escape(old_brief_descr.text.strip()))
+    if (old_class != None):
+        old_brief_descr = old_class.find("brief_description")
+        if (old_brief_descr != None):
+            write_string(f, escape(old_brief_descr.text.strip()))
 
 
-    write_string(f,"</brief_description>")
+    write_string(f, "</brief_description>")
 
-    write_string(f,"<description>")
-    if (old_class!=None):
-        old_descr=old_class.find("description")
-        if (old_descr!=None):
-            write_string(f,escape(old_descr.text.strip()))
+    write_string(f, "<description>")
+    if (old_class != None):
+        old_descr = old_class.find("description")
+        if (old_descr != None):
+            write_string(f, escape(old_descr.text.strip()))
 
-    write_string(f,"</description>")
+    write_string(f, "</description>")
 
     methods = c.find("methods")
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
 
-        write_string(f,"<methods>")
+        write_string(f, "<methods>")
         inc_tab()
 
         for m in list(methods):
-            qualifiers=get_tag(m,"qualifiers")
+            qualifiers = get_tag(m, "qualifiers")
 
-            write_string(f,'<method name="'+escape(m.attrib["name"])+'" ' +qualifiers+'>')
+            write_string(f, '<method name="' + escape(m.attrib["name"]) + '" ' + qualifiers + '>')
             inc_tab()
 
             for a in list(m):
-                if (a.tag=="return"):
-                    typ=get_tag(a,"type")
-                    write_string(f,'<return'+typ+'>');
-                    write_string(f,'</return>');
-                elif (a.tag=="argument"):
+                if (a.tag == "return"):
+                    typ = get_tag(a, "type")
+                    write_string(f, '<return' + typ + '>');
+                    write_string(f, '</return>');
+                elif (a.tag == "argument"):
 
-                    default=get_tag(a,"default")
+                    default = get_tag(a, "default")
 
-                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'"' +default+'>');
-                    write_string(f,'</argument>');
+                    write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '"' + default + '>');
+                    write_string(f, '</argument>');
 
-            write_string(f,'<description>');
-            if (old_class!=None):
-                old_method_descr=find_method_descr(old_class,m.attrib["name"])
+            write_string(f, '<description>');
+            if (old_class != None):
+                old_method_descr = find_method_descr(old_class, m.attrib["name"])
                 if (old_method_descr):
-                    write_string(f,escape(escape(old_method_descr.strip())))
+                    write_string(f, escape(escape(old_method_descr.strip())))
 
-            write_string(f,'</description>');
+            write_string(f, '</description>');
             dec_tab()
-            write_string(f,"</method>")
+            write_string(f, "</method>")
         dec_tab()
-        write_string(f,"</methods>")
+        write_string(f, "</methods>")
 
     signals = c.find("signals")
-    if(signals!=None and len(list(signals))>0):
+    if(signals != None and len(list(signals)) > 0):
 
-        write_string(f,"<signals>")
+        write_string(f, "<signals>")
         inc_tab()
 
         for m in list(signals):
 
-            write_string(f,'<signal name="'+escape(m.attrib["name"])+'">')
+            write_string(f, '<signal name="' + escape(m.attrib["name"]) + '">')
             inc_tab()
 
             for a in list(m):
-                if (a.tag=="argument"):
+                if (a.tag == "argument"):
 
-                    write_string(f,'<argument index="'+a.attrib["index"]+'" name="'+escape(a.attrib["name"])+'" type="'+a.attrib["type"]+'">');
-                    write_string(f,'</argument>');
+                    write_string(f, '<argument index="' + a.attrib["index"] + '" name="' + escape(a.attrib["name"]) + '" type="' + a.attrib["type"] + '">');
+                    write_string(f, '</argument>');
 
-            write_string(f,'<description>');
-            if (old_class!=None):
-                old_signal_descr=find_signal_descr(old_class,m.attrib["name"])
+            write_string(f, '<description>');
+            if (old_class != None):
+                old_signal_descr = find_signal_descr(old_class, m.attrib["name"])
                 if (old_signal_descr):
-                    write_string(f,escape(old_signal_descr.strip()))
-            write_string(f,'</description>');
+                    write_string(f, escape(old_signal_descr.strip()))
+            write_string(f, '</description>');
             dec_tab()
-            write_string(f,"</signal>")
+            write_string(f, "</signal>")
         dec_tab()
-        write_string(f,"</signals>")
+        write_string(f, "</signals>")
 
     constants = c.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
 
-        write_string(f,"<constants>")
+        write_string(f, "<constants>")
         inc_tab()
 
         for m in list(constants):
 
-            write_string(f,'<constant name="'+escape(m.attrib["name"])+'" value="'+m.attrib["value"]+'">')
-            old_constant_descr=find_constant_descr(old_class,m.attrib["name"])
+            write_string(f, '<constant name="' + escape(m.attrib["name"]) + '" value="' + m.attrib["value"] + '">')
+            old_constant_descr = find_constant_descr(old_class, m.attrib["name"])
             if (old_constant_descr):
-                write_string(f,escape(old_constant_descr.strip()))
-            write_string(f,"</constant>")
+                write_string(f, escape(old_constant_descr.strip()))
+            write_string(f, "</constant>")
 
         dec_tab()
-        write_string(f,"</constants>")
+        write_string(f, "</constants>")
 
     dec_tab()
-    write_string(f,"</class>")
+    write_string(f, "</class>")
 
 for c in list(old_doc):
-    old_classes[c.attrib["name"]]=c
+    old_classes[c.attrib["name"]] = c
 
 for c in list(new_doc):
     write_class(c)
-write_string(f,'</doc>\n')
+write_string(f, '</doc>\n')
 
 
diff --git a/doc/tools/doc_status.py b/doc/tools/doc_status.py
index 00907bb01d..4e108f352e 100755
--- a/doc/tools/doc_status.py
+++ b/doc/tools/doc_status.py
@@ -11,7 +11,7 @@ import xml.etree.ElementTree as ET
 ################################################################################
 
 flags = {
-    'c': platform.platform() != 'Windows', # Disable by default on windows, since we use ANSI escape codes
+    'c': platform.platform() != 'Windows',  # Disable by default on windows, since we use ANSI escape codes
     'b': False,
     'g': False,
     's': False,
@@ -62,15 +62,15 @@ long_flags = {
 table_columns = ['name', 'brief_description', 'description', 'methods', 'constants', 'members', 'signals']
 table_column_names = ['Name', 'Brief Desc.', 'Desc.', 'Methods', 'Constants', 'Members', 'Signals']
 colors = {
-    'name': [36], # cyan
-    'part_big_problem': [4, 31], # underline, red
-    'part_problem': [31], # red
-    'part_mostly_good': [33], # yellow
-    'part_good': [32], # green
-    'url': [4, 34], # underline, blue
-    'section': [1, 4], # bold, underline
-    'state_off': [36], # cyan
-    'state_on': [1, 35], # bold, magenta/plum
+    'name': [36],  # cyan
+    'part_big_problem': [4, 31],  # underline, red
+    'part_problem': [31],  # red
+    'part_mostly_good': [33],  # yellow
+    'part_good': [32],  # green
+    'url': [4, 34],  # underline, blue
+    'section': [1, 4],  # bold, underline
+    'state_off': [36],  # cyan
+    'state_on': [1, 35],  # bold, magenta/plum
 }
 overall_progress_description_weigth = 10
 
@@ -105,7 +105,7 @@ def nonescape_len(s):
 ################################################################################
 
 class ClassStatusProgress:
-    def __init__(self, described = 0, total = 0):
+    def __init__(self, described=0, total=0):
         self.described = described
         self.total = total
 
@@ -127,12 +127,12 @@ class ClassStatusProgress:
             return self.to_colored_string()
 
     def to_colored_string(self, format='{has}/{total}', pad_format='{pad_described}{s}{pad_total}'):
-        ratio = self.described/self.total if self.total != 0 else 1
-        percent = round(100*ratio)
-        s = format.format(has = str(self.described), total = str(self.total), percent = str(percent))
+        ratio = self.described / self.total if self.total != 0 else 1
+        percent = round(100 * ratio)
+        s = format.format(has=str(self.described), total=str(self.total), percent=str(percent))
         if self.described >= self.total:
             s = color('part_good', s)
-        elif self.described >= self.total/4*3:
+        elif self.described >= self.total / 4 * 3:
             s = color('part_mostly_good', s)
         elif self.described > 0:
             s = color('part_problem', s)
@@ -142,7 +142,7 @@ class ClassStatusProgress:
         pad_described = ''.ljust(pad_size - len(str(self.described)))
         pad_percent = ''.ljust(3 - len(str(percent)))
         pad_total = ''.ljust(pad_size - len(str(self.total)))
-        return pad_format.format(pad_described = pad_described, pad_total = pad_total, pad_percent = pad_percent, s = s)
+        return pad_format.format(pad_described=pad_described, pad_total=pad_total, pad_percent=pad_percent, s=s)
 
 
 class ClassStatus:
@@ -231,7 +231,7 @@ class ClassStatus:
                     status.progresses[tag.tag].increment(len(sub_tag.text.strip()) > 0)
 
             elif tag.tag in ['theme_items']:
-                pass #Ignore those tags, since they seem to lack description at all
+                pass  # Ignore those tags, since they seem to lack description at all
 
             else:
                 print(tag.tag, tag.attrib)
@@ -296,10 +296,10 @@ if len(input_file_list) < 1 or flags['h']:
             if long_flags[synonym] == flag:
                 synonyms.append(color('name', '--' + synonym))
 
-        print(('{synonyms} (Currently '+color('state_'+('on' if flags[flag] else 'off'), '{value}')+')\n\t{description}').format(
-            synonyms = ', '.join(synonyms),
-            value = ('on' if flags[flag] else 'off'),
-            description = flag_descriptions[flag]
+        print(('{synonyms} (Currently ' + color('state_' + ('on' if flags[flag] else 'off'), '{value}') + ')\n\t{description}').format(
+            synonyms=', '.join(synonyms),
+            value=('on' if flags[flag] else 'off'),
+            description=flag_descriptions[flag]
         ))
     sys.exit(0)
 
@@ -413,9 +413,9 @@ for row_i, row in enumerate(table):
     for cell_i, cell in enumerate(row):
         padding_needed = table_column_sizes[cell_i] - nonescape_len(cell) + 2
         if cell_i == 0:
-            row_string += table_row_chars[2] + cell + table_row_chars[2]*(padding_needed-1)
+            row_string += table_row_chars[2] + cell + table_row_chars[2] * (padding_needed - 1)
         else:
-            row_string += table_row_chars[2]*math.floor(padding_needed/2) + cell + table_row_chars[2]*math.ceil((padding_needed/2))
+            row_string += table_row_chars[2] * math.floor(padding_needed / 2) + cell + table_row_chars[2] * math.ceil((padding_needed / 2))
         row_string += table_column_chars
 
     print(row_string)
diff --git a/doc/tools/makedoku.py b/doc/tools/makedoku.py
index f00a4614d5..32a52a584a 100644
--- a/doc/tools/makedoku.py
+++ b/doc/tools/makedoku.py
@@ -15,68 +15,68 @@ if len(input_list) < 1:
     sys.exit(0)
 
 
-def validate_tag(elem,tag):
+def validate_tag(elem, tag):
     if (elem.tag != tag):
-        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        print("Tag mismatch, expected '" + tag + "', got " + elem.tag);
         sys.exit(255)
 
 
-class_names=[]
-classes={}
+class_names = []
+classes = {}
 
 
-def make_class_list(class_list,columns):
+def make_class_list(class_list, columns):
 
-    f=open("class_list.txt","wb")
-    prev=0
+    f = open("class_list.txt", "wb")
+    prev = 0
     col_max = len(class_list) / columns + 1
     print("col max is ", col_max)
     col_count = 0
     row_count = 0
     last_initial = ""
-    fit_columns=[]
+    fit_columns = []
 
-    for n in range(0,columns):
-        fit_columns+=[[]]
+    for n in range(0, columns):
+        fit_columns += [[]]
 
-    indexers=[]
-    last_initial=""
+    indexers = []
+    last_initial = ""
 
-    idx=0
+    idx = 0
     for n in class_list:
-        col = idx/col_max
-        if (col>=columns):
-            col=columns-1
-        fit_columns[col]+=[n]
-        idx+=1
-        if (n[:1]!=last_initial):
-            indexers+=[n]
-        last_initial=n[:1]
+        col = idx / col_max
+        if (col >= columns):
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if (n[:1] != last_initial):
+            indexers += [n]
+        last_initial = n[:1]
 
 
-    row_max=0
+    row_max = 0
 
-    for n in range(0,columns):
-        if (len(fit_columns[n])>row_max):
-            row_max=len(fit_columns[n])
+    for n in range(0, columns):
+        if (len(fit_columns[n]) > row_max):
+            row_max = len(fit_columns[n])
 
 
-    for r in range(0,row_max):
-        s="|"
-        for c in range(0,columns):
-            if (r>=len(fit_columns[c])):
+    for r in range(0, row_max):
+        s = "|"
+        for c in range(0, columns):
+            if (r >= len(fit_columns[c])):
                 continue
 
             classname = fit_columns[c][r]
-            initial=classname[0]
+            initial = classname[0]
             if (classname in indexers):
-                s+="**"+initial+"**|"
+                s += "**" + initial + "**|"
             else:
-                s+=" |"
+                s += " |"
 
-            s+="[["+classname.lower()+"|"+classname+"]]|"
+            s += "[[" + classname.lower() + "|" + classname + "]]|"
 
-        s+="\n"
+        s += "\n"
         f.write(s)
 
 
@@ -86,221 +86,221 @@ def dokuize_text(txt):
 
 
 def dokuize_text(text):
-    pos=0
+    pos = 0
     while(True):
-        pos = text.find("[",pos)
-        if (pos==-1):
+        pos = text.find("[", pos)
+        if (pos == -1):
             break
 
-        endq_pos=text.find("]",pos+1)
-        if (endq_pos==-1):
+        endq_pos = text.find("]", pos + 1)
+        if (endq_pos == -1):
             break
 
-        pre_text=text[:pos]
-        post_text=text[endq_pos+1:]
-        tag_text=text[pos+1:endq_pos]
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
 
         if (tag_text in class_names):
-            tag_text="[["+tag_text.lower()+"|"+tag_text+"]]"
-        else: #command
-            cmd=tag_text
-            space_pos=tag_text.find(" ")
-            if (cmd.find("html")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-                tag_text="<"+param+">"
-            elif(cmd.find("method")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-
-                if (param.find(".")!=-1):
-                    class_param,method_param=param.split(".")
-                    tag_text="[["+class_param.lower()+"#"+method_param+"|"+class_param+'.'+method_param+"]]"
+            tag_text = "[[" + tag_text.lower() + "|" + tag_text + "]]"
+        else:  # command
+            cmd = tag_text
+            space_pos = tag_text.find(" ")
+            if (cmd.find("html") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = "<" + param + ">"
+            elif(cmd.find("method") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if (param.find(".") != -1):
+                    class_param, method_param = param.split(".")
+                    tag_text = "[[" + class_param.lower() + "#" + method_param + "|" + class_param + '.' + method_param + "]]"
                 else:
-                    tag_text="[[#"+param+"|"+param+"]]"
-            elif (cmd.find("image=")==0):
-                tag_text="{{"+cmd[6:]+"}}"
-            elif (cmd.find("url=")==0):
-                tag_text="[["+cmd[4:]+"|"
-            elif (cmd=="/url"):
-                tag_text="]]>"
-            elif (cmd=="center"):
-                tag_text=""
-            elif (cmd=="/center"):
-                tag_text=""
-            elif (cmd=="br"):
-                tag_text="\\\\\n"
-            elif (cmd=="i" or cmd=="/i"):
-                tag_text="//"
-            elif (cmd=="b" or cmd=="/b"):
-                tag_text="**"
-            elif (cmd=="u" or cmd=="/u"):
-                tag_text="__"
+                    tag_text = "[[#" + param + "|" + param + "]]"
+            elif (cmd.find("image=") == 0):
+                tag_text = "{{" + cmd[6:] + "}}"
+            elif (cmd.find("url=") == 0):
+                tag_text = "[[" + cmd[4:] + "|"
+            elif (cmd == "/url"):
+                tag_text = "]]>"
+            elif (cmd == "center"):
+                tag_text = ""
+            elif (cmd == "/center"):
+                tag_text = ""
+            elif (cmd == "br"):
+                tag_text = "\\\\\n"
+            elif (cmd == "i" or cmd == "/i"):
+                tag_text = "//"
+            elif (cmd == "b" or cmd == "/b"):
+                tag_text = "**"
+            elif (cmd == "u" or cmd == "/u"):
+                tag_text = "__"
             else:
-                tag_text="["+tag_text+"]"
+                tag_text = "[" + tag_text + "]"
 
 
-        text=pre_text+tag_text+post_text
-        pos=len(pre_text)+len(tag_text)
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
     #tnode = ET.SubElement(parent,"div")
-    #tnode.text=text
+    # tnode.text=text
     return text
 
 
 def make_type(t):
     global class_names
     if (t in class_names):
-        return "[["+t.lower()+"|"+t+"]]"
+        return "[[" + t.lower() + "|" + t + "]]"
     return t
 
 
-def make_method(f,name,m,declare,event=False):
+def make_method(f, name, m, declare, event=False):
 
-    s="  * "
-    ret_type="void"
-    args=list(m)
-    mdata={}
-    mdata["argidx"]=[]
+    s = "  * "
+    ret_type = "void"
+    args = list(m)
+    mdata = {}
+    mdata["argidx"] = []
     for a in args:
-        if (a.tag=="return"):
-            idx=-1
-        elif (a.tag=="argument"):
-            idx=int(a.attrib["index"])
+        if (a.tag == "return"):
+            idx = -1
+        elif (a.tag == "argument"):
+            idx = int(a.attrib["index"])
         else:
             continue
 
         mdata["argidx"].append(idx)
-        mdata[idx]=a
+        mdata[idx] = a
 
 
 
     if (not event):
         if (-1 in mdata["argidx"]):
-            s+=make_type(mdata[-1].attrib["type"])
+            s += make_type(mdata[-1].attrib["type"])
         else:
-            s+="void"
-        s+=" "
+            s += "void"
+        s += " "
 
     if (declare):
 
-        #span.attrib["class"]="funcdecl"
-        #a=ET.SubElement(span,"a")
-        #a.attrib["name"]=name+"_"+m.attrib["name"]
-        #a.text=name+"::"+m.attrib["name"]
-        s+="**"+m.attrib["name"]+"**"
+        # span.attrib["class"]="funcdecl"
+        # a=ET.SubElement(span,"a")
+        # a.attrib["name"]=name+"_"+m.attrib["name"]
+        # a.text=name+"::"+m.attrib["name"]
+        s += "**" + m.attrib["name"] + "**"
     else:
-        s+="[[#"+m.attrib["name"]+"|"+m.attrib["name"]+"]]"
+        s += "[[#" + m.attrib["name"] + "|" + m.attrib["name"] + "]]"
 
-    s+="**(**"
-    argfound=False
+    s += "**(**"
+    argfound = False
     for a in mdata["argidx"]:
-        arg=mdata[a]
-        if (a<0):
+        arg = mdata[a]
+        if (a < 0):
             continue
-        if (a>0):
-            s+=", "
+        if (a > 0):
+            s += ", "
         else:
-            s+=" "
+            s += " "
 
-        s+=make_type(arg.attrib["type"])
+        s += make_type(arg.attrib["type"])
         if ("name" in arg.attrib):
-            s+=" "+arg.attrib["name"]
+            s += " " + arg.attrib["name"]
         else:
-            s+=" arg"+str(a)
+            s += " arg" + str(a)
 
         if ("default" in arg.attrib):
-            s+="="+arg.attrib["default"]
+            s += "=" + arg.attrib["default"]
 
 
-        argfound=True
+        argfound = True
 
     if (argfound):
-        s+=" "
-    s+="**)**"
+        s += " "
+    s += "**)**"
 
     if ("qualifiers" in m.attrib):
-        s+=" "+m.attrib["qualifiers"]
+        s += " " + m.attrib["qualifiers"]
 
-    f.write(s+"\n")
+    f.write(s + "\n")
 
 
 def make_doku_class(node):
 
     name = node.attrib["name"]
 
-    f=open(name.lower()+".txt","wb")
+    f = open(name.lower() + ".txt", "wb")
 
-    f.write("======  "+name+"  ======\n")
+    f.write("======  " + name + "  ======\n")
 
     if ("inherits" in node.attrib):
-        inh=node.attrib["inherits"].strip()
-        f.write("**Inherits:** [["+inh.lower()+"|"+inh+"]]\\\\\n")
+        inh = node.attrib["inherits"].strip()
+        f.write("**Inherits:** [[" + inh.lower() + "|" + inh + "]]\\\\\n")
     if ("category" in node.attrib):
-        f.write("**Category:** "+node.attrib["category"].strip()+"\\\\\n")
+        f.write("**Category:** " + node.attrib["category"].strip() + "\\\\\n")
 
     briefd = node.find("brief_description")
-    if (briefd!=None):
+    if (briefd != None):
         f.write("=====  Brief Description  ======\n")
-        f.write( dokuize_text(briefd.text.strip())+"\n" )
+        f.write(dokuize_text(briefd.text.strip()) + "\n")
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         f.write("=====  Member Functions  ======\n")
         for m in list(methods):
-            make_method(f,node.attrib["name"],m,False)
+            make_method(f, node.attrib["name"], m, False)
 
     events = node.find("signals")
-    if(events!=None and len(list(events))>0):
+    if(events != None and len(list(events)) > 0):
         f.write("=====  Signals  ======\n")
         for m in list(events):
-            make_method(f,node.attrib["name"],m,True,True)
+            make_method(f, node.attrib["name"], m, True, True)
 
     members = node.find("members")
 
-    if(members!=None and len(list(members))>0):
+    if(members != None and len(list(members)) > 0):
         f.write("=====  Member Variables  ======\n")
 
         for c in list(members):
             s = "  * "
-            s+=make_type(c.attrib["type"])+" "
-            s+="**"+c.attrib["name"]+"**"
-            if (c.text.strip()!=""):
-                s+=" - "+c.text.strip()
-            f.write(s+"\n")
+            s += make_type(c.attrib["type"]) + " "
+            s += "**" + c.attrib["name"] + "**"
+            if (c.text.strip() != ""):
+                s += " - " + c.text.strip()
+            f.write(s + "\n")
 
 
 
     constants = node.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
         f.write("=====  Numeric Constants  ======\n")
         for c in list(constants):
             s = "  * "
-            s+="**"+c.attrib["name"]+"**"
+            s += "**" + c.attrib["name"] + "**"
             if ("value" in c.attrib):
-                s+=" = **"+c.attrib["value"]+"**"
-            if (c.text.strip()!=""):
-                s+=" - "+c.text.strip()
-            f.write(s+"\n")
+                s += " = **" + c.attrib["value"] + "**"
+            if (c.text.strip() != ""):
+                s += " - " + c.text.strip()
+            f.write(s + "\n")
 
 
-    descr=node.find("description")
-    if (descr!=None and descr.text.strip()!=""):
+    descr = node.find("description")
+    if (descr != None and descr.text.strip() != ""):
         f.write("=====  Description  ======\n")
-        f.write(dokuize_text(descr.text.strip())+"\n")
+        f.write(dokuize_text(descr.text.strip()) + "\n")
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
         f.write("=====  Member Function Description  ======\n")
         for m in list(methods):
 
-            d=m.find("description")
-            if (d==None or d.text.strip()==""):
+            d = m.find("description")
+            if (d == None or d.text.strip() == ""):
                 continue
-            f.write("==  "+m.attrib["name"]+"  ==\n")
-            make_method(f,node.attrib["name"],m,False)
+            f.write("==  " + m.attrib["name"] + "  ==\n")
+            make_method(f, node.attrib["name"], m, False)
             f.write("\\\\\n")
             f.write(dokuize_text(d.text.strip()))
             f.write("\n")
@@ -488,27 +488,27 @@ def make_doku_class(node):
 """
 for file in input_list:
     tree = ET.parse(file)
-    doc=tree.getroot()
+    doc = tree.getroot()
 
     if ("version" not in doc.attrib):
         print("Version missing from 'doc'")
         sys.exit(255)
 
-    version=doc.attrib["version"]
+    version = doc.attrib["version"]
 
     for c in list(doc):
         if (c.attrib["name"] in class_names):
             continue
         class_names.append(c.attrib["name"])
-        classes[c.attrib["name"]]=c
+        classes[c.attrib["name"]] = c
 
 
 class_names.sort()
 
-make_class_list(class_names,4)
+make_class_list(class_names, 4)
 
 for cn in class_names:
-    c=classes[cn]
+    c = classes[cn]
     make_doku_class(c)
 
 
diff --git a/doc/tools/makehtml.py b/doc/tools/makehtml.py
index 12f92883a4..95a35960b7 100644
--- a/doc/tools/makehtml.py
+++ b/doc/tools/makehtml.py
@@ -10,7 +10,7 @@ html_escape_table = {
     "'": "&apos;"
 }
 
-html_unescape_table = {v:k for k, v in html_escape_table.items()}
+html_unescape_table = {v: k for k, v in html_escape_table.items()}
 
 def html_escape(text):
     return escape(text, html_escape_table)
@@ -20,7 +20,7 @@ def html_unescape(text):
 
 input_list = []
 
-single_page=True
+single_page = True
 
 for arg in sys.argv[1:]:
     if arg[:1] == "-":
@@ -36,106 +36,106 @@ if len(input_list) < 1:
     sys.exit(0)
 
 
-def validate_tag(elem,tag):
+def validate_tag(elem, tag):
     if (elem.tag != tag):
-        print("Tag mismatch, expected '"+tag+"', got "+elem.tag);
+        print("Tag mismatch, expected '" + tag + "', got " + elem.tag);
         sys.exit(255)
 
 def make_html_bottom(body):
-    #make_html_top(body,True)
-    ET.SubElement(body,"hr")
-    copyright = ET.SubElement(body,"span")
+    # make_html_top(body,True)
+    ET.SubElement(body, "hr")
+    copyright = ET.SubElement(body, "span")
     copyright.text = "Copyright 2008-2010 Codenix SRL"
 
-def make_html_top(body,bottom=False):
+def make_html_top(body, bottom=False):
 
     if (bottom):
-        ET.SubElement(body,"hr")
-
-    table = ET.SubElement(body,"table")
-    table.attrib["class"]="top_table"
-    tr = ET.SubElement(table,"tr")
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-
-    img = ET.SubElement(td,"image")
-    img.attrib["src"]="images/logo.png"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="index.html"
-    a.text="Index"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="alphabetical.html"
-    a.text="Classes"
-    td = ET.SubElement(tr,"td")
-    td.attrib["class"]="top_table"
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="category.html"
-    a.text="Categories"
-    td = ET.SubElement(tr,"td")
-    a = ET.SubElement(td,"a")
-    a.attrib["href"]="inheritance.html"
-    a.text="Inheritance"
+        ET.SubElement(body, "hr")
+
+    table = ET.SubElement(body, "table")
+    table.attrib["class"] = "top_table"
+    tr = ET.SubElement(table, "tr")
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+
+    img = ET.SubElement(td, "image")
+    img.attrib["src"] = "images/logo.png"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "index.html"
+    a.text = "Index"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "alphabetical.html"
+    a.text = "Classes"
+    td = ET.SubElement(tr, "td")
+    td.attrib["class"] = "top_table"
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "category.html"
+    a.text = "Categories"
+    td = ET.SubElement(tr, "td")
+    a = ET.SubElement(td, "a")
+    a.attrib["href"] = "inheritance.html"
+    a.text = "Inheritance"
     if (not bottom):
-        ET.SubElement(body,"hr")
+        ET.SubElement(body, "hr")
 
 
 
 
-def make_html_class_list(class_list,columns):
+def make_html_class_list(class_list, columns):
 
-    div=ET.Element("div")
-    div.attrib["class"]="ClassList";
+    div = ET.Element("div")
+    div.attrib["class"] = "ClassList";
 
-    h1=ET.SubElement(div,"h2")
-    h1.text="Alphabetical Class List"
+    h1 = ET.SubElement(div, "h2")
+    h1.text = "Alphabetical Class List"
 
-    table=ET.SubElement(div,"table")
-    table.attrib["class"]="class_table"
-    table.attrib["width"]="100%"
-    prev=0
+    table = ET.SubElement(div, "table")
+    table.attrib["class"] = "class_table"
+    table.attrib["width"] = "100%"
+    prev = 0
 
     col_max = len(class_list) / columns + 1
     print("col max is ", col_max)
     col_count = 0
     row_count = 0
     last_initial = ""
-    fit_columns=[]
+    fit_columns = []
 
-    for n in range(0,columns):
-        fit_columns+=[[]]
+    for n in range(0, columns):
+        fit_columns += [[]]
 
-    indexers=[]
-    last_initial=""
+    indexers = []
+    last_initial = ""
 
-    idx=0
+    idx = 0
     for n in class_list:
-        col = int(idx/col_max)
-        if (col>=columns):
-            col=columns-1
-        fit_columns[col]+=[n]
-        idx+=1
-        if (n[:1]!=last_initial):
-            indexers+=[n]
-            last_initial=n[:1]
-
-    row_max=0
-
-    for n in range(0,columns):
-        if (len(fit_columns[n])>row_max):
-            row_max=len(fit_columns[n])
-
-
-    for r in range(0,row_max):
-        tr = ET.SubElement(table,"tr")
-        for c in range(0,columns):
-            tdi = ET.SubElement(tr,"td")
-            tdi.attrib["align"]="right"
-            td = ET.SubElement(tr,"td")
-            if (r>=len(fit_columns[c])):
+        col = int(idx / col_max)
+        if (col >= columns):
+            col = columns - 1
+        fit_columns[col] += [n]
+        idx += 1
+        if (n[:1] != last_initial):
+            indexers += [n]
+            last_initial = n[:1]
+
+    row_max = 0
+
+    for n in range(0, columns):
+        if (len(fit_columns[n]) > row_max):
+            row_max = len(fit_columns[n])
+
+
+    for r in range(0, row_max):
+        tr = ET.SubElement(table, "tr")
+        for c in range(0, columns):
+            tdi = ET.SubElement(tr, "td")
+            tdi.attrib["align"] = "right"
+            td = ET.SubElement(tr, "td")
+            if (r >= len(fit_columns[c])):
                 continue
 
             classname = fit_columns[c][r]
@@ -147,17 +147,17 @@ def make_html_class_list(class_list,columns):
                 span.text = classname[:1].upper()
 
             if (single_page):
-                link="#"+classname
+                link = "#" + classname
             else:
-                link=classname+".html"
+                link = classname + ".html"
 
-            a=ET.SubElement(td,"a")
-            a.attrib["href"]=link
-            a.text=classname
+            a = ET.SubElement(td, "a")
+            a.attrib["href"] = link
+            a.text = classname
 
 
     if (not single_page):
-        cat_class_list=ET.Element("html")
+        cat_class_list = ET.Element("html")
         csscc = ET.SubElement(cat_class_list, "link")
         csscc.attrib["href"] = "main.css"
         csscc.attrib["rel"] = "stylesheet"
@@ -165,62 +165,62 @@ def make_html_class_list(class_list,columns):
         bodycc = ET.SubElement(cat_class_list, "body")
         make_html_top(bodycc)
 
-        cat_class_parent=bodycc
+        cat_class_parent = bodycc
     else:
-        cat_class_parent=div
+        cat_class_parent = div
 
 
 
 
-    h1=ET.SubElement(cat_class_parent,"h2")
-    h1.text="Class List By Category"
+    h1 = ET.SubElement(cat_class_parent, "h2")
+    h1.text = "Class List By Category"
 
-    class_cat_table={}
-    class_cat_list=[]
+    class_cat_table = {}
+    class_cat_list = []
 
     for c in class_list:
         clss = classes[c]
         if ("category" in clss.attrib):
-            class_cat=clss.attrib["category"]
+            class_cat = clss.attrib["category"]
         else:
-            class_cat="Core"
-        if (class_cat.find("/")!=-1):
-            class_cat=class_cat[class_cat.rfind("/")+1:]
+            class_cat = "Core"
+        if (class_cat.find("/") != -1):
+            class_cat = class_cat[class_cat.rfind("/") + 1:]
         if (not class_cat in class_cat_list):
             class_cat_list.append(class_cat)
-            class_cat_table[class_cat]=[]
+            class_cat_table[class_cat] = []
         class_cat_table[class_cat].append(c)
 
     class_cat_list.sort()
 
-    ct = ET.SubElement(cat_class_parent,"table")
+    ct = ET.SubElement(cat_class_parent, "table")
     for cl in class_cat_list:
         l = class_cat_table[cl]
         l.sort()
-        tr = ET.SubElement(ct,"tr")
-        tr.attrib["class"]="category_title"
-        td = ET.SubElement(ct,"td")
-        td.attrib["class"]="category_title"
+        tr = ET.SubElement(ct, "tr")
+        tr.attrib["class"] = "category_title"
+        td = ET.SubElement(ct, "td")
+        td.attrib["class"] = "category_title"
 
-        a = ET.SubElement(td,"a")
-        a.attrib["class"]="category_title"
-        a.text=cl
-        a.attrib["name"]="CATEGORY_"+cl
+        a = ET.SubElement(td, "a")
+        a.attrib["class"] = "category_title"
+        a.text = cl
+        a.attrib["name"] = "CATEGORY_" + cl
 
-        td = ET.SubElement(ct,"td")
-        td.attrib["class"]="category_title"
+        td = ET.SubElement(ct, "td")
+        td.attrib["class"] = "category_title"
 
         for clt in l:
-            tr = ET.SubElement(ct,"tr")
-            td = ET.SubElement(ct,"td")
-            make_type(clt,td)
-            clss=classes[clt]
+            tr = ET.SubElement(ct, "tr")
+            td = ET.SubElement(ct, "td")
+            make_type(clt, td)
+            clss = classes[clt]
             bd = clss.find("brief_description")
-            bdtext=""
-            if (bd!=None):
-                bdtext=bd.text
-            td = ET.SubElement(ct,"td")
-            td.text=bdtext
+            bdtext = ""
+            if (bd != None):
+                bdtext = bd.text
+            td = ET.SubElement(ct, "td")
+            td.text = bdtext
 
     if (not single_page):
         make_html_bottom(bodycc)
@@ -229,31 +229,31 @@ def make_html_class_list(class_list,columns):
 
 
     if (not single_page):
-        inh_class_list=ET.Element("html")
+        inh_class_list = ET.Element("html")
         cssic = ET.SubElement(inh_class_list, "link")
         cssic.attrib["href"] = "main.css"
         cssic.attrib["rel"] = "stylesheet"
         cssic.attrib["type"] = "text/css"
         bodyic = ET.SubElement(inh_class_list, "body")
         make_html_top(bodyic)
-        inh_class_parent=bodyic
+        inh_class_parent = bodyic
     else:
-        inh_class_parent=div
+        inh_class_parent = div
 
 
 
 
-    h1=ET.SubElement(inh_class_parent,"h2")
-    h1.text="Class List By Inheritance"
+    h1 = ET.SubElement(inh_class_parent, "h2")
+    h1.text = "Class List By Inheritance"
 
-    itemlist = ET.SubElement(inh_class_parent,"list")
+    itemlist = ET.SubElement(inh_class_parent, "list")
 
-    class_inh_table={}
+    class_inh_table = {}
 
     def add_class(clss):
         if (clss.attrib["name"] in class_inh_table):
-            return #already added
-        parent_list=None
+            return  # already added
+        parent_list = None
 
         if ("inherits" in clss.attrib):
             inhc = clss.attrib["inherits"]
@@ -262,20 +262,20 @@ def make_html_class_list(class_list,columns):
 
             parent_list = class_inh_table[inhc].find("div")
             if (parent_list == None):
-                parent_div = ET.SubElement(class_inh_table[inhc],"div")
-                parent_list = ET.SubElement(parent_div,"list")
-                parent_div.attrib["class"]="inh_class_list"
+                parent_div = ET.SubElement(class_inh_table[inhc], "div")
+                parent_list = ET.SubElement(parent_div, "list")
+                parent_div.attrib["class"] = "inh_class_list"
             else:
                 parent_list = parent_list.find("list")
 
 
         else:
-            parent_list=itemlist
+            parent_list = itemlist
 
-        item = ET.SubElement(parent_list,"li")
+        item = ET.SubElement(parent_list, "li")
 #   item.attrib["class"]="inh_class_list"
-        class_inh_table[clss.attrib["name"]]=item
-        make_type(clss.attrib["name"],item)
+        class_inh_table[clss.attrib["name"]] = item
+        make_type(clss.attrib["name"], item)
 
 
     for c in class_list:
@@ -290,98 +290,98 @@ def make_html_class_list(class_list,columns):
 
 
 
-    #h1=ET.SubElement(div,"h2")
+    # h1=ET.SubElement(div,"h2")
     #h1.text="Class List By Inheritance"
 
     return div
 
 
-def make_type(p_type,p_parent):
-    if (p_type=="RefPtr"):
-        p_type="Resource"
+def make_type(p_type, p_parent):
+    if (p_type == "RefPtr"):
+        p_type = "Resource"
 
     if (p_type in class_names):
-        a=ET.SubElement(p_parent,"a")
-        a.attrib["class"]="datatype_existing"
-        a.text=p_type+" "
+        a = ET.SubElement(p_parent, "a")
+        a.attrib["class"] = "datatype_existing"
+        a.text = p_type + " "
         if (single_page):
-            a.attrib["href"]="#"+p_type
+            a.attrib["href"] = "#" + p_type
         else:
-            a.attrib["href"]=p_type+".html"
+            a.attrib["href"] = p_type + ".html"
     else:
-        span=ET.SubElement(p_parent,"span")
-        span.attrib["class"]="datatype"
-        span.text=p_type+" "
+        span = ET.SubElement(p_parent, "span")
+        span.attrib["class"] = "datatype"
+        span.text = p_type + " "
 
 
 
-def make_text_def(class_name,parent,text):
+def make_text_def(class_name, parent, text):
     text = html_escape(text)
-    pos=0
+    pos = 0
     while(True):
-        pos = text.find("[",pos)
-        if (pos==-1):
+        pos = text.find("[", pos)
+        if (pos == -1):
             break
 
-        endq_pos=text.find("]",pos+1)
-        if (endq_pos==-1):
+        endq_pos = text.find("]", pos + 1)
+        if (endq_pos == -1):
             break
 
-        pre_text=text[:pos]
-        post_text=text[endq_pos+1:]
-        tag_text=text[pos+1:endq_pos]
+        pre_text = text[:pos]
+        post_text = text[endq_pos + 1:]
+        tag_text = text[pos + 1:endq_pos]
 
         if (tag_text in class_names):
             if (single_page):
-                tag_text='<a href="#'+tag_text+'">'+tag_text+'</a>'
+                tag_text = '<a href="#' + tag_text + '">' + tag_text + '</a>'
             else:
-                tag_text='<a href="'+tag_text+'.html">'+tag_text+'</a>'
-        else: #command
-            cmd=tag_text
-            space_pos=tag_text.find(" ")
-            if (cmd.find("html")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-                tag_text="<"+param+">"
-            elif(cmd.find("method")==0):
-                cmd=tag_text[:space_pos]
-                param=tag_text[space_pos+1:]
-
-                if (not single_page and param.find(".")!=-1):
-                    class_param,method_param=param.split(".")
-                    tag_text=tag_text='<a href="'+class_param+'.html#'+class_param+"_"+method_param+'">'+class_param+'.'+method_param+'()</a>'
+                tag_text = '<a href="' + tag_text + '.html">' + tag_text + '</a>'
+        else:  # command
+            cmd = tag_text
+            space_pos = tag_text.find(" ")
+            if (cmd.find("html") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+                tag_text = "<" + param + ">"
+            elif(cmd.find("method") == 0):
+                cmd = tag_text[:space_pos]
+                param = tag_text[space_pos + 1:]
+
+                if (not single_page and param.find(".") != -1):
+                    class_param, method_param = param.split(".")
+                    tag_text = tag_text = '<a href="' + class_param + '.html#' + class_param + "_" + method_param + '">' + class_param + '.' + method_param + '()</a>'
                 else:
-                    tag_text=tag_text='<a href="#'+class_name+"_"+param+'">'+class_name+'.'+param+'()</a>'
-            elif (cmd.find("image=")==0):
-                print("found image: "+cmd)
-                tag_text="<img src="+cmd[6:]+"/>"
-            elif (cmd.find("url=")==0):
-                tag_text="<a href="+cmd[4:]+">"
-            elif (cmd=="/url"):
-                tag_text="</a>"
-            elif (cmd=="center"):
-                tag_text="<div align=\"center\">"
-            elif (cmd=="/center"):
-                tag_text="</div>"
-            elif (cmd=="br"):
-                tag_text="<br/>"
-            elif (cmd=="i" or cmd=="/i" or cmd=="b" or cmd=="/b" or cmd=="u" or cmd=="/u"):
-                tag_text="<"+tag_text+">" #html direct mapping
+                    tag_text = tag_text = '<a href="#' + class_name + "_" + param + '">' + class_name + '.' + param + '()</a>'
+            elif (cmd.find("image=") == 0):
+                print("found image: " + cmd)
+                tag_text = "<img src=" + cmd[6:] + "/>"
+            elif (cmd.find("url=") == 0):
+                tag_text = "<a href=" + cmd[4:] + ">"
+            elif (cmd == "/url"):
+                tag_text = "</a>"
+            elif (cmd == "center"):
+                tag_text = "<div align=\"center\">"
+            elif (cmd == "/center"):
+                tag_text = "</div>"
+            elif (cmd == "br"):
+                tag_text = "<br/>"
+            elif (cmd == "i" or cmd == "/i" or cmd == "b" or cmd == "/b" or cmd == "u" or cmd == "/u"):
+                tag_text = "<" + tag_text + ">"  # html direct mapping
             else:
-                tag_text="["+tag_text+"]"
+                tag_text = "[" + tag_text + "]"
 
 
-        text=pre_text+tag_text+post_text
-        pos=len(pre_text)+len(tag_text)
+        text = pre_text + tag_text + post_text
+        pos = len(pre_text) + len(tag_text)
 
     #tnode = ET.SubElement(parent,"div")
-    #tnode.text=text
-    text="<div class=\"description\">"+text+"</div>"
+    # tnode.text=text
+    text = "<div class=\"description\">" + text + "</div>"
     try:
-        tnode=ET.XML(text)
+        tnode = ET.XML(text)
         parent.append(tnode)
     except:
-        print("Error parsing description text: '"+text+"'")
+        print("Error parsing description text: '" + text + "'")
         sys.exit(255)
 
 
@@ -390,292 +390,292 @@ def make_text_def(class_name,parent,text):
 
 
 
-def make_method_def(name,m,declare,event=False):
+def make_method_def(name, m, declare, event=False):
 
-    mdata={}
+    mdata = {}
 
 
     if (not declare):
-        div=ET.Element("tr")
-        div.attrib["class"]="method"
-        ret_parent=ET.SubElement(div,"td")
-        ret_parent.attrib["align"]="right"
-        func_parent=ET.SubElement(div,"td")
+        div = ET.Element("tr")
+        div.attrib["class"] = "method"
+        ret_parent = ET.SubElement(div, "td")
+        ret_parent.attrib["align"] = "right"
+        func_parent = ET.SubElement(div, "td")
     else:
-        div=ET.Element("div")
-        div.attrib["class"]="method"
-        ret_parent=div
-        func_parent=div
-
-    mdata["argidx"]=[]
-    mdata["name"]=m.attrib["name"]
-    qualifiers=""
+        div = ET.Element("div")
+        div.attrib["class"] = "method"
+        ret_parent = div
+        func_parent = div
+
+    mdata["argidx"] = []
+    mdata["name"] = m.attrib["name"]
+    qualifiers = ""
     if ("qualifiers" in m.attrib):
-        qualifiers=m.attrib["qualifiers"]
+        qualifiers = m.attrib["qualifiers"]
 
-    args=list(m)
+    args = list(m)
     for a in args:
-        if (a.tag=="return"):
-            idx=-1
-        elif (a.tag=="argument"):
-            idx=int(a.attrib["index"])
+        if (a.tag == "return"):
+            idx = -1
+        elif (a.tag == "argument"):
+            idx = int(a.attrib["index"])
         else:
             continue
 
         mdata["argidx"].append(idx)
-        mdata[idx]=a
+        mdata[idx] = a
 
     if (not event):
         if (-1 in mdata["argidx"]):
-            make_type(mdata[-1].attrib["type"],ret_parent)
+            make_type(mdata[-1].attrib["type"], ret_parent)
             mdata["argidx"].remove(-1)
         else:
-            make_type("void",ret_parent)
+            make_type("void", ret_parent)
 
-    span=ET.SubElement(func_parent,"span")
+    span = ET.SubElement(func_parent, "span")
     if (declare):
-        span.attrib["class"]="funcdecl"
-        a=ET.SubElement(span,"a")
-        a.attrib["name"]=name+"_"+m.attrib["name"]
-        a.text=name+"::"+m.attrib["name"]
+        span.attrib["class"] = "funcdecl"
+        a = ET.SubElement(span, "a")
+        a.attrib["name"] = name + "_" + m.attrib["name"]
+        a.text = name + "::" + m.attrib["name"]
     else:
-        span.attrib["class"]="identifier funcdef"
-        a=ET.SubElement(span,"a")
-        a.attrib["href"]="#"+name+"_"+m.attrib["name"]
-        a.text=m.attrib["name"]
+        span.attrib["class"] = "identifier funcdef"
+        a = ET.SubElement(span, "a")
+        a.attrib["href"] = "#" + name + "_" + m.attrib["name"]
+        a.text = m.attrib["name"]
 
-    span=ET.SubElement(func_parent,"span")
-    span.attrib["class"]="symbol"
-    span.text=" ("
+    span = ET.SubElement(func_parent, "span")
+    span.attrib["class"] = "symbol"
+    span.text = " ("
 
     for a in mdata["argidx"]:
-        arg=mdata[a]
-        if (a>0):
-            span=ET.SubElement(func_parent,"span")
-            span.text=", "
+        arg = mdata[a]
+        if (a > 0):
+            span = ET.SubElement(func_parent, "span")
+            span.text = ", "
         else:
-            span=ET.SubElement(func_parent,"span")
-            span.text=" "
+            span = ET.SubElement(func_parent, "span")
+            span.text = " "
 
 
-        make_type(arg.attrib["type"],func_parent)
+        make_type(arg.attrib["type"], func_parent)
 
-        span=ET.SubElement(func_parent,"span")
-        span.text=arg.attrib["name"]
+        span = ET.SubElement(func_parent, "span")
+        span.text = arg.attrib["name"]
         if ("default" in arg.attrib):
-            span.text=span.text+"="+arg.attrib["default"]
+            span.text = span.text + "=" + arg.attrib["default"]
 
 
-    span=ET.SubElement(func_parent,"span")
-    span.attrib["class"]="symbol"
+    span = ET.SubElement(func_parent, "span")
+    span.attrib["class"] = "symbol"
     if (len(mdata["argidx"])):
-        span.text=" )"
+        span.text = " )"
     else:
-        span.text=")"
+        span.text = ")"
 
     if (qualifiers):
-        span=ET.SubElement(func_parent,"span")
-        span.attrib["class"]="qualifier"
-        span.text=" "+qualifiers
+        span = ET.SubElement(func_parent, "span")
+        span.attrib["class"] = "qualifier"
+        span.text = " " + qualifiers
 
     return div
 
 
 def make_html_class(node):
 
-    div=ET.Element("div")
-    div.attrib["class"]="class";
+    div = ET.Element("div")
+    div.attrib["class"] = "class";
 
-    a=ET.SubElement(div,"a")
-    a.attrib["name"]=node.attrib["name"]
+    a = ET.SubElement(div, "a")
+    a.attrib["name"] = node.attrib["name"]
 
-    h3=ET.SubElement(a,"h3")
-    h3.attrib["class"]="title class_title"
-    h3.text=node.attrib["name"]
+    h3 = ET.SubElement(a, "h3")
+    h3.attrib["class"] = "title class_title"
+    h3.text = node.attrib["name"]
 
     briefd = node.find("brief_description")
-    if (briefd!=None):
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="description class_description"
-        div2.text=briefd.text
+    if (briefd != None):
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "description class_description"
+        div2.text = briefd.text
 
     if ("inherits" in node.attrib):
-        ET.SubElement(div,"br")
+        ET.SubElement(div, "br")
 
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="inheritance";
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "inheritance";
 
-        span=ET.SubElement(div2,"span")
-        span.text="Inherits: "
+        span = ET.SubElement(div2, "span")
+        span.text = "Inherits: "
 
-        make_type(node.attrib["inherits"],div2)
+        make_type(node.attrib["inherits"], div2)
 
     if ("category" in node.attrib):
-        ET.SubElement(div,"br")
+        ET.SubElement(div, "br")
 
-        div3=ET.SubElement(div,"div")
-        div3.attrib["class"]="category";
+        div3 = ET.SubElement(div, "div")
+        div3.attrib["class"] = "category";
 
-        span=ET.SubElement(div3,"span")
-        span.attrib["class"]="category"
-        span.text="Category: "
+        span = ET.SubElement(div3, "span")
+        span.attrib["class"] = "category"
+        span.text = "Category: "
 
-        a = ET.SubElement(div3,"a")
-        a.attrib["class"]="category_ref"
-        a.text=node.attrib["category"]
-        catname=a.text
-        if (catname.rfind("/")!=-1):
-            catname=catname[catname.rfind("/"):]
-        catname="CATEGORY_"+catname
+        a = ET.SubElement(div3, "a")
+        a.attrib["class"] = "category_ref"
+        a.text = node.attrib["category"]
+        catname = a.text
+        if (catname.rfind("/") != -1):
+            catname = catname[catname.rfind("/"):]
+        catname = "CATEGORY_" + catname
 
         if (single_page):
-            a.attrib["href"]="#"+catname
+            a.attrib["href"] = "#" + catname
         else:
-            a.attrib["href"]="category.html#"+catname
+            a.attrib["href"] = "category.html#" + catname
 
 
     methods = node.find("methods")
 
-    if(methods!=None and len(list(methods))>0):
+    if(methods != None and len(list(methods)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Public Methods:"
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Public Methods:"
 
-        method_table=ET.SubElement(div,"table")
-        method_table.attrib["class"]="method_list";
+        method_table = ET.SubElement(div, "table")
+        method_table.attrib["class"] = "method_list";
 
         for m in list(methods):
             #li = ET.SubElement(div2, "li")
-            method_table.append( make_method_def(node.attrib["name"],m,False) )
+            method_table.append(make_method_def(node.attrib["name"], m, False))
 
     events = node.find("signals")
 
-    if(events!=None and len(list(events))>0):
-        h4=ET.SubElement(div,"h4")
-        h4.text="Events:"
+    if(events != None and len(list(events)) > 0):
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Events:"
 
-        event_table=ET.SubElement(div,"table")
-        event_table.attrib["class"]="method_list";
+        event_table = ET.SubElement(div, "table")
+        event_table.attrib["class"] = "method_list";
 
         for m in list(events):
             #li = ET.SubElement(div2, "li")
-            event_table.append( make_method_def(node.attrib["name"],m,False,True) )
+            event_table.append(make_method_def(node.attrib["name"], m, False, True))
 
 
     members = node.find("members")
-    if(members!=None and len(list(members))>0):
+    if(members != None and len(list(members)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Public Variables:"
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="member_list";
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Public Variables:"
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "member_list";
 
         for c in list(members):
 
             li = ET.SubElement(div2, "li")
-            div3=ET.SubElement(li,"div")
-            div3.attrib["class"]="member";
-            make_type(c.attrib["type"],div3)
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="identifier member_name"
-            span.text=" "+c.attrib["name"]+" "
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="member_description"
-            span.text=c.text
+            div3 = ET.SubElement(li, "div")
+            div3.attrib["class"] = "member";
+            make_type(c.attrib["type"], div3)
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "identifier member_name"
+            span.text = " " + c.attrib["name"] + " "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "member_description"
+            span.text = c.text
 
 
     constants = node.find("constants")
-    if(constants!=None and len(list(constants))>0):
+    if(constants != None and len(list(constants)) > 0):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Constants:"
-        div2=ET.SubElement(div,"div")
-        div2.attrib["class"]="constant_list";
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Constants:"
+        div2 = ET.SubElement(div, "div")
+        div2.attrib["class"] = "constant_list";
 
         for c in list(constants):
             li = ET.SubElement(div2, "li")
-            div3=ET.SubElement(li,"div")
-            div3.attrib["class"]="constant";
+            div3 = ET.SubElement(li, "div")
+            div3.attrib["class"] = "constant";
 
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="identifier constant_name"
-            span.text=c.attrib["name"]+" "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "identifier constant_name"
+            span.text = c.attrib["name"] + " "
             if ("value" in c.attrib):
-                span=ET.SubElement(div3,"span")
-                span.attrib["class"]="symbol"
-                span.text="= "
-                span=ET.SubElement(div3,"span")
-                span.attrib["class"]="constant_value"
-                span.text=c.attrib["value"]+" "
-            span=ET.SubElement(div3,"span")
-            span.attrib["class"]="constant_description"
-            span.text=c.text
+                span = ET.SubElement(div3, "span")
+                span.attrib["class"] = "symbol"
+                span.text = "= "
+                span = ET.SubElement(div3, "span")
+                span.attrib["class"] = "constant_value"
+                span.text = c.attrib["value"] + " "
+            span = ET.SubElement(div3, "span")
+            span.attrib["class"] = "constant_description"
+            span.text = c.text
 
 #  ET.SubElement(div,"br")
 
 
-    descr=node.find("description")
-    if (descr!=None and descr.text.strip()!=""):
-        h4=ET.SubElement(div,"h4")
-        h4.text="Description:"
+    descr = node.find("description")
+    if (descr != None and descr.text.strip() != ""):
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Description:"
 
-        make_text_def(node.attrib["name"],div,descr.text)
+        make_text_def(node.attrib["name"], div, descr.text)
 #   div2=ET.SubElement(div,"div")
 #   div2.attrib["class"]="description";
 #   div2.text=descr.text
 
 
 
-    if(methods!=None or events!=None):
+    if(methods != None or events != None):
 
-        h4=ET.SubElement(div,"h4")
-        h4.text="Method Documentation:"
+        h4 = ET.SubElement(div, "h4")
+        h4.text = "Method Documentation:"
         iter_list = []
-        if (methods!=None):
-            iter_list+=list(methods)
-        if (events!=None):
-            iter_list+=list(events)
+        if (methods != None):
+            iter_list += list(methods)
+        if (events != None):
+            iter_list += list(events)
 
         for m in iter_list:
 
-            descr=m.find("description")
+            descr = m.find("description")
 
-            if (descr==None or descr.text.strip()==""):
+            if (descr == None or descr.text.strip() == ""):
                 continue;
 
-            div2=ET.SubElement(div,"div")
-            div2.attrib["class"]="method_doc";
+            div2 = ET.SubElement(div, "div")
+            div2.attrib["class"] = "method_doc";
 
 
-            div2.append( make_method_def(node.attrib["name"],m,True) )
+            div2.append(make_method_def(node.attrib["name"], m, True))
             #anchor = ET.SubElement(div2, "a")
-            #anchor.attrib["name"] =
-            make_text_def(node.attrib["name"],div2,descr.text)
-            #div3=ET.SubElement(div2,"div")
-            #div3.attrib["class"]="description";
-            #div3.text=descr.text
+            # anchor.attrib["name"] =
+            make_text_def(node.attrib["name"], div2, descr.text)
+            # div3=ET.SubElement(div2,"div")
+            # div3.attrib["class"]="description";
+            # div3.text=descr.text
 
 
     return div
 
-class_names=[]
-classes={}
+class_names = []
+classes = {}
 
 for file in input_list:
     tree = ET.parse(file)
-    doc=tree.getroot()
+    doc = tree.getroot()
 
     if ("version" not in doc.attrib):
         print("Version missing from 'doc'")
         sys.exit(255)
 
-        version=doc.attrib["version"]
+        version = doc.attrib["version"]
 
     for c in list(doc):
         if (c.attrib["name"] in class_names):
             continue
         class_names.append(c.attrib["name"])
-        classes[c.attrib["name"]]=c
+        classes[c.attrib["name"]] = c
 
 html = ET.Element("html")
 css = ET.SubElement(html, "link")
@@ -691,24 +691,24 @@ if (not single_page):
 
 class_names.sort()
 
-body.append( make_html_class_list(class_names,5) )
+body.append(make_html_class_list(class_names, 5))
 
 for cn in class_names:
-    c=classes[cn]
+    c = classes[cn]
     if (single_page):
-        body.append( make_html_class(c))
+        body.append(make_html_class(c))
     else:
         html2 = ET.Element("html")
         css = ET.SubElement(html2, "link")
         css.attrib["href"] = "main.css"
         css.attrib["rel"] = "stylesheet"
         css.attrib["type"] = "text/css"
-        body2 = ET.SubElement(html2, "body" )
+        body2 = ET.SubElement(html2, "body")
         make_html_top(body2)
-        body2.append( make_html_class(c) );
+        body2.append(make_html_class(c));
         make_html_bottom(body2)
         et_out = ET.ElementTree(html2)
-        et_out.write(c.attrib["name"]+".html")
+        et_out.write(c.attrib["name"] + ".html")
 
 
 et_out = ET.ElementTree(html)
diff --git a/doc/tools/makemd.py b/doc/tools/makemd.py
index 2c9d697039..0693291f35 100644
--- a/doc/tools/makemd.py
+++ b/doc/tools/makemd.py
@@ -82,7 +82,7 @@ def make_class_list(class_list, columns):
             else:
                 s += ' | '
 
-            s += '[' + classname + '](class_'+ classname.lower()+') | '
+            s += '[' + classname + '](class_' + classname.lower() + ') | '
 
         s += '\n'
         f.write(s)
@@ -126,14 +126,14 @@ def dokuize_text(text):
 
                 if param.find('.') != -1:
                     (class_param, method_param) = param.split('.')
-                    tag_text = '['+class_param+'.'+method_param.replace("_","&#95;")+'](' + class_param.lower() + '#' \
+                    tag_text = '[' + class_param + '.' + method_param.replace("_", "&#95;") + '](' + class_param.lower() + '#' \
                         + method_param + ')'
                 else:
-                    tag_text = '[' + param.replace("_","&#95;") + '](#' + param + ')'
+                    tag_text = '[' + param.replace("_", "&#95;") + '](#' + param + ')'
             elif cmd.find('image=') == 0:
                 tag_text = '![](' + cmd[6:] + ')'
             elif cmd.find('url=') == 0:
-                tag_text = '[' + cmd[4:] + ']('+cmd[4:]
+                tag_text = '[' + cmd[4:] + '](' + cmd[4:]
             elif cmd == '/url':
                 tag_text = ')'
             elif cmd == 'center':
@@ -205,9 +205,9 @@ def make_method(
         # a.attrib["name"]=name+"_"+m.attrib["name"]
         # a.text=name+"::"+m.attrib["name"]
 
-        s += ' **'+m.attrib['name'].replace("_","&#95;")+'** '
+        s += ' **' + m.attrib['name'].replace("_", "&#95;") + '** '
     else:
-        s += ' **['+ m.attrib['name'].replace("_","&#95;")+'](#' + m.attrib['name'] + ')** '
+        s += ' **[' + m.attrib['name'].replace("_", "&#95;") + '](#' + m.attrib['name'] + ')** '
 
     s += ' **(**'
     argfound = False
@@ -245,13 +245,13 @@ def make_doku_class(node):
 
     name = node.attrib['name']
 
-    f = open("class_"+name.lower() + '.md', 'wb')
+    f = open("class_" + name.lower() + '.md', 'wb')
 
     f.write('#  ' + name + '  \n')
 
     if 'inherits' in node.attrib:
         inh = node.attrib['inherits'].strip()
-        f.write('####**Inherits:** '+make_type(inh)+'\n')
+        f.write('####**Inherits:** ' + make_type(inh) + '\n')
     if 'category' in node.attrib:
         f.write('####**Category:** ' + node.attrib['category'].strip()
                 + '\n')
@@ -313,7 +313,7 @@ def make_doku_class(node):
             d = m.find('description')
             if d == None or d.text.strip() == '':
                 continue
-            f.write('\n#### <a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n')
+            f.write('\n#### <a name="' + m.attrib['name'] + '">' + m.attrib['name'] + '</a>\n')
             make_method(f, node.attrib['name'], m, True)
             f.write('\n')
             f.write(dokuize_text(d.text.strip()))
diff --git a/doc/tools/makerst.py b/doc/tools/makerst.py
index 583f9afeaa..2f3b9c269d 100644
--- a/doc/tools/makerst.py
+++ b/doc/tools/makerst.py
@@ -24,11 +24,11 @@ def validate_tag(elem, tag):
 class_names = []
 classes = {}
 
-def ul_string(str,ul):
-    str+="\n"
-    for i in range(len(str)-1):
-        str+=ul
-    str+="\n"
+def ul_string(str, ul):
+    str += "\n"
+    for i in range(len(str) - 1):
+        str += ul
+    str += "\n"
     return str
 
 def make_class_list(class_list, columns):
@@ -89,7 +89,7 @@ def make_class_list(class_list, columns):
             else:
                 s += ' | '
 
-            s += '[' + classname + '](class_'+ classname.lower()+') | '
+            s += '[' + classname + '](class_' + classname.lower() + ') | '
 
         s += '\n'
         f.write(s)
@@ -99,7 +99,7 @@ def make_class_list(class_list, columns):
     f.write("\n")
 
 
-def rstize_text(text,cclass):
+def rstize_text(text, cclass):
 
     # Linebreak + tabs in the XML should become two line breaks unless in a "codeblock"
     pos = 0
@@ -109,9 +109,9 @@ def rstize_text(text,cclass):
             break
 
         pre_text = text[:pos]
-        while text[pos+1] == '\t':
+        while text[pos + 1] == '\t':
             pos += 1
-        post_text = text[pos+1:]
+        post_text = text[pos + 1:]
 
         # Handle codeblocks
         if post_text.startswith("[codeblock]"):
@@ -130,14 +130,14 @@ def rstize_text(text,cclass):
                     break
 
                 to_skip = 0
-                while code_pos+to_skip+1 < len(code_text) and code_text[code_pos+to_skip+1] == '\t':
+                while code_pos + to_skip + 1 < len(code_text) and code_text[code_pos + to_skip + 1] == '\t':
                     to_skip += 1
 
-                if len(code_text[code_pos+to_skip+1:])==0:
+                if len(code_text[code_pos + to_skip + 1:]) == 0:
                     code_text = code_text[:code_pos] + "\n"
                     code_pos += 1
                 else:
-                    code_text = code_text[:code_pos] + "\n    " + code_text[code_pos+to_skip+1:]
+                    code_text = code_text[:code_pos] + "\n    " + code_text[code_pos + to_skip + 1:]
                     code_pos += 5 - to_skip
 
             text = pre_text + "\n[codeblock]" + code_text + post_text
@@ -163,7 +163,7 @@ def rstize_text(text,cclass):
         pos = text.find('_', pos)
         if pos == -1:
             break
-        if not text[pos + 1].isalnum(): # don't escape within a snake_case word
+        if not text[pos + 1].isalnum():  # don't escape within a snake_case word
             text = text[:pos] + "\_" + text[pos + 1:]
             pos += 2
         else:
@@ -186,7 +186,7 @@ def rstize_text(text,cclass):
 
         if tag_text in class_names:
             tag_text = make_type(tag_text)
-        else: # command
+        else:  # command
             cmd = tag_text
             space_pos = tag_text.find(' ')
             if cmd.find('html') == 0:
@@ -199,13 +199,13 @@ def rstize_text(text,cclass):
 
                 if param.find('.') != -1:
                     (class_param, method_param) = param.split('.')
-                    tag_text = ':ref:`'+class_param+'.'+method_param+'<class_' + class_param + '_' + method_param + '>`'
+                    tag_text = ':ref:`' + class_param + '.' + method_param + '<class_' + class_param + '_' + method_param + '>`'
                 else:
-                    tag_text = ':ref:`' + param + '<class_' + cclass +"_"+ param + '>`'
+                    tag_text = ':ref:`' + param + '<class_' + cclass + "_" + param + '>`'
             elif cmd.find('image=') == 0:
-                tag_text = "" #'![](' + cmd[6:] + ')'
+                tag_text = ""  # '![](' + cmd[6:] + ')'
             elif cmd.find('url=') == 0:
-                tag_text = ':ref:`' + cmd[4:] + '<'+cmd[4:]+">`"
+                tag_text = ':ref:`' + cmd[4:] + '<' + cmd[4:] + ">`"
             elif cmd == '/url':
                 tag_text = ')'
             elif cmd == 'center':
@@ -234,7 +234,7 @@ def rstize_text(text,cclass):
             elif cmd == 'code' or cmd == '/code':
                 tag_text = '``'
             else:
-                tag_text = ':ref:`' + tag_text + '<class_'+tag_text.lower()+'>`'
+                tag_text = ':ref:`' + tag_text + '<class_' + tag_text.lower() + '>`'
 
         text = pre_text + tag_text + post_text
         pos = len(pre_text) + len(tag_text)
@@ -248,7 +248,7 @@ def rstize_text(text,cclass):
 def make_type(t):
     global class_names
     if t in class_names:
-        return ':ref:`'+t+'<class_' + t.lower()+'>`'
+        return ':ref:`' + t + '<class_' + t.lower() + '>`'
     return t
 
 
@@ -262,7 +262,7 @@ def make_method(
         pp=None
 ):
 
-    if (declare or pp==None):
+    if (declare or pp == None):
         t = '- '
     else:
         t = ""
@@ -289,16 +289,16 @@ def make_method(
             t += 'void'
         t += ' '
 
-    if declare or pp==None:
+    if declare or pp == None:
 
         # span.attrib["class"]="funcdecl"
         # a=ET.SubElement(span,"a")
         # a.attrib["name"]=name+"_"+m.attrib["name"]
         # a.text=name+"::"+m.attrib["name"]
 
-        s = ' **'+m.attrib['name']+'** '
+        s = ' **' + m.attrib['name'] + '** '
     else:
-        s = ':ref:`'+ m.attrib['name']+'<class_' + cname+"_"+m.attrib['name'] + '>` '
+        s = ':ref:`' + m.attrib['name'] + '<class_' + cname + "_" + m.attrib['name'] + '>` '
 
     s += ' **(**'
     argfound = False
@@ -331,16 +331,16 @@ def make_method(
 
 #	f.write(s)
     if (not declare):
-        if (pp!=None):
-            pp.append( (t,s) )
+        if (pp != None):
+            pp.append((t, s))
         else:
-            f.write("- "+t+" "+s+"\n")
+            f.write("- " + t + " " + s + "\n")
     else:
-        f.write(t+s+"\n")
+        f.write(t + s + "\n")
 
 
 def make_heading(title, underline):
-    return title + '\n' + underline*len(title) + "\n\n"
+    return title + '\n' + underline * len(title) + "\n\n"
 
 
 
@@ -348,47 +348,47 @@ def make_rst_class(node):
 
     name = node.attrib['name']
 
-    f = codecs.open("class_"+name.lower() + '.rst', 'wb', 'utf-8')
+    f = codecs.open("class_" + name.lower() + '.rst', 'wb', 'utf-8')
 
     # Warn contributors not to edit this file directly
     f.write(".. Generated automatically by doc/tools/makerst.py in Godot's source tree.\n")
     f.write(".. DO NOT EDIT THIS FILE, but the doc/base/classes.xml source instead.\n\n")
 
-    f.write(".. _class_"+name+":\n\n")
+    f.write(".. _class_" + name + ":\n\n")
     f.write(make_heading(name, '='))
 
     if 'inherits' in node.attrib:
         inh = node.attrib['inherits'].strip()
 #		whle inh in classes[cn]
         f.write('**Inherits:** ')
-        first=True
+        first = True
         while(inh in classes):
             if (not first):
                 f.write(" **<** ")
             else:
-                first=False
+                first = False
 
             f.write(make_type(inh))
             inode = classes[inh]
             if ('inherits' in inode.attrib):
-                inh=inode.attrib['inherits'].strip()
+                inh = inode.attrib['inherits'].strip()
             else:
-                inh=None
+                inh = None
 
 
         f.write("\n\n")
 
-    inherited=[]
+    inherited = []
     for cn in classes:
-        c=classes[cn]
+        c = classes[cn]
         if 'inherits' in c.attrib:
-            if (c.attrib['inherits'].strip()==name):
+            if (c.attrib['inherits'].strip() == name):
                 inherited.append(c.attrib['name'])
 
     if (len(inherited)):
         f.write('**Inherited By:** ')
         for i in range(len(inherited)):
-            if (i>0):
+            if (i > 0):
                 f.write(", ")
             f.write(make_type(inherited[i]))
         f.write("\n\n")
@@ -398,41 +398,41 @@ def make_rst_class(node):
     f.write(make_heading('Brief Description', '-'))
     briefd = node.find('brief_description')
     if briefd != None:
-        f.write(rstize_text(briefd.text.strip(),name) + "\n\n")
+        f.write(rstize_text(briefd.text.strip(), name) + "\n\n")
 
     methods = node.find('methods')
 
     if methods != None and len(list(methods)) > 0:
         f.write(make_heading('Member Functions', '-'))
-        ml=[]
+        ml = []
         for m in list(methods):
-            make_method(f, node.attrib['name'], m, False,name,False,ml)
+            make_method(f, node.attrib['name'], m, False, name, False, ml)
         longest_t = 0
         longest_s = 0
         for s in ml:
             sl = len(s[0])
-            if (sl>longest_s):
-                longest_s=sl
+            if (sl > longest_s):
+                longest_s = sl
             tl = len(s[1])
-            if (tl>longest_t):
-                longest_t=tl
-
-        sep="+"
-        for i in range(longest_s+2):
-            sep+="-"
-        sep+="+"
-        for i in range(longest_t+2):
-            sep+="-"
-        sep+="+\n"
+            if (tl > longest_t):
+                longest_t = tl
+
+        sep = "+"
+        for i in range(longest_s + 2):
+            sep += "-"
+        sep += "+"
+        for i in range(longest_t + 2):
+            sep += "-"
+        sep += "+\n"
         f.write(sep)
         for s in ml:
             rt = s[0]
-            while( len(rt) < longest_s ):
-                rt+=" "
+            while(len(rt) < longest_s):
+                rt += " "
             st = s[1]
-            while( len(st) < longest_t ):
-                st+=" "
-            f.write("| "+rt+" | "+st+" |\n")
+            while(len(st) < longest_t):
+                st += " "
+            f.write("| " + rt + " | " + st + " |\n")
             f.write(sep)
         f.write('\n')
 
@@ -441,7 +441,7 @@ def make_rst_class(node):
     if events != None and len(list(events)) > 0:
         f.write(make_heading('Signals', '-'))
         for m in list(events):
-            make_method(f, node.attrib['name'], m, True,name, True)
+            make_method(f, node.attrib['name'], m, True, name, True)
         f.write('\n')
 
     members = node.find('members')
@@ -466,28 +466,28 @@ def make_rst_class(node):
             if 'value' in c.attrib:
                 s += ' = **' + c.attrib['value'] + '**'
             if c.text.strip() != '':
-                s += ' --- ' + rstize_text(c.text.strip(),name)
+                s += ' --- ' + rstize_text(c.text.strip(), name)
             f.write(s + '\n')
         f.write('\n')
 
     descr = node.find('description')
     if descr != None and descr.text.strip() != '':
         f.write(make_heading('Description', '-'))
-        f.write(rstize_text(descr.text.strip(),name) + "\n\n")
+        f.write(rstize_text(descr.text.strip(), name) + "\n\n")
 
     methods = node.find('methods')
     if methods != None and len(list(methods)) > 0:
         f.write(make_heading('Member Function Description', '-'))
         for m in list(methods):
-            f.write(".. _class_"+name+"_"+m.attrib['name']+":\n\n")
+            f.write(".. _class_" + name + "_" + m.attrib['name'] + ":\n\n")
 #			f.write(ul_string(m.attrib['name'],"^"))
             #f.write('\n<a name="'+m.attrib['name']+'">' + m.attrib['name'] + '</a>\n------\n')
-            make_method(f, node.attrib['name'], m, True,name)
+            make_method(f, node.attrib['name'], m, True, name)
             f.write('\n')
             d = m.find('description')
             if d == None or d.text.strip() == '':
                 continue
-            f.write(rstize_text(d.text.strip(),name))
+            f.write(rstize_text(d.text.strip(), name))
             f.write("\n\n")
         f.write('\n')
 
@@ -510,7 +510,7 @@ for file in input_list:
 
 class_names.sort()
 
-#Don't make class list for Sphinx, :toctree: handles it
+# Don't make class list for Sphinx, :toctree: handles it
 #make_class_list(class_names, 2)
 
 for cn in class_names: