STY: Make PEP8 fixes in numpy/f2py

Decided to bite the bullet on this one. The code is certainly more
readable, so should be easier to fix if we need to.

1 files changed, 244 insertions, 123 deletions

diff --git a/numpy/f2py/auxfuncs.py b/numpy/f2py/auxfuncs.py
index d762aa7a5..9e6a393c3 100644
--- a/numpy/f2py/auxfuncs.py
+++ b/numpy/f2py/auxfuncs.py
@@ -56,8 +56,8 @@ f2py_version = __version__.version
 errmess = sys.stderr.write
 show = pprint.pprint
 
-options={}
-debugoptions=[]
+options = {}
+debugoptions = []
 wrapfuncs = 1
 
 
@@ -65,44 +65,57 @@ def outmess(t):
     if options.get('verbose', 1):
         sys.stdout.write(t)
 
+
 def debugcapi(var):
     return 'capi' in debugoptions
 
+
 def _isstring(var):
-    return 'typespec' in var and var['typespec']=='character' and (not isexternal(var))
+    return 'typespec' in var and var['typespec'] == 'character' and (not isexternal(var))
+
 
 def isstring(var):
     return _isstring(var) and not isarray(var)
 
+
 def ischaracter(var):
     return isstring(var) and 'charselector' not in var
 
+
 def isstringarray(var):
     return isarray(var) and _isstring(var)
 
+
 def isarrayofstrings(var):
     # leaving out '*' for now so that
     # `character*(*) a(m)` and `character a(m,*)`
     # are treated differently. Luckily `character**` is illegal.
-    return isstringarray(var) and var['dimension'][-1]=='(*)'
+    return isstringarray(var) and var['dimension'][-1] == '(*)'
+
 
 def isarray(var):
     return 'dimension' in var and (not isexternal(var))
 
+
 def isscalar(var):
     return not (isarray(var) or isstring(var) or isexternal(var))
 
+
 def iscomplex(var):
     return isscalar(var) and var.get('typespec') in ['complex', 'double complex']
 
+
 def islogical(var):
-    return isscalar(var) and var.get('typespec')=='logical'
+    return isscalar(var) and var.get('typespec') == 'logical'
+
 
 def isinteger(var):
-    return isscalar(var) and var.get('typespec')=='integer'
+    return isscalar(var) and var.get('typespec') == 'integer'
+
 
 def isreal(var):
-    return isscalar(var) and var.get('typespec')=='real'
+    return isscalar(var) and var.get('typespec') == 'real'
+
 
 def get_kind(var):
     try:
@@ -113,187 +126,221 @@ def get_kind(var):
         except KeyError:
             pass
 
+
 def islong_long(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') not in ['integer', 'logical']:
         return 0
-    return get_kind(var)=='8'
+    return get_kind(var) == '8'
+
 
 def isunsigned_char(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-1'
+    return get_kind(var) == '-1'
+
 
 def isunsigned_short(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-2'
+    return get_kind(var) == '-2'
+
 
 def isunsigned(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-4'
+    return get_kind(var) == '-4'
+
 
 def isunsigned_long_long(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-8'
+    return get_kind(var) == '-8'
+
 
 def isdouble(var):
     if not isscalar(var):
         return 0
-    if not var.get('typespec')=='real':
+    if not var.get('typespec') == 'real':
         return 0
-    return get_kind(var)=='8'
+    return get_kind(var) == '8'
+
 
 def islong_double(var):
     if not isscalar(var):
         return 0
-    if not var.get('typespec')=='real':
+    if not var.get('typespec') == 'real':
         return 0
-    return get_kind(var)=='16'
+    return get_kind(var) == '16'
+
 
 def islong_complex(var):
     if not iscomplex(var):
         return 0
-    return get_kind(var)=='32'
+    return get_kind(var) == '32'
+
 
 def iscomplexarray(var):
     return isarray(var) and var.get('typespec') in ['complex', 'double complex']
 
+
 def isint1array(var):
-    return isarray(var) and var.get('typespec')=='integer' \
-    and get_kind(var)=='1'
+    return isarray(var) and var.get('typespec') == 'integer' \
+        and get_kind(var) == '1'
+
 
 def isunsigned_chararray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-1'
+        and get_kind(var) == '-1'
+
 
 def isunsigned_shortarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-2'
+        and get_kind(var) == '-2'
+
 
 def isunsignedarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-4'
+        and get_kind(var) == '-4'
+
 
 def isunsigned_long_longarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-8'
+        and get_kind(var) == '-8'
+
 
 def issigned_chararray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='1'
+        and get_kind(var) == '1'
+
 
 def issigned_shortarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='2'
+        and get_kind(var) == '2'
+
 
 def issigned_array(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='4'
+        and get_kind(var) == '4'
+
 
 def issigned_long_longarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='8'
+        and get_kind(var) == '8'
+
 
 def isallocatable(var):
     return 'attrspec' in var and 'allocatable' in var['attrspec']
 
+
 def ismutable(var):
-    return not (not 'dimension' in var or isstring(var))
+    return not ('dimension' not in var or isstring(var))
+
 
 def ismoduleroutine(rout):
     return 'modulename' in rout
 
+
 def ismodule(rout):
-    return ('block' in rout and 'module'==rout['block'])
+    return ('block' in rout and 'module' == rout['block'])
+
 
 def isfunction(rout):
-    return ('block' in rout and 'function'==rout['block'])
+    return ('block' in rout and 'function' == rout['block'])
+
+# def isfunction_wrap(rout):
+# return wrapfuncs and (iscomplexfunction(rout) or isstringfunction(rout))
+# and (not isexternal(rout))
 
-#def isfunction_wrap(rout):
-#    return wrapfuncs and (iscomplexfunction(rout) or isstringfunction(rout)) and (not isexternal(rout))
 
 def isfunction_wrap(rout):
     if isintent_c(rout):
         return 0
     return wrapfuncs and isfunction(rout) and (not isexternal(rout))
 
+
 def issubroutine(rout):
-    return ('block' in rout and 'subroutine'==rout['block'])
+    return ('block' in rout and 'subroutine' == rout['block'])
+
 
 def issubroutine_wrap(rout):
     if isintent_c(rout):
         return 0
     return issubroutine(rout) and hasassumedshape(rout)
 
+
 def hasassumedshape(rout):
     if rout.get('hasassumedshape'):
         return True
     for a in rout['args']:
         for d in rout['vars'].get(a, {}).get('dimension', []):
-            if d==':':
+            if d == ':':
                 rout['hasassumedshape'] = True
                 return True
     return False
 
+
 def isroutine(rout):
     return isfunction(rout) or issubroutine(rout)
 
+
 def islogicalfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islogical(rout['vars'][a])
     return 0
 
+
 def islong_longfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islong_long(rout['vars'][a])
     return 0
 
+
 def islong_doublefunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islong_double(rout['vars'][a])
     return 0
 
+
 def iscomplexfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return iscomplex(rout['vars'][a])
     return 0
 
+
 def iscomplexfunction_warn(rout):
     if iscomplexfunction(rout):
         outmess("""\
@@ -307,35 +354,43 @@ def iscomplexfunction_warn(rout):
         return 1
     return 0
 
+
 def isstringfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return isstring(rout['vars'][a])
     return 0
 
+
 def hasexternals(rout):
     return 'externals' in rout and rout['externals']
 
+
 def isthreadsafe(rout):
     return 'f2pyenhancements' in rout and 'threadsafe' in rout['f2pyenhancements']
 
+
 def hasvariables(rout):
     return 'vars' in rout and rout['vars']
 
+
 def isoptional(var):
     return ('attrspec' in var and 'optional' in var['attrspec'] and 'required' not in var['attrspec']) and isintent_nothide(var)
 
+
 def isexternal(var):
     return ('attrspec' in var and 'external' in var['attrspec'])
 
+
 def isrequired(var):
     return not isoptional(var) and isintent_nothide(var)
 
+
 def isintent_in(var):
     if 'intent' not in var:
         return 1
@@ -353,46 +408,62 @@ def isintent_in(var):
         return 0
     return 1
 
+
 def isintent_inout(var):
     return 'intent' in var and ('inout' in var['intent'] or 'outin' in var['intent']) and 'in' not in var['intent'] and 'hide' not in var['intent'] and 'inplace' not in var['intent']
 
+
 def isintent_out(var):
     return 'out' in var.get('intent', [])
 
+
 def isintent_hide(var):
     return ('intent' in var and ('hide' in var['intent'] or ('out' in var['intent'] and 'in' not in var['intent'] and (not l_or(isintent_inout, isintent_inplace)(var)))))
 
+
 def isintent_nothide(var):
     return not isintent_hide(var)
 
+
 def isintent_c(var):
     return 'c' in var.get('intent', [])
 
 # def isintent_f(var):
 #     return not isintent_c(var)
 
+
 def isintent_cache(var):
     return 'cache' in var.get('intent', [])
 
+
 def isintent_copy(var):
     return 'copy' in var.get('intent', [])
 
+
 def isintent_overwrite(var):
     return 'overwrite' in var.get('intent', [])
 
+
 def isintent_callback(var):
     return 'callback' in var.get('intent', [])
 
+
 def isintent_inplace(var):
     return 'inplace' in var.get('intent', [])
 
+
 def isintent_aux(var):
     return 'aux' in var.get('intent', [])
 
+
 def isintent_aligned4(var):
     return 'aligned4' in var.get('intent', [])
+
+
 def isintent_aligned8(var):
     return 'aligned8' in var.get('intent', [])
+
+
 def isintent_aligned16(var):
     return 'aligned16' in var.get('intent', [])
 
@@ -406,34 +477,41 @@ isintent_dict = {isintent_in: 'INTENT_IN', isintent_inout: 'INTENT_INOUT',
                  isintent_aligned16: 'INTENT_ALIGNED16',
                  }
 
+
 def isprivate(var):
     return 'attrspec' in var and 'private' in var['attrspec']
 
+
 def hasinitvalue(var):
     return '=' in var
 
+
 def hasinitvalueasstring(var):
     if not hasinitvalue(var):
         return 0
     return var['='][0] in ['"', "'"]
 
+
 def hasnote(var):
     return 'note' in var
 
+
 def hasresultnote(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return hasnote(rout['vars'][a])
     return 0
 
+
 def hascommon(rout):
     return 'common' in rout
 
+
 def containscommon(rout):
     if hascommon(rout):
         return 1
@@ -443,6 +521,7 @@ def containscommon(rout):
                 return 1
     return 0
 
+
 def containsmodule(block):
     if ismodule(block):
         return 1
@@ -453,97 +532,119 @@ def containsmodule(block):
             return 1
     return 0
 
+
 def hasbody(rout):
     return 'body' in rout
 
+
 def hascallstatement(rout):
     return getcallstatement(rout) is not None
 
+
 def istrue(var):
     return 1
 
+
 def isfalse(var):
     return 0
 
+
 class F2PYError(Exception):
     pass
 
+
 class throw_error:
+
     def __init__(self, mess):
         self.mess = mess
+
     def __call__(self, var):
         mess = '\n\n  var = %s\n  Message: %s\n' % (var, self.mess)
         raise F2PYError(mess)
 
+
 def l_and(*f):
-    l, l2='lambda v', []
+    l, l2 = 'lambda v', []
     for i in range(len(f)):
-        l='%s,f%d=f[%d]'%(l, i, i)
-        l2.append('f%d(v)'%(i))
-    return eval('%s:%s'%(l, ' and '.join(l2)))
+        l = '%s,f%d=f[%d]' % (l, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l, ' and '.join(l2)))
+
 
 def l_or(*f):
-    l, l2='lambda v', []
+    l, l2 = 'lambda v', []
     for i in range(len(f)):
-        l='%s,f%d=f[%d]'%(l, i, i)
-        l2.append('f%d(v)'%(i))
-    return eval('%s:%s'%(l, ' or '.join(l2)))
+        l = '%s,f%d=f[%d]' % (l, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l, ' or '.join(l2)))
+
 
 def l_not(f):
     return eval('lambda v,f=f:not f(v)')
 
+
 def isdummyroutine(rout):
     try:
-        return rout['f2pyenhancements']['fortranname']==''
+        return rout['f2pyenhancements']['fortranname'] == ''
     except KeyError:
         return 0
 
+
 def getfortranname(rout):
     try:
         name = rout['f2pyenhancements']['fortranname']
-        if name=='':
+        if name == '':
             raise KeyError
         if not name:
-            errmess('Failed to use fortranname from %s\n'%(rout['f2pyenhancements']))
+            errmess('Failed to use fortranname from %s\n' %
+                    (rout['f2pyenhancements']))
             raise KeyError
     except KeyError:
         name = rout['name']
     return name
 
-def getmultilineblock(rout,blockname,comment=1,counter=0):
+
+def getmultilineblock(rout, blockname, comment=1, counter=0):
     try:
         r = rout['f2pyenhancements'].get(blockname)
     except KeyError:
         return
-    if not r: return
+    if not r:
+        return
     if counter > 0 and isinstance(r, str):
         return
     if isinstance(r, list):
-        if counter>=len(r): return
+        if counter >= len(r):
+            return
         r = r[counter]
-    if r[:3]=="'''":
+    if r[:3] == "'''":
         if comment:
-            r = '\t/* start ' + blockname + ' multiline ('+repr(counter)+') */\n' + r[3:]
+            r = '\t/* start ' + blockname + \
+                ' multiline (' + repr(counter) + ') */\n' + r[3:]
         else:
             r = r[3:]
-        if r[-3:]=="'''":
+        if r[-3:] == "'''":
             if comment:
-                r = r[:-3] + '\n\t/* end multiline ('+repr(counter)+')*/'
+                r = r[:-3] + '\n\t/* end multiline (' + repr(counter) + ')*/'
             else:
                 r = r[:-3]
         else:
-            errmess("%s multiline block should end with `'''`: %s\n" \
+            errmess("%s multiline block should end with `'''`: %s\n"
                     % (blockname, repr(r)))
     return r
 
+
 def getcallstatement(rout):
     return getmultilineblock(rout, 'callstatement')
 
-def getcallprotoargument(rout,cb_map={}):
+
+def getcallprotoargument(rout, cb_map={}):
     r = getmultilineblock(rout, 'callprotoargument', comment=0)
-    if r: return r
+    if r:
+        return r
     if hascallstatement(rout):
-        outmess('warning: callstatement is defined without callprotoargument\n')
+        outmess(
+            'warning: callstatement is defined without callprotoargument\n')
         return
     from .capi_maps import getctype
     arg_types, arg_types2 = [], []
@@ -554,7 +655,7 @@ def getcallprotoargument(rout,cb_map={}):
         if isintent_callback(var):
             continue
         if n in cb_map:
-            ctype = cb_map[n]+'_typedef'
+            ctype = cb_map[n] + '_typedef'
         else:
             ctype = getctype(var)
             if l_and(isintent_c, l_or(isscalar, iscomplex))(var):
@@ -563,174 +664,194 @@ def getcallprotoargument(rout,cb_map={}):
                 pass
                 #ctype = 'void*'
             else:
-                ctype = ctype+'*'
+                ctype = ctype + '*'
             if isstring(var) or isarrayofstrings(var):
                 arg_types2.append('size_t')
         arg_types.append(ctype)
 
-    proto_args = ','.join(arg_types+arg_types2)
+    proto_args = ','.join(arg_types + arg_types2)
     if not proto_args:
         proto_args = 'void'
-    #print proto_args
+    # print proto_args
     return proto_args
 
+
 def getusercode(rout):
     return getmultilineblock(rout, 'usercode')
 
+
 def getusercode1(rout):
     return getmultilineblock(rout, 'usercode', counter=1)
 
+
 def getpymethoddef(rout):
     return getmultilineblock(rout, 'pymethoddef')
 
+
 def getargs(rout):
-    sortargs, args=[], []
+    sortargs, args = [], []
     if 'args' in rout:
-        args=rout['args']
+        args = rout['args']
         if 'sortvars' in rout:
             for a in rout['sortvars']:
-                if a in args: sortargs.append(a)
+                if a in args:
+                    sortargs.append(a)
             for a in args:
                 if a not in sortargs:
                     sortargs.append(a)
-        else: sortargs=rout['args']
+        else:
+            sortargs = rout['args']
     return args, sortargs
 
+
 def getargs2(rout):
-    sortargs, args=[], rout.get('args', [])
-    auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])\
+    sortargs, args = [], rout.get('args', [])
+    auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])
                and a not in args]
     args = auxvars + args
     if 'sortvars' in rout:
         for a in rout['sortvars']:
-            if a in args: sortargs.append(a)
+            if a in args:
+                sortargs.append(a)
         for a in args:
             if a not in sortargs:
                 sortargs.append(a)
-    else: sortargs=auxvars + rout['args']
+    else:
+        sortargs = auxvars + rout['args']
     return args, sortargs
 
+
 def getrestdoc(rout):
     if 'f2pymultilines' not in rout:
         return None
     k = None
-    if rout['block']=='python module':
+    if rout['block'] == 'python module':
         k = rout['block'], rout['name']
     return rout['f2pymultilines'].get(k, None)
 
+
 def gentitle(name):
-    l=(80-len(name)-6)//2
-    return '/*%s %s %s*/'%(l*'*', name, l*'*')
+    l = (80 - len(name) - 6) // 2
+    return '/*%s %s %s*/' % (l * '*', name, l * '*')
+
 
 def flatlist(l):
     if isinstance(l, list):
-        return reduce(lambda x,y,f=flatlist:x+f(y), l, [])
+        return reduce(lambda x, y, f=flatlist: x + f(y), l, [])
     return [l]
 
+
 def stripcomma(s):
-    if s and s[-1]==',': return s[:-1]
+    if s and s[-1] == ',':
+        return s[:-1]
     return s
 
-def replace(str,d,defaultsep=''):
+
+def replace(str, d, defaultsep=''):
     if isinstance(d, list):
         return [replace(str, _m, defaultsep) for _m in d]
     if isinstance(str, list):
         return [replace(_m, d, defaultsep) for _m in str]
-    for k in 2*list(d.keys()):
-        if k=='separatorsfor':
+    for k in 2 * list(d.keys()):
+        if k == 'separatorsfor':
             continue
         if 'separatorsfor' in d and k in d['separatorsfor']:
-            sep=d['separatorsfor'][k]
+            sep = d['separatorsfor'][k]
         else:
-            sep=defaultsep
+            sep = defaultsep
         if isinstance(d[k], list):
-            str=str.replace('#%s#'%(k), sep.join(flatlist(d[k])))
+            str = str.replace('#%s#' % (k), sep.join(flatlist(d[k])))
         else:
-            str=str.replace('#%s#'%(k), d[k])
+            str = str.replace('#%s#' % (k), d[k])
     return str
 
+
 def dictappend(rd, ar):
     if isinstance(ar, list):
         for a in ar:
-            rd=dictappend(rd, a)
+            rd = dictappend(rd, a)
         return rd
     for k in ar.keys():
-        if k[0]=='_':
+        if k[0] == '_':
             continue
         if k in rd:
             if isinstance(rd[k], str):
-                rd[k]=[rd[k]]
+                rd[k] = [rd[k]]
             if isinstance(rd[k], list):
                 if isinstance(ar[k], list):
-                    rd[k]=rd[k]+ar[k]
+                    rd[k] = rd[k] + ar[k]
                 else:
                     rd[k].append(ar[k])
             elif isinstance(rd[k], dict):
                 if isinstance(ar[k], dict):
-                    if k=='separatorsfor':
+                    if k == 'separatorsfor':
                         for k1 in ar[k].keys():
                             if k1 not in rd[k]:
-                                rd[k][k1]=ar[k][k1]
+                                rd[k][k1] = ar[k][k1]
                     else:
-                        rd[k]=dictappend(rd[k], ar[k])
+                        rd[k] = dictappend(rd[k], ar[k])
         else:
-            rd[k]=ar[k]
+            rd[k] = ar[k]
     return rd
 
-def applyrules(rules,d,var={}):
-    ret={}
+
+def applyrules(rules, d, var={}):
+    ret = {}
     if isinstance(rules, list):
         for r in rules:
-            rr=applyrules(r, d, var)
-            ret=dictappend(ret, rr)
+            rr = applyrules(r, d, var)
+            ret = dictappend(ret, rr)
             if '_break' in rr:
                 break
         return ret
     if '_check' in rules and (not rules['_check'](var)):
         return ret
     if 'need' in rules:
-        res = applyrules({'needs':rules['need']}, d, var)
+        res = applyrules({'needs': rules['need']}, d, var)
         if 'needs' in res:
             cfuncs.append_needs(res['needs'])
 
     for k in rules.keys():
-        if k=='separatorsfor':
-            ret[k]=rules[k]; continue
+        if k == 'separatorsfor':
+            ret[k] = rules[k]
+            continue
         if isinstance(rules[k], str):
-            ret[k]=replace(rules[k], d)
+            ret[k] = replace(rules[k], d)
         elif isinstance(rules[k], list):
-            ret[k]=[]
+            ret[k] = []
             for i in rules[k]:
-                ar=applyrules({k:i}, d, var)
+                ar = applyrules({k: i}, d, var)
                 if k in ar:
                     ret[k].append(ar[k])
-        elif k[0]=='_':
+        elif k[0] == '_':
             continue
         elif isinstance(rules[k], dict):
-            ret[k]=[]
+            ret[k] = []
             for k1 in rules[k].keys():
                 if isinstance(k1, types.FunctionType) and k1(var):
                     if isinstance(rules[k][k1], list):
                         for i in rules[k][k1]:
                             if isinstance(i, dict):
-                                res=applyrules({'supertext':i}, d, var)
+                                res = applyrules({'supertext': i}, d, var)
                                 if 'supertext' in res:
-                                    i=res['supertext']
-                                else: i=''
+                                    i = res['supertext']
+                                else:
+                                    i = ''
                             ret[k].append(replace(i, d))
                     else:
-                        i=rules[k][k1]
+                        i = rules[k][k1]
                         if isinstance(i, dict):
-                            res=applyrules({'supertext':i}, d)
+                            res = applyrules({'supertext': i}, d)
                             if 'supertext' in res:
-                                i=res['supertext']
-                            else: i=''
+                                i = res['supertext']
+                            else:
+                                i = ''
                         ret[k].append(replace(i, d))
         else:
-            errmess('applyrules: ignoring rule %s.\n'%repr(rules[k]))
+            errmess('applyrules: ignoring rule %s.\n' % repr(rules[k]))
         if isinstance(ret[k], list):
-            if len(ret[k])==1:
-                ret[k]=ret[k][0]
-            if ret[k]==[]:
+            if len(ret[k]) == 1:
+                ret[k] = ret[k][0]
+            if ret[k] == []:
                 del ret[k]
     return ret