diff --git a/files/FolderSplit.py b/files/FolderSplit.py
index 44616ec..dbe810b 100755
--- a/files/FolderSplit.py
+++ b/files/FolderSplit.py
@@ -1,41 +1,79 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
-import os,sys
-import math,shutil,re
+import os, sys
+import math, shutil, re
 from random import shuffle
 
-VERSION="0.1"
+VERSION = "0.1"
+
 
 def setup_options():
-    ''' Setup the command line options '''
+    """ Setup the command line options """
     from argparse import ArgumentParser
 
-    parser=ArgumentParser(description="Splits files to subfolders equally.")
-    
-    parser.add_argument("--order",'-o',type=str,action='store', dest='order',default="sequence",
-                      help="Splitting method.",
-                      choices=['sequence','sparse','regexp','random'])
-    parser.add_argument("-m",action='store_true', dest='move',default=False,
-                      help="Move entries instead of hardlink.")
-    parser.add_argument("-f",action='store_true', dest='files',default=False,
-                      help="Split files only, skipping folders")
-    parser.add_argument("-r",'--regexp',type=str,action='store', dest='regexp',default="",
-                      help="Regular expression for splitting. When set, order regexp used, -n not used.")
-    parser.add_argument("-n",'-N',type=int,action='store', dest='n',
-                      help="Number of subfolders to split into.")                      
-    parser.add_argument("path",type=str,action="store",default=".",nargs="?",
-                      help="Folder to split.")
-    options=parser.parse_args()
-    if options.n==None and options.regexp=="":
+    parser = ArgumentParser(description="Splits files to subfolders equally.")
+
+    parser.add_argument(
+        "--order",
+        "-o",
+        type=str,
+        action="store",
+        dest="order",
+        default="sequence",
+        help="Splitting method.",
+        choices=["sequence", "sparse", "regexp", "random"],
+    )
+    parser.add_argument(
+        "-m",
+        action="store_true",
+        dest="move",
+        default=False,
+        help="Move entries instead of hardlink.",
+    )
+    parser.add_argument(
+        "-f",
+        action="store_true",
+        dest="files",
+        default=False,
+        help="Split files only, skipping folders",
+    )
+    parser.add_argument(
+        "-r",
+        "--regexp",
+        type=str,
+        action="store",
+        dest="regexp",
+        default="",
+        help="Regular expression for splitting. When set, order regexp used, -n not used.",
+    )
+    parser.add_argument(
+        "-n",
+        "-N",
+        type=int,
+        action="store",
+        dest="n",
+        help="Number of subfolders to split into.",
+    )
+    parser.add_argument(
+        "path",
+        type=str,
+        action="store",
+        default=".",
+        nargs="?",
+        help="Folder to split.",
+    )
+    options = parser.parse_args()
+    if options.n == None and options.regexp == "":
         parser.print_help()
         parser.error("Either -n or -r must be passed")
-    if options.regexp!="":
-        options.order="regexp"
+    if options.regexp != "":
+        options.order = "regexp"
     return options
 
+
 def linktree(src, dst):
     """Recursively link a directory tree using os.link.
-       Modified from shutil.copytree 
+    Modified from shutil.copytree
     """
     names = os.listdir(src)
     os.makedirs(dst)
@@ -49,116 +87,124 @@ def linktree(src, dst):
             else:
                 # Will raise a SpecialFileError for unsupported file types
                 os.link(srcname, dstname)
-        except Error, err:
+        except Error as err:
             errors.extend(err.args[0])
-        except EnvironmentError, why:
+        except EnvironmentError as why:
             errors.append((srcname, dstname, str(why)))
 
     if errors:
-        raise Error, errors
+        raise Error(errors)
 
-def copyfileorfolder(basename,source,target,move):
-    ''' Copies a file or folder structure under target folder '''
+
+def copyfileorfolder(basename, source, target, move):
+    """ Copies a file or folder structure under target folder """
     if move:
-        shutil.move(os.path.join(source,basename),os.path.join(target,basename))
+        shutil.move(os.path.join(source, basename), os.path.join(target, basename))
         return
-    if os.path.isfile(os.path.join(source,basename)):
-        os.link(os.path.join(source,basename),os.path.join(target,basename))
+    if os.path.isfile(os.path.join(source, basename)):
+        os.link(os.path.join(source, basename), os.path.join(target, basename))
         return
-    if os.path.isdir(os.path.join(source,basename)):
-        linktree(os.path.join(source,basename),os.path.join(target,basename))
+    if os.path.isdir(os.path.join(source, basename)):
+        linktree(os.path.join(source, basename), os.path.join(target, basename))
         return
-    raise RuntimeError(source+' was neither file nor folder.')
+    raise RuntimeError(source + " was neither file nor folder.")
 
-def portorder(inFiles,inFolder,outFolders,N,link):
-    ''' Copy files in port order (sparse) '''
-    outidx=0
+
+def portorder(inFiles, inFolder, outFolders, N, link):
+    """ Copy files in port order (sparse) """
+    outidx = 0
     for row in inFiles:
-        copyfileorfolder(row,inFolder,outFolders[outidx],link)
-        outidx+=1
-        if outidx+1>N:
-            outidx=0
+        copyfileorfolder(row, inFolder, outFolders[outidx], link)
+        outidx += 1
+        if outidx + 1 > N:
+            outidx = 0
 
-def fileorder(inFiles,inFolder,outFolders,N,link):
-    ''' Copy files in input file order (sequnce)  '''
 
-    bins=[int(math.floor(float(len(inFiles))/float(N)))]*int(N)
-    binidx=0
-    while sum(bins)<len(inFiles):
-        bins[binidx]+=1
-        binidx+=1
-    offsets=list(offset(bins))
-    offsets.insert(0,0)
+def fileorder(inFiles, inFolder, outFolders, N, link):
+    """ Copy files in input file order (sequnce)  """
+
+    bins = [int(math.floor(float(len(inFiles)) / float(N)))] * int(N)
+    binidx = 0
+    while sum(bins) < len(inFiles):
+        bins[binidx] += 1
+        binidx += 1
+    offsets = list(offset(bins))
+    offsets.insert(0, 0)
 
     for outidx in range(N):
-        for f in range(offsets[outidx], offsets[outidx]+bins[outidx]):
-            copyfileorfolder(inFiles[f],inFolder,outFolders[outidx],link)
+        for f in range(offsets[outidx], offsets[outidx] + bins[outidx]):
+            copyfileorfolder(inFiles[f], inFolder, outFolders[outidx], link)
+
+
+def regexorder(inFiles, inFolder, outFolders, matcher, uniqlabel, link):
+    """ Copy files by regex match """
 
-def regexorder(inFiles,inFolder,outFolders,matcher,uniqlabel,link):
-    ''' Copy files by regex match '''
-    
     for f in inFiles:
-        m=matcher.search(f)
+        m = matcher.search(f)
         if m:
-            outidx=uniqlabel.index(m.group(1))
-            copyfileorfolder(f,inFolder,outFolders[outidx],link)
+            outidx = uniqlabel.index(m.group(1))
+            copyfileorfolder(f, inFolder, outFolders[outidx], link)
+
 
 def regexmatches(inFiles, opts):
-    matcher=re.compile(opts.regexp)
-    matches=[]
-    skipped=0
+    matcher = re.compile(opts.regexp)
+    matches = []
+    skipped = 0
     for f in inFiles:
-        m=matcher.search(f)
+        m = matcher.search(f)
         if m:
             matches.append(m.group(1))
         else:
-            skipped+=1
-    uniqlabel=sorted(set(matches))
-    print("Unique matches",uniqlabel)
-    print("Not matching %d files."% skipped)
+            skipped += 1
+    uniqlabel = sorted(set(matches))
+    print("Unique matches", uniqlabel)
+    print("Not matching %d files." % skipped)
     for x in uniqlabel:
-        outFolders.append(os.path.join(opts.path,x))
+        outFolders.append(os.path.join(opts.path, x))
     return (outFolders, uniqlabel, matcher)
 
+
 def offset(it):
     total = 0
     for x in it:
         total += x
         yield total
 
+
 def report(outFolders):
     for x in outFolders:
-        n=len(os.listdir(x))
-        print( os.path.basename( x )+":"+str(n) )
+        n = len(os.listdir(x))
+        print(os.path.basename(x) + ":" + str(n))
 
-''' Splits a folder input in N outputs '''
-options=setup_options()
-outFolders=[]
+
+""" Splits a folder input in N outputs """
+options = setup_options()
+outFolders = []
 method = options.order.lower().strip()
 # list files, and remove hidden  (.files)
-inFiles=sorted(filter(lambda x: not x.startswith('.'), os.listdir(options.path)))
+inFiles = sorted(filter(lambda x: not x.startswith("."), os.listdir(options.path)))
 if options.files:
-    inFiles=[ f for f in inFiles if os.path.isfile( os.path.join( options.path, f ) ) ]
+    inFiles = [f for f in inFiles if os.path.isfile(os.path.join(options.path, f))]
 
-if method=='regexp':
-    (outFolders, uniqlabel, matcher)=regexmatches(inFiles, options)
-    raw_input("correct?")
+if method == "regexp":
+    (outFolders, uniqlabel, matcher) = regexmatches(inFiles, options)
+    input("correct?")
 else:
     for x in range(options.n):
-        outFolders.append(os.path.join(options.path,'folder'+str(x+1)))
+        outFolders.append(os.path.join(options.path, "folder" + str(x + 1)))
 
 for x in outFolders:
     if not os.path.isdir(x):
         os.mkdir(x)
-if method=='random':
+if method == "random":
     shuffle(inFiles)
-    portorder(inFiles,options.path,outFolders,options.n,options.move)
-if method=='regexp':
-    regexorder(inFiles,options.path,outFolders,matcher,uniqlabel,options.move)
-if method=='sparse':
-    portorder(inFiles,options.path,outFolders,options.n,options.move)
-if method=='sequence':
-    fileorder(inFiles,options.path,outFolders,options.n,options.move)
+    portorder(inFiles, options.path, outFolders, options.n, options.move)
+if method == "regexp":
+    regexorder(inFiles, options.path, outFolders, matcher, uniqlabel, options.move)
+if method == "sparse":
+    portorder(inFiles, options.path, outFolders, options.n, options.move)
+if method == "sequence":
+    fileorder(inFiles, options.path, outFolders, options.n, options.move)
 
 
 report(outFolders)
diff --git a/files/fimplate.py b/files/fimplate.py
index 5b3add9..aac7062 100755
--- a/files/fimplate.py
+++ b/files/fimplate.py
@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
-import sys,re,os
+import sys, re, os
 from argparse import ArgumentParser
 from argparse import RawTextHelpFormatter
 
+
 def setup_options():
     parser = ArgumentParser(
         description="""Template Filler
@@ -15,33 +16,30 @@ def setup_options():
 [[name]]=John
 [[letter]]=@letter.txt
     """,
-        formatter_class = RawTextHelpFormatter
+        formatter_class=RawTextHelpFormatter,
     )
     parser.add_argument(
         "-e",
-        action = "store_true",
-        dest = "env",
-        default = False,
-        help = "Use the environment to replace ${env} style variables."
+        action="store_true",
+        dest="env",
+        default=False,
+        help="Use the environment to replace ${env} style variables.",
     )
     parser.add_argument(
-        "-f",
-        action = "store",
-        dest = "file",
-        help = "File name to read keys/values."
+        "-f", action="store", dest="file", help="File name to read keys/values."
     )
     parser.add_argument(
         "-p",
-        action = "append",
-        dest = "values",
-        default = [],
-        help = "key=value pairs. This option may be issued several times."
+        action="append",
+        dest="values",
+        default=[],
+        help="key=value pairs. This option may be issued several times.",
     )
     parser.add_argument(
-        'template',
-        action = "store",
-        nargs = '?',
-        help = "Template file to be filled. If not defined, stdin used."
+        "template",
+        action="store",
+        nargs="?",
+        help="Template file to be filled. If not defined, stdin used.",
     )
     options = parser.parse_args()
     return options
@@ -54,28 +52,34 @@ def parse_file(filename):
             l = l.rstrip("\n\r")
             if len(l) == 0:
                 continue
-            tokens = l.split('=', 1)
+            tokens = l.split("=", 1)
             if len(tokens) != 2:
-                print("File %s:%i key=value pair '%s' does not parse"%(
-                    filename, i+1, l,
-                ))
+                print(
+                    "File %s:%i key=value pair '%s' does not parse"
+                    % (
+                        filename,
+                        i + 1,
+                        l,
+                    )
+                )
                 sys.exit(1)
-            pairs.append( (tokens[0], tokens[1]) )
+            pairs.append((tokens[0], tokens[1]))
     return pairs
 
+
 def parse_arguments(args):
     pairs = []
     for p in args:
-        tokens = p.split('=', 1)
+        tokens = p.split("=", 1)
         if len(tokens) != 2:
-            print("Argument key=value pair '%s' does not parse"%(p,))
+            print("Argument key=value pair '%s' does not parse" % (p,))
             sys.exit(1)
-        pairs.append( (tokens[0], tokens[1]) )
+        pairs.append((tokens[0], tokens[1]))
     return pairs
 
 
 if __name__ == "__main__":
-    options = setup_options();
+    options = setup_options()
     pairs = []
     if options.file != None:
         pairs.extend(parse_file(options.file))
@@ -83,18 +87,18 @@ if __name__ == "__main__":
     if options.template == None:
         in_reader = sys.stdin
     else:
-        in_reader = open(options.template, 'rb')
+        in_reader = open(options.template, "rb")
     for l in in_reader:
         for p in pairs:
             value = p[1]
             if len(value) > 0:
                 if value[0] == "@":
-                    value = open(value[1:], 'rt').read()
+                    value = open(value[1:], "rt").read()
                 elif value[0:2] == "\\@":
                     value = value[1:]
-            l = l.replace(p[0].encode('utf-8'), value.encode('utf-8'))
+            l = l.replace(p[0].encode("utf-8"), value.encode("utf-8"))
         if options.env:
-            var_list = [m.group(0) for m in re.finditer('\${[^ ]+}', l)]
+            var_list = [m.group(0) for m in re.finditer("\${[^ ]+}", l)]
             for v in var_list:
                 l = l.replace(v, os.environ.get(v[:-1][2:], ""))
-        sys.stdout.write(l.decode('utf-8'))
+        sys.stdout.write(l.decode("utf-8"))
diff --git a/files/foldermenu.py b/files/foldermenu.py
index 4482777..856903c 100755
--- a/files/foldermenu.py
+++ b/files/foldermenu.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import math
 import os
@@ -10,57 +10,125 @@ import time
 import tty
 
 
-readline.parse_and_bind('tab: complete')
-readline.parse_and_bind('set editing-mode vi')
+readline.parse_and_bind("tab: complete")
+readline.parse_and_bind("set editing-mode vi")
 
-MENUFILE = '.foldermenu'
-DEFAULTFILE = os.path.expanduser(os.path.join('~','.config','foldermenu','default'))
+MENUFILE = ".foldermenu"
+DEFAULTFILE = os.path.expanduser(os.path.join("~", ".config", "foldermenu", "default"))
 VERSION = "0.5"
 DEBUG = False
 
+
 def setup_options():
-    ''' Setup the command line options '''
+    """ Setup the command line options """
     from argparse import ArgumentParser
 
-    parser=ArgumentParser(description="Prints folder specific shell commands stored in '" + MENUFILE +
-                        "' file, and in addition the executables in the current folder. " +
-                        "Menufile format for each line:  'description:command'. " +
-                        "If the command ends in '&' it is run in the background. " +
-                        "If the command ends in '/' it is a folder, and selecting will enter. " +
-                        "Extra keyboard shortcuts:  / Edit, $ Shell ")
-    parser.add_argument("-1","--one-shot",action = 'store_true', dest = 'once', default = False,
-                      help = "Launch only once, then exit")
-    parser.add_argument("-b","--no-banner", action='store_false', dest='banner', default=True,
-                      help="Do not show banners. Banners are ## starting lines in the file")
-    parser.add_argument("-d","--no-defaults",action='store_false', dest='defaults',default=True,
-                      help="Do not show default entries from "+DEFAULTFILE)
-    parser.add_argument("-x","--no-exec",action='store_false', dest='executables',default=True,
-                      help="Do not show executables in the listing.")
-    parser.add_argument("--columns",'-f','-C',type=int,action='store', dest='columns',default=0,
-                      help="Number of columns. 0 for automatic")
-    parser.add_argument("-l","--list",action='store_true', dest='list',default=False,
-                      help="Print the list, don't wait for keypress.")
-    parser.add_argument("--command",'-c',type=str,action='store', dest='command',
-                      help="Command to run (1-9a-z..), any argumets after -- are forwarded to the command ")
-    parser.add_argument("--no-colors",'--nc',action="store_false",dest="colors",default=True,
-                        help="Disable colored output")
-    parser.add_argument("--horizontal",'-H',action="store_true",dest="horizontal",default=False,
-                        help="Horizontal order of items, only valid for -l listing.")
-    parser.add_argument("--version",action='version', version=VERSION)
-    parser.add_argument("args",type=str,action="store",default="",nargs="?",
-                      help="Arguments for the command, if -c used. The string will be re-parsed with shutils. Use '--' to skip local parsing.")
+    parser = ArgumentParser(
+        description="Prints folder specific shell commands stored in '"
+        + MENUFILE
+        + "' file, and in addition the executables in the current folder. "
+        + "Menufile format for each line:  'description:command'. "
+        + "If the command ends in '&' it is run in the background. "
+        + "If the command ends in '/' it is a folder, and selecting will enter. "
+        + "Extra keyboard shortcuts:  / Edit, $ Shell "
+    )
+    parser.add_argument(
+        "-1",
+        "--one-shot",
+        action="store_true",
+        dest="once",
+        default=False,
+        help="Launch only once, then exit",
+    )
+    parser.add_argument(
+        "-b",
+        "--no-banner",
+        action="store_false",
+        dest="banner",
+        default=True,
+        help="Do not show banners. Banners are ## starting lines in the file",
+    )
+    parser.add_argument(
+        "-d",
+        "--no-defaults",
+        action="store_false",
+        dest="defaults",
+        default=True,
+        help="Do not show default entries from " + DEFAULTFILE,
+    )
+    parser.add_argument(
+        "-x",
+        "--no-exec",
+        action="store_false",
+        dest="executables",
+        default=True,
+        help="Do not show executables in the listing.",
+    )
+    parser.add_argument(
+        "--columns",
+        "-f",
+        "-C",
+        type=int,
+        action="store",
+        dest="columns",
+        default=0,
+        help="Number of columns. 0 for automatic",
+    )
+    parser.add_argument(
+        "-l",
+        "--list",
+        action="store_true",
+        dest="list",
+        default=False,
+        help="Print the list, don't wait for keypress.",
+    )
+    parser.add_argument(
+        "--command",
+        "-c",
+        type=str,
+        action="store",
+        dest="command",
+        help="Command to run (1-9a-z..), any argumets after -- are forwarded to the command ",
+    )
+    parser.add_argument(
+        "--no-colors",
+        "--nc",
+        action="store_false",
+        dest="colors",
+        default=True,
+        help="Disable colored output",
+    )
+    parser.add_argument(
+        "--horizontal",
+        "-H",
+        action="store_true",
+        dest="horizontal",
+        default=False,
+        help="Horizontal order of items, only valid for -l listing.",
+    )
+    parser.add_argument("--version", action="version", version=VERSION)
+    parser.add_argument(
+        "args",
+        type=str,
+        action="store",
+        default="",
+        nargs="?",
+        help="Arguments for the command, if -c used. The string will be re-parsed with shutils. Use '--' to skip local parsing.",
+    )
 
     options = parser.parse_args()
     if not os.path.exists(DEFAULTFILE):
         options.defaults = False
     return options
 
+
 def termsize():
-    rows, columns = os.popen('stty size', 'r').read().split()
+    rows, columns = os.popen("stty size", "r").read().split()
     return (int(rows), int(columns))
 
+
 def ichr(i):
-    ''' convert integer to 1-9, a-z, A-Z, omitting q,x '''
+    """ convert integer to 1-9, a-z, A-Z, omitting q,x """
 
     if i < 10:
         return str(i)
@@ -73,36 +141,37 @@ def ichr(i):
         i += 64 - 122
     return chr(i)
 
+
 class bc:
-    MAG = '\033[35m'
-    BLU = '\033[34m'
-    GRE = '\033[32m'
-    YEL = '\033[33m'
-    RED = '\033[31m'
-    CYA = '\033[36m'
-    WHI = '\033[1m'
-    BG_BLK = '\033[40m'
-    END = '\033[0m'
-    CLR = '\033[2J'
-    INV = '\033[7m'
+    MAG = "\033[35m"
+    BLU = "\033[34m"
+    GRE = "\033[32m"
+    YEL = "\033[33m"
+    RED = "\033[31m"
+    CYA = "\033[36m"
+    WHI = "\033[1m"
+    BG_BLK = "\033[40m"
+    END = "\033[0m"
+    CLR = "\033[2J"
+    INV = "\033[7m"
 
     def disable(self):
-        self.MAG = ''
-        self.BLU = ''
-        self.GRE = ''
-        self.YEL = ''
-        self.RED = ''
-        self.CYA = ''
-        self.WHI = ''
-        self.END = ''
-        self.BG_BLK = ''
-        self.INV = ''
+        self.MAG = ""
+        self.BLU = ""
+        self.GRE = ""
+        self.YEL = ""
+        self.RED = ""
+        self.CYA = ""
+        self.WHI = ""
+        self.END = ""
+        self.BG_BLK = ""
+        self.INV = ""
 
-    def pos(self,y,x):
-        return "\033[%s;%sH"%( y, x )
+    def pos(self, y, x):
+        return "\033[%s;%sH" % (y, x)
 
     def posprint(self, y, x, s):
-        sys.stdout.write( self.pos(y, x) + str(s) )
+        sys.stdout.write(self.pos(y, x) + str(s))
 
 
 class getch:
@@ -122,18 +191,21 @@ class getch:
 
 
 class launch_item:
-    ''' Class for launchable items '''
+    """ Class for launchable items """
+
     def __init__(self, command, description, launcher):
         self.command = command
         self.description = description
         self.launcher = launcher
 
+
 class entry_collection:
-    ''' Object containing the list items, and the printing methods '''
+    """ Object containing the list items, and the printing methods """
+
     def __init__(self, options):
         self.options = options
-        self.menu_keys=[ichr(i+1) for i in range(60)]
-        self.args = ''
+        self.menu_keys = [ichr(i + 1) for i in range(60)]
+        self.args = ""
         self.co = bc()
         self.dir_mode = False
         self.max_length = 0
@@ -160,76 +232,58 @@ class entry_collection:
     def set_args(self, args):
         self.args = args
 
-    def read_menu(self, menu_file = MENUFILE):
-        ''' Read the menu file '''
+    def read_menu(self, menu_file=MENUFILE):
+        """ Read the menu file """
         if os.path.exists(menu_file):
-            with open(menu_file, 'rt') as f:
+            with open(menu_file, "rt") as f:
                 for row in f:
-                    if row.strip() == '':
+                    if row.strip() == "":
                         continue
-                    if row[0:2] == '##':
-                        self.banner.append(
-                            row[2:].replace("\n","").replace("\r","")
-                        )
+                    if row[0:2] == "##":
+                        self.banner.append(row[2:].replace("\n", "").replace("\r", ""))
                         continue
-                    if row[0] == '#':
+                    if row[0] == "#":
                         continue
-                    row = row.strip().split(':',1)
+                    row = row.strip().split(":", 1)
                     if len(row) == 1:
-                        row = [ row[0].strip(), row[0] ]
+                        row = [row[0].strip(), row[0]]
                     else:
-                        row = [ row[0].strip(), row[1] ]
+                        row = [row[0].strip(), row[1]]
                     if len(row[1]) == 0:
                         row[1] = " "
                     launcher = "menu"
-                    if row[1][-1] == '/' and os.path.isdir(row[1]):
+                    if row[1][-1] == "/" and os.path.isdir(row[1]):
                         launcher = "dir"
                         if row[0][-1] != "/":
                             row[0] += "/"
                     self.entries.append(
                         launch_item(
-                            command = row[1],
-                            description = row[0],
-                            launcher = launcher
+                            command=row[1], description=row[0], launcher=launcher
                         )
                     )
 
     def read_folder(self):
-        ''' Read folder contents, return executable files and dirs '''
+        """ Read folder contents, return executable files and dirs """
 
-        self.dirs.append(
-            launch_item(
-                command = '..',
-                description = '..',
-                launcher = "dir"
-            )
-        )
+        self.dirs.append(launch_item(command="..", description="..", launcher="dir"))
         dirs = []
         executables = []
-        for f in os.listdir('.'):
+        for f in os.listdir("."):
             if os.path.isfile(f):
                 if os.access(f, os.X_OK):
                     executables.append(f)
-            if os.path.isdir(f) and f[0] != '.':
+            if os.path.isdir(f) and f[0] != ".":
                 dirs.append(f)
         dirs.sort()
         for d in dirs:
             self.dirs.append(
-                launch_item(
-                    command = d,
-                    description = d + "/",
-                    launcher = "dir"
-                )
+                launch_item(command=d, description=d + "/", launcher="dir")
             )
         if self.options.executables:
             executables.sort()
             for e in executables:
                 self.entries.append(
-                    launch_item(
-                        command = e,
-                        description = e,
-                        launcher = "exec"
-                    )
+                    launch_item(command=e, description=e, launcher="exec")
                 )
 
     def entry_color(self, launcher):
@@ -246,11 +300,11 @@ class entry_collection:
             helptext = "[.]commands"
             my_entries = self.dirs
         else:
-            helptext = '[.]folders [-]args %s(%s%s%s)'%(
+            helptext = "[.]folders [-]args %s(%s%s%s)" % (
                 self.co.END + self.co.MAG,
                 self.co.END,
                 self.args,
-                self.co.MAG
+                self.co.MAG,
             )
             my_entries = self.entries
 
@@ -271,34 +325,21 @@ class entry_collection:
         else:
             banner = []
         blen = len(banner)
-        cwd = os.path.basename( os.getcwd() )[0:15]
+        cwd = os.path.basename(os.getcwd())[0:15]
 
-        self.co.posprint(
-            1,
-            1,
-            self.co.END + self.co.CLR
-        )
+        self.co.posprint(1, 1, self.co.END + self.co.CLR)
         self.co.posprint(
             1,
             3,
-            "%s%s%s [q/x]exit %s%s"%(
-                self.co.WHI,
-                cwd,
-                self.co.MAG,
-                helptext,
-                self.co.END
-            )
+            "%s%s%s [q/x]exit %s%s"
+            % (self.co.WHI, cwd, self.co.MAG, helptext, self.co.END),
         )
         for i, e in enumerate(banner):
-            self.co.posprint(
-                i+2,
-                0,
-                e
-            )
-        rows = int( math.ceil( len(my_entries) / pars ) )
+            self.co.posprint(i + 2, 0, e)
+        rows = int(math.ceil(len(my_entries) / pars))
         while rows > maxrows:
             pars += 1
-            rows = int( math.ceil( len(my_entries) / pars ) )
+            rows = int(math.ceil(len(my_entries) / pars))
         maxcolumns = int(math.ceil(maxcolumns / pars))
         r = 1 + blen
         par = 1
@@ -313,16 +354,17 @@ class entry_collection:
                 column = 2
                 border = ""
             else:
-                column = maxcolumns * ( par - 1 )
-                border = '| '
+                column = maxcolumns * (par - 1)
+                border = "| "
             if self.selected == index:
                 highlight = self.co.INV + ">"
             else:
-                highlight = ' '
+                highlight = " "
             self.co.posprint(
-                r+1,
+                r + 1,
                 column,
-                "%s%s%s%s%s%s%s%s"%(
+                "%s%s%s%s%s%s%s%s"
+                % (
                     border,
                     self.co.WHI,
                     key,
@@ -330,16 +372,13 @@ class entry_collection:
                     self.entry_color(entry.launcher),
                     highlight,
                     printline,
-                    self.co.END
-                )
+                    self.co.END,
+                ),
             )
             r += 1
-        self.co.posprint(
-            rows + 2 + blen,
-            0,
-            "#"
-        )
+        self.co.posprint(rows + 2 + blen, 0, "#")
         self.rows = rows
+        sys.stdout.flush()
 
     def list(self):
         """ draws the list at cursor """
@@ -350,18 +389,13 @@ class entry_collection:
         if self.options.columns == 0:
             pars = 1.0
             if len(self.entries) > 9:
-                pars = max(
-                    1.0,
-                    math.floor(
-                        maxcolumns / float(self.max_length)
-                    )
-                )
+                pars = max(1.0, math.floor(maxcolumns / float(self.max_length)))
                 while len(self.entries) / pars < pars:
                     pars -= 1
         else:
             pars = float(self.options.columns)
 
-        rows = int(math.ceil( len(self.entries) / float(pars) ))
+        rows = int(math.ceil(len(self.entries) / float(pars)))
         maxcolumns = int(math.floor(maxcolumns / pars)) - 2
         # If names won't fit the columns, make sure at least 3 characters are visible
         if maxcolumns < 6:
@@ -370,8 +404,8 @@ class entry_collection:
             origmaxcolumns -= 10
             while maxcolumns < 6:
                 pars -= 1
-                rows = int(math.ceil( len(self.entries) / float(pars) ))
-                maxcolumns = int(math.floor( origmaxcolumns / pars )) - 2
+                rows = int(math.ceil(len(self.entries) / float(pars)))
+                maxcolumns = int(math.floor(origmaxcolumns / pars)) - 2
 
         self.max_length = min(maxcolumns, self.max_length)
         if self.options.horizontal:
@@ -380,24 +414,24 @@ class entry_collection:
         for r in range(int(rows)):
             formatted.append([])
             for p in range(int(pars)):
-                formatted[r].append(' '*(self.max_length))
+                formatted[r].append(" " * (self.max_length))
                 if self.options.horizontal:
-                    formatted[r][p] += ' '
+                    formatted[r][p] += " "
         r = 0
         par = 0
-        for entry,key in zip(self.entries, self.menu_keys):
+        for entry, key in zip(self.entries, self.menu_keys):
             if r >= rows:
                 par += 1
                 r = 0
-            printline = entry.description[:(maxcolumns-3)]
-            printline += ' '*(self.max_length-len(printline)-1)
-            formatted[r][par]="%s%s%s %s%s%s"%(
+            printline = entry.description[: (maxcolumns - 3)]
+            printline += " " * (self.max_length - len(printline) - 1)
+            formatted[r][par] = "%s%s%s %s%s%s" % (
                 self.co.WHI,
                 key,
                 self.co.END,
                 self.entry_color(entry.launcher),
                 printline,
-                self.co.END
+                self.co.END,
             )
             r += 1
         if self.options.horizontal:
@@ -407,10 +441,10 @@ class entry_collection:
             if self.banner:
                 print("\n".join(self.banner))
         for row in formatted:
-            print('|'.join(row))
+            print("|".join(row))
 
     def launch(self, key):
-        ''' launch the given entry '''
+        """ launch the given entry """
 
         bg = False
         idx = self.menu_keys.index(key)
@@ -428,14 +462,14 @@ class entry_collection:
                 self.selected = -1
             return
 
-        if command_str[-1] == '&':
-            #Run the program in background
+        if command_str[-1] == "&":
+            # Run the program in background
             command_str = command_str[:-1]
             bg = True
         if len(self.args) > 0:
-            command_str += ' ' + self.args
-        if self.entries[idx].launcher == 'exec':
-            command_str = './' + command_str
+            command_str += " " + self.args
+        if self.entries[idx].launcher == "exec":
+            command_str = "./" + command_str
 
         if not self.options.command:
             print(command_str)
@@ -443,24 +477,24 @@ class entry_collection:
             if bg:
                 subprocess.Popen(
                     command_str,
-                    stderr = subprocess.PIPE,
+                    stderr=subprocess.PIPE,
                     shell=True,
-                    executable="/bin/bash"
+                    executable="/bin/bash",
                 )
             else:
                 subprocess.call(
                     command_str,
-                    stderr = subprocess.STDOUT,
-                    shell = True,
-                    executable = "/bin/bash"
+                    stderr=subprocess.STDOUT,
+                    shell=True,
+                    executable="/bin/bash",
                 )
         except:
             print('Non-zero exit code: "' + command_str + '"')
 
         if not (self.options.command or self.options.once or bg):
-            print('Press any key...')
-            ch=getch()
-            inkey=ord(ch.get())
+            print("Press any key...")
+            ch = getch()
+            inkey = ord(ch.get())
 
     def flip_mode(self):
         self.dir_mode = not self.dir_mode
@@ -474,10 +508,10 @@ class entry_collection:
         try:
             idx = self.menu_keys.index(key)
         except ValueError:
-            return (False, 'Not a possible key')
+            return (False, "Not a possible key")
         if idx + 1 > my_len:
-            return (False, 'No such entry')
-        return (True, '')
+            return (False, "No such entry")
+        return (True, "")
 
     def select_move(self, delta):
         new_value = self.selected + delta
@@ -493,30 +527,27 @@ class entry_collection:
 
     def edit_menu(self):
         subprocess.call(
-            "vim %s"%( MENUFILE, ),
-            stderr = subprocess.STDOUT,
-            shell = True,
-            executable = "/bin/bash"
+            "vim %s" % (MENUFILE,),
+            stderr=subprocess.STDOUT,
+            shell=True,
+            executable="/bin/bash",
         )
         self.initialize()
 
     def shell(self):
-        #env = os.environ.copy()
-        #env["PS1"] = "fM:" + env.get("PS1","")
+        # env = os.environ.copy()
+        # env["PS1"] = "fM:" + env.get("PS1","")
         subprocess.call(
             "bash --rcfile <(cat ~/.bashrc; echo \"PS1='folderMenu: '\$PS1\") -i",
-            stderr = subprocess.STDOUT,
-            shell = True,
-            executable = "/bin/bash"
+            stderr=subprocess.STDOUT,
+            shell=True,
+            executable="/bin/bash",
         )
         self.initialize()
 
 
 def debug_code_print(c):
-    print("- code: %d, str: %s -"%(
-        c,
-        str(c)
-    ))
+    print("- code: %d, str: %s -" % (c, str(c)))
     time.sleep(1)
 
 
@@ -565,25 +596,25 @@ def start_engines():
                 # 53 = pg up
                 # 54 = pg down
                 #
-                #~ print(inkey3)
-                #~ sys.exit(0)
+                # ~ print(inkey3)
+                # ~ sys.exit(0)
 
-        if inkey in (113, 120, 3, 24, 4): # q, x
-            print('Exited in: ' + os.getcwd())
+        if inkey in (113, 120, 3, 24, 4):  # q, x
+            print("Exited in: " + os.getcwd())
             sys.exit(0)
-        if inkey == 45: # -
-            print('')
+        if inkey == 45:  # -
+            print("")
             readline.set_startup_hook(lambda: readline.insert_text(entries.args))
-            args = raw_input('args: ')
+            args = raw_input("args: ")
             entries.set_args(args)
             readline.set_startup_hook(None)
-        if inkey == 46: # .
+        if inkey == 46:  # .
             entries.flip_mode()
-        if inkey == 47: # /
+        if inkey == 47:  # /
             entries.edit_menu()
-        if inkey == 36: # $
+        if inkey == 36:  # $
             entries.shell()
-        if inkey == 13: # enter
+        if inkey == 13:  # enter
             inkey = ord(entries.menu_keys[entries.selected])
         found, message = entries.is_key(chr(inkey))
         if found:
@@ -592,7 +623,6 @@ def start_engines():
                 sys.exit(0)
             entries.initialize()
 
+
 if __name__ == "__main__":
     start_engines()
-
-
diff --git a/files/gcd-findmatch.py b/files/gcd-findmatch.py
index 43d36c5..59768b9 100755
--- a/files/gcd-findmatch.py
+++ b/files/gcd-findmatch.py
@@ -1,6 +1,6 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
-import sys,os,re
+import sys, os, re
 import difflib as dl
 
 # Define color codes
@@ -10,61 +10,65 @@ Reset = "\033[0m"
 # Available shortcut keys
 key_list = "1234567890qwertyuiop"
 
+
 class getch:
     def get(self):
         import termios, tty
+
         fd = sys.stdin.fileno()
         old_settings = termios.tcgetattr(fd)
         try:
             tty.setraw(sys.stdin.fileno())
             ch = sys.stdin.read(1)
         finally:
-            termios.tcsetattr(
-                fd,
-                termios.TCSADRAIN,
-                old_settings
-            )
+            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
         return ch
 
+
 def printerr(s):
     sys.stderr.write(s + "\n")
     sys.stderr.flush()
 
+
 def errexit(s):
     printerr(s)
     sys.exit(1)
 
+
 def colorize_matches(directories, repl):
-    return [repl.sub("%s\g<1>%s"%(Green, Reset), d) for d in directories]
+    return [repl.sub("%s\g<1>%s" % (Green, Reset), d) for d in directories]
+
 
 def search_close_match(directories, key):
     """ Return a list of Components whose name closely matches key """
     match = []
     key = key.lower()
     for name in directories:
-        s = dl.SequenceMatcher(
-            None,
-            name.lower(),
-            key
-        )
+        s = dl.SequenceMatcher(None, name.lower(), key)
         if s.ratio() > 0:
-            match.append(( s.ratio(), name ))
-    match.sort(key = lambda x: x[0], reverse = True)
-    best_matches=[x[1] for x in match[0:10]]
+            match.append((s.ratio(), name))
+    match.sort(key=lambda x: x[0], reverse=True)
+    best_matches = [x[1] for x in match[0:10]]
     return best_matches
 
+
 def get_dirs(pat_dir):
 
     # list sub-folders in the folder
-    current_folders = [d for d in os.listdir(pat_dir) if os.path.isdir(os.path.join(pat_dir, d))]
+    current_folders = [
+        d for d in os.listdir(pat_dir) if os.path.isdir(os.path.join(pat_dir, d))
+    ]
     current_folders = [d for d in current_folders if not d.startswith(".")]
     current_folders.sort()
     return current_folders
 
+
 def main():
     # Print help
     if len(sys.argv) == 1 or sys.argv[-1] == "-h":
-        errexit("Guess cd: Find first match in folder, interactive if multiple matches\n  Arguments: [dir/]pattern_to_match_folders")
+        errexit(
+            "Guess cd: Find first match in folder, interactive if multiple matches\n  Arguments: [dir/]pattern_to_match_folders"
+        )
 
     pattern = ".".join(sys.argv[1:])
     pat_base = os.path.basename(pattern)
@@ -74,14 +78,14 @@ def main():
         pat_dir = "."
 
     if not os.path.exists(pat_dir):
-        errexit("%s: %sNo such folder%s"%(pat_dir, Red, Reset))
+        errexit("%s: %sNo such folder%s" % (pat_dir, Red, Reset))
 
     # list sub-folders in the folder
     current_folders = get_dirs(pat_dir)
 
     # no sub-folders
     if len(current_folders) == 0:
-        errexit("There are no subfolders in %s"%( pat_dir,))
+        errexit("There are no subfolders in %s" % (pat_dir,))
 
     # find matches
     match_case = re.compile(".*" + pat_base + ".*")
@@ -92,8 +96,8 @@ def main():
 
     # no matches, try case insensitive
     if len(matching_folders) == 0:
-        match_nocase = re.compile(".*" + pat_base + ".*",re.I)
-        repl_nocase = re.compile("(" + pat_base + ")",re.I)
+        match_nocase = re.compile(".*" + pat_base + ".*", re.I)
+        repl_nocase = re.compile("(" + pat_base + ")", re.I)
         matching_folders = [d for d in current_folders if match_nocase.match(d)]
         matches = colorize_matches(matching_folders, repl_nocase)
 
@@ -109,7 +113,7 @@ def main():
         sys.exit(0)
 
     # Many matches, ask the user for folder index
-    for i,m in enumerate(matches[0:len(key_list)]):
+    for i, m in enumerate(matches[0 : len(key_list)]):
         printerr(key_list[i] + ": " + m)
 
     if len(matches) > len(key_list):
@@ -120,9 +124,10 @@ def main():
         key_index = key_list.index(key_in)
         key_match = matching_folders[key_index]
     except (ValueError, IndexError) as err:
-        errexit("%s'%s' Not in the list%s"%(Red, key_in, Reset))
+        errexit("%s'%s' Not in the list%s" % (Red, key_in, Reset))
 
     print(os.path.join(pat_dir, key_match))
 
+
 if __name__ == "__main__":
     main()