[LNT] Python 3 support: Update type comparisons and type names

[hubert.reinterpretcast]

Summary

This patch is split out from D67535, updating type names (or in one case type(1.4)-style goodness) and updating type comparisons with use of isinstance. Additionally, changed a dictionary key lookup for a type mapping.

As requested by reviewers in D67535, spaces are added after commas in what are now tuples of types.

[hubert.reinterpretcast]

• Add spaces around operators on lines touched

[hubert.reinterpretcast]

• Fix !isinstance

[thopre]

Thanks for this massive cleanup. LGTM

lnt/external/stats/pstat.py

 until it is as long as the longest list.  If this behavior is not desired,
 use pstat.simpleabut().
 
 Usage:   abut(source, args)   where args=any # of lists
 Returns: a list of lists as long as the LONGEST list past, source on the
          'left', lists in <args> attached consecutively on the 'right'
 """
 
-    if type(source) not in [ListType,TupleType]:
+    if !isinstance(source, (list, tuple)):
         source = [source]
     for addon in args:
-        if type(addon) not in [ListType,TupleType]:
+        if !isinstance(addon, (list, tuple)):
             addon = [addon]
         if len(addon) < len(source):                # is source list longer?
             if len(source) % len(addon) == 0:        # are they integer multiples?
                 repeats = len(source)/len(addon)    # repeat addon n times
                 origadd = copy.deepcopy(addon)
                 for i in range(repeats-1):
                     addon = addon + origadd
             else:

 repeat either list to make the 2 lists of equal length.  Beware of list pairs
 with different lengths ... the resulting list will be the length of the
 FIRST list passed.
 
 Usage:   simpleabut(source,addon)  where source, addon=list (or list-of-lists)
 Returns: a list of lists as long as source, with source on the 'left' and
                  addon on the 'right'
 """
-    if type(source) not in [ListType,TupleType]:
+    if !isinstance(source, (list, tuple)):
         source = [source]
-    if type(addon) not in [ListType,TupleType]:
+    if !isinstance(addon, (list, tuple)):
         addon = [addon]
     minlen = min(len(source),len(addon))
     list = copy.deepcopy(source)                # start abut process
-    if type(source[0]) not in [ListType,TupleType]:
-        if type(addon[0]) not in [ListType,TupleType]:
+    if !isinstance(source[0], (list, tuple)):
+        if !isinstance(addon[0], (list, tuple)):
             for i in range(minlen):
                 list[i] = [source[i]] + [addon[i]]        # source/addon = column
         else:
             for i in range(minlen):
                 list[i] = [source[i]] + addon[i]        # addon=list-of-lists
     else:
-        if type(addon[0]) not in [ListType,TupleType]:
+        if !isinstance(addon[0], (list, tuple)):
             for i in range(minlen):
                 list[i] = source[i] + [addon[i]]        # source=list-of-lists
         else:
             for i in range(minlen):
                 list[i] = source[i] + addon[i]        # source/addon = list-of-lists
     source = list
     return source
 
 
 def colex (listoflists,cnums):
     """
 Extracts from listoflists the columns specified in the list 'cnums'
 (cnums can be an integer, a sequence of integers, or a string-expression that
 corresponds to a slice operation on the variable x ... e.g., 'x[3:]' will colex
 columns 3 onward from the listoflists).
 
 Usage:   colex (listoflists,cnums)
 Returns: a list-of-lists corresponding to the columns from listoflists
          specified by cnums, in the order the column numbers appear in cnums
 """
     global index
     column = 0
-    if type(cnums) in [ListType,TupleType]:   # if multiple columns to get
+    if isinstance(cnums, (list, tuple)):   # if multiple columns to get
         index = cnums[0]
         column = map(lambda x: x[index], listoflists)
         for col in cnums[1:]:
             index = col
             column = abut(column,map(lambda x: x[index], listoflists))
-    elif type(cnums) == StringType:              # if an 'x[3:]' type expr.
+    elif isinstance(cnums, str):              # if an 'x[3:]' type expr.
         evalstring = 'map(lambda x: x'+cnums+', listoflists)'
         column = eval(evalstring)
     else:                                     # else it's just 1 col to get
         index = cnums
         column = map(lambda x: x[index], listoflists)
     return column
 
 
Returns: a list of lists with all unique permutations of entries appearing in
      collapsecols.
 """
      def collmean (inlist):
          s = 0
          for item in inlist:
              s = s + item
          return s/float(len(inlist))
 
-     if type(keepcols) not in [ListType,TupleType]:
+     if !isinstance(keepcols, (list, tuple)):
          keepcols = [keepcols]
-     if type(collapsecols) not in [ListType,TupleType]:
+     if !isinstance(collapsecols, (list, tuple)):
          collapsecols = [collapsecols]
      if cfcn == None:
          cfcn = collmean
      if keepcols == []:
          means = [0]*len(collapsecols)
          for i in range(len(collapsecols)):
              avgcol = colex(listoflists,collapsecols[i])
              means[i] = cfcn(avgcol)
if keepcols == []:
                  except TypeError:
                      means[i] = [means[i],len(avgcol)]
          return means
      else:
          values = colex(listoflists,keepcols)
          uniques = unique(values)
          uniques.sort()
          newlist = []
-         if type(keepcols) not in [ListType,TupleType]:  keepcols = [keepcols]
+         if !isinstance(keepcols, (list, tuple)):  keepcols = [keepcols]
          for item in uniques:
-             if type(item) not in [ListType,TupleType]:  item =[item]
+             if !isinstance(item, (list, tuple)):  item =[item]
              tmprows = linexand(listoflists,keepcols,item)
              for col in collapsecols:
                  avgcol = colex(tmprows,col)
                  item.append(cfcn(avgcol))
                  if fcn1 <> None:
                      try:
                          test = fcn1(avgcol)
                      except:
def linexand (listoflists,columnlist,valuelist):
     """
 Returns the rows of a list of lists where col (from columnlist) = val
 (from valuelist) for EVERY pair of values (columnlist[i],valuelists[i]).
 len(columnlist) must equal len(valuelist).
 
 Usage:   linexand (listoflists,columnlist,valuelist)
 Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ALL i
 """
-    if type(columnlist) not in [ListType,TupleType]:
+    if !isinstance(columnlist, (list, tuple)):
         columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType]:
+    if !isinstance(valuelist, (list, tuple)):
         valuelist = [valuelist]
     criterion = ''
     for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
+        if isinstance(valuelist[i], str):
             critval = '\'' + valuelist[i] + '\''
         else:
             critval = str(valuelist[i])
         criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
     criterion = criterion[0:-3]         # remove the "and" after the last crit
     function = 'filter(lambda x: '+criterion+',listoflists)'
     lines = eval(function)
     return lines
 
 
 def linexor (listoflists,columnlist,valuelist):
     """
 Returns the rows of a list of lists where col (from columnlist) = val
 (from valuelist) for ANY pair of values (colunmlist[i],valuelist[i[).
 One value is required for each column in columnlist.  If only one value
 exists for columnlist but multiple values appear in valuelist, the
 valuelist values are all assumed to pertain to the same column.
 
 Usage:   linexor (listoflists,columnlist,valuelist)
 Returns: the rows of listoflists where columnlist[i]=valuelist[i] for ANY i
 """
-    if type(columnlist) not in [ListType,TupleType]:
+    if !isinstance(columnlist, (list, tuple)):
         columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType]:
+    if !isinstance(valuelist, (list, tuple)):
         valuelist = [valuelist]
     criterion = ''
     if len(columnlist) == 1 and len(valuelist) > 1:
         columnlist = columnlist*len(valuelist)
     for i in range(len(columnlist)):          # build an exec string
-        if type(valuelist[i])==StringType:
+        if isinstance(valuelist[i], str):
             critval = '\'' + valuelist[i] + '\''
         else:
             critval = str(valuelist[i])
         criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
     criterion = criterion[0:-2]         # remove the "or" after the last crit
     function = 'filter(lambda x: '+criterion+',listoflists)'
     lines = eval(function)
     return lines
 
 
 def linedelimited (inlist,delimiter):
     """
 Returns a string composed of elements in inlist, with each element
 separated by 'delimiter.'  Used by function writedelimited.  Use '\t'
 for tab-delimiting.
 
 Usage:   linedelimited (inlist,delimiter)
 """
     outstr = ''
     for item in inlist:
-        if type(item) <> StringType:
+        if !isinstance(item, str):
             item = str(item)
         outstr = outstr + item + delimiter
     outstr = outstr[0:-1]
     return outstr
 
 
 def lineincols (inlist,colsize):
     """
 Returns a string composed of elements in inlist, with each element
 right-aligned in columns of (fixed) colsize.
 
 Usage:   lineincols (inlist,colsize)   where colsize is an integer
 """
     outstr = ''
     for item in inlist:
-        if type(item) <> StringType:
+        if !isinstance(item, str):
             item = str(item)
         size = len(item)
         if size <= colsize:
             for i in range(colsize-size):
                 outstr = outstr + ' '
             outstr = outstr + item
         else:
             outstr = outstr + item[0:colsize+1]
     return outstr
 
 
 def lineincustcols (inlist,colsizes):
     """
 Returns a string composed of elements in inlist, with each element
 right-aligned in a column of width specified by a sequence colsizes.  The
 length of colsizes must be greater than or equal to the number of columns
 in inlist.
 
 Usage:   lineincustcols (inlist,colsizes)
 Returns: formatted string created from inlist
 """
     outstr = ''
     for i in range(len(inlist)):
-        if type(inlist[i]) <> StringType:
+        if !isinstance(inlist[i], str):
             item = str(inlist[i])
         else:
             item = inlist[i]
         size = len(item)
         if size <= colsizes[i]:
             for j in range(colsizes[i]-size):
                 outstr = outstr + ' '
             outstr = outstr + item

 """
     x = []
     for item in inlist:
         x.append([item])
     return x
 
 
 def makestr (x):
-    if type(x) <> StringType:
+    if !isinstance(x, str):
         x = str(x)
     return x
 
 
 def printcc (lst,extra=2):
     """
 Prints a list of lists in columns, customized by the max size of items
 within the columns (max size of items in col, plus 'extra' number of spaces).
 Use 'dashes' or '\\n' in the list-of-lists to print dashes or blank lines,
 respectively.
 
 Usage:   printcc (lst,extra=2)
 Returns: None
 """
-    if type(lst[0]) not in [ListType,TupleType]:
+    if !isinstance(lst[0], (list, tuple)):
         lst = [lst]
     rowstokill = []
     list2print = copy.deepcopy(lst)
     for i in range(len(lst)):
         if lst[i] == ['\n'] or lst[i]=='\n' or lst[i]=='dashes' or lst[i]=='' or lst[i]==['']:
             rowstokill = rowstokill + [i]
     rowstokill.reverse()   # delete blank rows from the end
     for row in rowstokill:

 def replace (inlst,oldval,newval):
     """
 Replaces all occurrences of 'oldval' with 'newval', recursively.
 
 Usage:   replace (inlst,oldval,newval)
 """
     lst = inlst*1
     for i in range(len(lst)):
-        if type(lst[i]) not in [ListType,TupleType]:
+        if !isinstance(lst[i], (list, tuple)):
             if lst[i]==oldval: lst[i]=newval
         else:
             lst[i] = replace(lst[i],oldval,newval)
     return lst
 
 
 def recode (inlist,listmap,cols=None):
     """
 Changes the values in a list to a new set of values (useful when
 you need to recode data from (e.g.) strings to numbers.  cols defaults
 to None (meaning all columns are recoded).
 
 Usage:   recode (inlist,listmap,cols=None)  cols=recode cols, listmap=2D list
 Returns: inlist with the appropriate values replaced with new ones
 """
     lst = copy.deepcopy(inlist)
     if cols != None:
-        if type(cols) not in [ListType,TupleType]:
+        if !isinstance(cols, (list, tuple)):
             cols = [cols]
         for col in cols:
             for row in range(len(lst)):
                 try:
                     idx = colex(listmap,0).index(lst[row][col])
                     lst[row][col] = listmap[idx][1]
                 except ValueError:
                     pass
"""
     function = 'map(lambda x: '+criterion+',listoflists)'
     lines = eval(function)
     return lines
 
 
 def roundlist (inlist,digits):
     """
 Goes through each element in a 1D or 2D inlist, and applies the following
-function to all elements of FloatType ... round(element,digits).
+function to all elements of float ... round(element,digits).
 
 Usage:   roundlist(inlist,digits)
 Returns: list with rounded floats
 """
-    if type(inlist[0]) in [IntType, FloatType]:
+    if isinstance(inlist[0], (int, float)):
         inlist = [inlist]
     l = inlist*1
     for i in range(len(l)):
         for j in range(len(l[i])):
-            if type(l[i][j])==FloatType:
+            if isinstance(l[i][j], float):
                 l[i][j] = round(l[i][j],digits)
     return l
 
 
 def sortby(listoflists,sortcols):
     """
 Sorts a list of lists on the column(s) specified in the sequence
 sortcols.
def acolex (a,indices,axis=1):
     """
 Extracts specified indices (a list) from passed array, along passed
 axis (column extraction is default).  BEWARE: A 1D array is presumed to be a
 column-array (and that the whole array will be returned as a column).
 
 Usage:   acolex (a,indices,axis=1)
 Returns: the columns of a specified by indices
 """
-    if type(indices) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(indices, (list, tuple, N.ndarray)):
         indices = [indices]
     if len(N.shape(a)) == 1:
         cols = N.resize(a,[a.shape[0],1])
     else:
         cols = N.take(a,indices,axis)
     return cols
 
 
  def acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None):
     """
 Averages data in collapsecol, keeping all unique items in keepcols
 (using unique, which keeps unique LISTS of column numbers), retaining
 the unique sets of values in keepcols, the mean for each.  If stderror or
 N of the mean are desired, set either or both parameters to 1.
 
 Usage:   acollapse (a,keepcols,collapsecols,fcn1=None,fcn2=None,cfcn=None)
 Returns: unique 'conditions' specified by the contents of columns specified
          by keepcols, abutted with the mean(s) of column(s) specified by
          collapsecols
 """
     def acollmean (inarray):
         return N.sum(N.ravel(inarray))
 
-    if type(keepcols) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(keepcols, (list, tuple, N.ndarray)):
         keepcols = [keepcols]
-    if type(collapsecols) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(collapsecols, (list, tuple, N.ndarray)):
         collapsecols = [collapsecols]
 
     if cfcn == None:
         cfcn = acollmean
     if keepcols == []:
         avgcol = acolex(a,collapsecols)
         means = N.sum(avgcol)/float(len(avgcol))
         if fcn1<>None:
             try:
                 test = fcn1(avgcol)
             except:
                 test = N.array(['N/A']*len(means))
             means = aabut(means,test)
         if fcn2<>None:
             try:
                 test = fcn2(avgcol)
             except:
                 test = N.array(['N/A']*len(means))
             means = aabut(means,test)
         return means
     else:
-        if type(keepcols) not in [ListType,TupleType,N.ndarray]:
+        if !isinstance(keepcols, (list, tuple, N.ndarray)):
             keepcols = [keepcols]
         values = colex(a,keepcols)   # so that "item" can be appended (below)
         uniques = unique(values)  # get a LIST, so .sort keeps rows intact
         uniques.sort()
         newlist = []
         for item in uniques:
-            if type(item) not in [ListType,TupleType,N.ndarray]:
+            if !isinstance(item, (list, tuple, N.ndarray)):
                 item =[item]
             tmprows = alinexand(a,keepcols,item)
             for col in collapsecols:
                 avgcol = acolex(tmprows,col)
                 item.append(acollmean(avgcol))
                 if fcn1<>None:
                     try:
                         test = fcn1(avgcol)
"""
     try:
         lines = N.array(lines)
     except:
         lines = N.array(lines,dtype='O')
     return lines
 
 
  def isstring(x):
-    if type(x)==StringType:
+    if isinstance(x, str):
         return 1
     else:
         return 0
 
 
  def alinexand (a,columnlist,valuelist):
     """
 Returns the rows of an array where col (from columnlist) = val
 (from valuelist).  One value is required for each column in columnlist.
 
 Usage:   alinexand (a,columnlist,valuelist)
 Returns: the rows of a where columnlist[i]=valuelist[i] for ALL i
 """
-    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(columnlist, (list, tuple, N.ndarray)):
         columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(valuelist, (list, tuple, N.ndarray)):
         valuelist = [valuelist]
     criterion = ''
     for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
+        if isinstance(valuelist[i], str):
             critval = '\'' + valuelist[i] + '\''
         else:
             critval = str(valuelist[i])
         criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' and'
     criterion = criterion[0:-3]         # remove the "and" after the last crit
     return adm(a,criterion)
 
 
  def alinexor (a,columnlist,valuelist):
     """
 Returns the rows of an array where col (from columnlist) = val (from
 valuelist).  One value is required for each column in columnlist.
 The exception is if either columnlist or valuelist has only 1 value,
 in which case that item will be expanded to match the length of the
 other list.
 
 Usage:   alinexor (a,columnlist,valuelist)
 Returns: the rows of a where columnlist[i]=valuelist[i] for ANY i
 """
-    if type(columnlist) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(columnlist, (list, tuple, N.ndarray)):
         columnlist = [columnlist]
-    if type(valuelist) not in [ListType,TupleType,N.ndarray]:
+    if !isinstance(valuelist, (list, tuple, N.ndarray)):
         valuelist = [valuelist]
     criterion = ''
     if len(columnlist) == 1 and len(valuelist) > 1:
         columnlist = columnlist*len(valuelist)
     elif len(valuelist) == 1 and len(columnlist) > 1:
         valuelist = valuelist*len(columnlist)
     for i in range(len(columnlist)):
-        if type(valuelist[i])==StringType:
+        if isinstance(valuelist[i], str):
             critval = '\'' + valuelist[i] + '\''
         else:
             critval = str(valuelist[i])
         criterion = criterion + ' x['+str(columnlist[i])+']=='+critval+' or'
     criterion = criterion[0:-2]         # remove the "or" after the last crit
     return adm(a,criterion)
 
 

 """
     ashape = a.shape
     if col == 'all':
         work = a.ravel()
     else:
         work = acolex(a,col)
         work = work.ravel()
     for pair in listmap:
-        if type(pair[1]) == StringType or work.dtype.char=='O' or a.dtype.char=='O':
+        if isinstance(pair[1], str) or work.dtype.char == 'O' or a.dtype.char == 'O':
             work = N.array(work,dtype='O')
             a = N.array(a,dtype='O')
             for i in range(len(work)):
                 if work[i]==pair[0]:
                     work[i] = pair[1]
             if col == 'all':
                 return N.reshape(work,ashape)
             else:

lnt/external/stats/stats.py

 array arguments, respectively.  That is, print stats.lmean.__doc__ or
 print stats.amean.__doc__ or whatever.
 """
 
     def __init__(self, *tuples):
         self._dispatch = {}
         for func, types in tuples:
             for t in types:
-                if t in self._dispatch.keys():
+                if t in self._dispatch:
                     raise ValueError, "can't have two dispatches on "+str(t)
                 self._dispatch[t] = func
-        self._types = self._dispatch.keys()
 
     def __call__(self, arg1, *args, **kw):
-        if type(arg1) not in self._types:
+        if type(arg1) not in self._dispatch:
             raise TypeError, "don't know how to dispatch %s arguments" %  type(arg1)
         return apply(self._dispatch[type(arg1)], (arg1,) + args, kw)
 
 
 ##########################################################################
 ########################   LIST-BASED FUNCTIONS   ########################
 ##########################################################################
 

 necessarily integers).  Default number of bins is 10.  If no sequence object
 is given for defaultreallimits, the routine picks (usually non-pretty) bins
 spanning all the numbers in the inlist.
 
 Usage:   lhistogram (inlist, numbins=10, defaultreallimits=None,suppressoutput=0)
 Returns: list of bin values, lowerreallimit, binsize, extrapoints
 """
     if (defaultreallimits <> None):
-        if type(defaultreallimits) not in [ListType,TupleType] or len(defaultreallimits)==1: # only one limit given, assumed to be lower one & upper is calc'd
+        if !isinstance(defaultreallimits, (list, tuple)) or len(defaultreallimits) == 1: # only one limit given, assumed to be lower one & upper is calc'd
             lowerreallimit = defaultreallimits
             upperreallimit = 1.000001 * max(inlist)
         else: # assume both limits given
             lowerreallimit = defaultreallimits[0]
             upperreallimit = defaultreallimits[1]
         binsize = (upperreallimit-lowerreallimit)/float(numbins)
     else:     # no limits given for histogram, both must be calc'd
         estbinwidth=(max(inlist)-min(inlist))/float(numbins) +1e-6 #1=>cover all
def writecc (listoflists,file,writetype='w',extra=2):
     """
 Writes a list of lists to a file in columns, customized by the max
 size of items within the columns (max size of items in col, +2 characters)
 to specified file.  File-overwrite is the default.
 
 Usage:   writecc (listoflists,file,writetype='w',extra=2)
 Returns: None
 """
-    if type(listoflists[0]) not in [ListType,TupleType]:
+    if !isinstance(listoflists[0], (list, tuple)):
         listoflists = [listoflists]
     outfile = open(file,writetype)
     rowstokill = []
     list2print = copy.deepcopy(listoflists)
     for i in range(len(listoflists)):
         if listoflists[i] == ['\n'] or listoflists[i]=='\n' or listoflists[i]=='dashes':
             rowstokill = rowstokill + [i]
     rowstokill.reverse()
"""
     except:
         pass
     if  prob < 0.001:  suffix = '  ***'
     elif prob < 0.01:  suffix = '  **'
     elif prob < 0.05:  suffix = '  *'
     title = [['Name','N','Mean','SD','Min','Max']]
     lofl = title+[[name1,n1,round(m1,3),round(math.sqrt(se1),3),min1,max1],
                   [name2,n2,round(m2,3),round(math.sqrt(se2),3),min2,max2]]
-    if type(fname)<>StringType or len(fname)==0:
+    if !isinstance(fname, str) or len(fname) == 0:
         print()
         print(statname)
         print()
         pstat.printcc(lofl)
         print()
         try:
             if stat.shape == ():
                 stat = stat[0]

 
 #########################################################
 #########################################################
 ####### DISPATCH LISTS AND TUPLES TO ABOVE FCNS #########
 #########################################################
 #########################################################
 
 ## CENTRAL TENDENCY:
-geometricmean = Dispatch ( (lgeometricmean, (ListType, TupleType)), )
-harmonicmean = Dispatch ( (lharmonicmean, (ListType, TupleType)), )
-mean = Dispatch ( (lmean, (ListType, TupleType)), )
-median = Dispatch ( (lmedian, (ListType, TupleType)), )
-medianscore = Dispatch ( (lmedianscore, (ListType, TupleType)), )
-mode = Dispatch ( (lmode, (ListType, TupleType)), )
+geometricmean = Dispatch ( (lgeometricmean, (list, tuple)), )
+harmonicmean = Dispatch ( (lharmonicmean, (list, tuple)), )
+mean = Dispatch ( (lmean, (list, tuple)), )
+median = Dispatch ( (lmedian, (list, tuple)), )
+medianscore = Dispatch ( (lmedianscore, (list, tuple)), )
+mode = Dispatch ( (lmode, (list, tuple)), )
 
 ## MOMENTS:
-moment = Dispatch ( (lmoment, (ListType, TupleType)), )
-variation = Dispatch ( (lvariation, (ListType, TupleType)), )
-skew = Dispatch ( (lskew, (ListType, TupleType)), )
-kurtosis = Dispatch ( (lkurtosis, (ListType, TupleType)), )
-describe = Dispatch ( (ldescribe, (ListType, TupleType)), )
+moment = Dispatch ( (lmoment, (list, tuple)), )
+variation = Dispatch ( (lvariation, (list, tuple)), )
+skew = Dispatch ( (lskew, (list, tuple)), )
+kurtosis = Dispatch ( (lkurtosis, (list, tuple)), )
+describe = Dispatch ( (ldescribe, (list, tuple)), )
 
 ## FREQUENCY STATISTICS:
-itemfreq = Dispatch ( (litemfreq, (ListType, TupleType)), )
-scoreatpercentile = Dispatch ( (lscoreatpercentile, (ListType, TupleType)), )
-percentileofscore = Dispatch ( (lpercentileofscore, (ListType, TupleType)), )
-histogram = Dispatch ( (lhistogram, (ListType, TupleType)), )
-cumfreq = Dispatch ( (lcumfreq, (ListType, TupleType)), )
-relfreq = Dispatch ( (lrelfreq, (ListType, TupleType)), )
+itemfreq = Dispatch ( (litemfreq, (list, tuple)), )
+scoreatpercentile = Dispatch ( (lscoreatpercentile, (list, tuple)), )
+percentileofscore = Dispatch ( (lpercentileofscore, (list, tuple)), )
+histogram = Dispatch ( (lhistogram, (list, tuple)), )
+cumfreq = Dispatch ( (lcumfreq, (list, tuple)), )
+relfreq = Dispatch ( (lrelfreq, (list, tuple)), )
 
 ## VARIABILITY:
-obrientransform = Dispatch ( (lobrientransform, (ListType, TupleType)), )
-samplevar = Dispatch ( (lsamplevar, (ListType, TupleType)), )
-samplestdev = Dispatch ( (lsamplestdev, (ListType, TupleType)), )
-var = Dispatch ( (lvar, (ListType, TupleType)), )
-stdev = Dispatch ( (lstdev, (ListType, TupleType)), )
-sterr = Dispatch ( (lsterr, (ListType, TupleType)), )
-sem = Dispatch ( (lsem, (ListType, TupleType)), )
-z = Dispatch ( (lz, (ListType, TupleType)), )
-zs = Dispatch ( (lzs, (ListType, TupleType)), )
+obrientransform = Dispatch ( (lobrientransform, (list, tuple)), )
+samplevar = Dispatch ( (lsamplevar, (list, tuple)), )
+samplestdev = Dispatch ( (lsamplestdev, (list, tuple)), )
+var = Dispatch ( (lvar, (list, tuple)), )
+stdev = Dispatch ( (lstdev, (list, tuple)), )
+sterr = Dispatch ( (lsterr, (list, tuple)), )
+sem = Dispatch ( (lsem, (list, tuple)), )
+z = Dispatch ( (lz, (list, tuple)), )
+zs = Dispatch ( (lzs, (list, tuple)), )
 
 ## TRIMMING FCNS:
-trimboth = Dispatch ( (ltrimboth, (ListType, TupleType)), )
-trim1 = Dispatch ( (ltrim1, (ListType, TupleType)), )
+trimboth = Dispatch ( (ltrimboth, (list, tuple)), )
+trim1 = Dispatch ( (ltrim1, (list, tuple)), )
 
 ## CORRELATION FCNS:
-paired = Dispatch ( (lpaired, (ListType, TupleType)), )
-pearsonr = Dispatch ( (lpearsonr, (ListType, TupleType)), )
-spearmanr = Dispatch ( (lspearmanr, (ListType, TupleType)), )
-pointbiserialr = Dispatch ( (lpointbiserialr, (ListType, TupleType)), )
-kendalltau = Dispatch ( (lkendalltau, (ListType, TupleType)), )
-linregress = Dispatch ( (llinregress, (ListType, TupleType)), )
+paired = Dispatch ( (lpaired, (list, tuple)), )
+pearsonr = Dispatch ( (lpearsonr, (list, tuple)), )
+spearmanr = Dispatch ( (lspearmanr, (list, tuple)), )
+pointbiserialr = Dispatch ( (lpointbiserialr, (list, tuple)), )
+kendalltau = Dispatch ( (lkendalltau, (list, tuple)), )
+linregress = Dispatch ( (llinregress, (list, tuple)), )
 
 ## INFERENTIAL STATS:
-ttest_1samp = Dispatch ( (lttest_1samp, (ListType, TupleType)), )
-ttest_ind = Dispatch ( (lttest_ind, (ListType, TupleType)), )
-ttest_rel = Dispatch ( (lttest_rel, (ListType, TupleType)), )
-chisquare = Dispatch ( (lchisquare, (ListType, TupleType)), )
-ks_2samp = Dispatch ( (lks_2samp, (ListType, TupleType)), )
-mannwhitneyu = Dispatch ( (lmannwhitneyu, (ListType, TupleType)), )
-ranksums = Dispatch ( (lranksums, (ListType, TupleType)), )
-tiecorrect = Dispatch ( (ltiecorrect, (ListType, TupleType)), )
-wilcoxont = Dispatch ( (lwilcoxont, (ListType, TupleType)), )
-kruskalwallish = Dispatch ( (lkruskalwallish, (ListType, TupleType)), )
-friedmanchisquare = Dispatch ( (lfriedmanchisquare, (ListType, TupleType)), )
+ttest_1samp = Dispatch ( (lttest_1samp, (list, tuple)), )
+ttest_ind = Dispatch ( (lttest_ind, (list, tuple)), )
+ttest_rel = Dispatch ( (lttest_rel, (list, tuple)), )
+chisquare = Dispatch ( (lchisquare, (list, tuple)), )
+ks_2samp = Dispatch ( (lks_2samp, (list, tuple)), )
+mannwhitneyu = Dispatch ( (lmannwhitneyu, (list, tuple)), )
+ranksums = Dispatch ( (lranksums, (list, tuple)), )
+tiecorrect = Dispatch ( (ltiecorrect, (list, tuple)), )
+wilcoxont = Dispatch ( (lwilcoxont, (list, tuple)), )
+kruskalwallish = Dispatch ( (lkruskalwallish, (list, tuple)), )
+friedmanchisquare = Dispatch ( (lfriedmanchisquare, (list, tuple)), )
 
 ## PROBABILITY CALCS:
-chisqprob = Dispatch ( (lchisqprob, (IntType, FloatType)), )
-zprob = Dispatch ( (lzprob, (IntType, FloatType)), )
-ksprob = Dispatch ( (lksprob, (IntType, FloatType)), )
-fprob = Dispatch ( (lfprob, (IntType, FloatType)), )
-betacf = Dispatch ( (lbetacf, (IntType, FloatType)), )
-betai = Dispatch ( (lbetai, (IntType, FloatType)), )
-erfcc = Dispatch ( (lerfcc, (IntType, FloatType)), )
-gammln = Dispatch ( (lgammln, (IntType, FloatType)), )
+chisqprob = Dispatch ( (lchisqprob, (int, float)), )
+zprob = Dispatch ( (lzprob, (int, float)), )
+ksprob = Dispatch ( (lksprob, (int, float)), )
+fprob = Dispatch ( (lfprob, (int, float)), )
+betacf = Dispatch ( (lbetacf, (int, float)), )
+betai = Dispatch ( (lbetai, (int, float)), )
+erfcc = Dispatch ( (lerfcc, (int, float)), )
+gammln = Dispatch ( (lgammln, (int, float)), )
 
 ## ANOVA FUNCTIONS:
-F_oneway = Dispatch ( (lF_oneway, (ListType, TupleType)), )
-F_value = Dispatch ( (lF_value, (ListType, TupleType)), )
+F_oneway = Dispatch ( (lF_oneway, (list, tuple)), )
+F_value = Dispatch ( (lF_value, (list, tuple)), )
 
 ## SUPPORT FUNCTIONS:
-incr = Dispatch ( (lincr, (ListType, TupleType)), )
-sum = Dispatch ( (lsum, (ListType, TupleType)), )
-cumsum = Dispatch ( (lcumsum, (ListType, TupleType)), )
-ss = Dispatch ( (lss, (ListType, TupleType)), )
-summult = Dispatch ( (lsummult, (ListType, TupleType)), )
-square_of_sums = Dispatch ( (lsquare_of_sums, (ListType, TupleType)), )
-sumdiffsquared = Dispatch ( (lsumdiffsquared, (ListType, TupleType)), )
-shellsort = Dispatch ( (lshellsort, (ListType, TupleType)), )
-rankdata = Dispatch ( (lrankdata, (ListType, TupleType)), )
-findwithin = Dispatch ( (lfindwithin, (ListType, TupleType)), )
+incr = Dispatch ( (lincr, (list, tuple)), )
+sum = Dispatch ( (lsum, (list, tuple)), )
+cumsum = Dispatch ( (lcumsum, (list, tuple)), )
+ss = Dispatch ( (lss, (list, tuple)), )
+summult = Dispatch ( (lsummult, (list, tuple)), )
+square_of_sums = Dispatch ( (lsquare_of_sums, (list, tuple)), )
+sumdiffsquared = Dispatch ( (lsumdiffsquared, (list, tuple)), )
+shellsort = Dispatch ( (lshellsort, (list, tuple)), )
+rankdata = Dispatch ( (lrankdata, (list, tuple)), )
+findwithin = Dispatch ( (lfindwithin, (list, tuple)), )
 
 
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============
 #=============  THE ARRAY-VERSION OF THE STATS FUNCTIONS  ===============

 Returns: geometric mean computed over dim(s) listed in dimension
 """
     inarray = N.array(inarray,N.float_)
     if dimension == None:
         inarray = N.ravel(inarray)
         size = len(inarray)
         mult = N.power(inarray,1.0/size)
         mult = N.multiply.reduce(mult)
-    elif type(dimension) in [IntType,FloatType]:
+    elif isinstance(dimension, (int, float)):
         size = inarray.shape[dimension]
         mult = N.power(inarray,1.0/size)
         mult = N.multiply.reduce(mult,dimension)
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             sum = N.reshape(sum,shp)
     else: # must be a SEQUENCE of dims to average over

 Usage:   aharmonicmean(inarray,dimension=None,keepdims=0)
 Returns: harmonic mean computed over dim(s) in dimension
 """
     inarray = inarray.astype(N.float_)
     if dimension == None:
         inarray = N.ravel(inarray)
         size = len(inarray)
         s = N.add.reduce(1.0 / inarray)
-    elif type(dimension) in [IntType,FloatType]:
+    elif isinstance(dimension, (int, float)):
         size = float(inarray.shape[dimension])
         s = N.add.reduce(1.0/inarray, dimension)
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             s = N.reshape(s,shp)
     else: # must be a SEQUENCE of dims to average over
         dims = list(dimension)

 Returns: arithematic mean calculated over dim(s) in dimension
 """
     if inarray.dtype in [N.int_, N.short,N.ubyte]:
         inarray = inarray.astype(N.float_)
     if dimension == None:
         inarray = N.ravel(inarray)
         sum = N.add.reduce(inarray)
         denom = float(len(inarray))
-    elif type(dimension) in [IntType,FloatType]:
+    elif isinstance(dimension, (int, float)):
         sum = asum(inarray,dimension)
         denom = float(inarray.shape[dimension])
         if keepdims == 1:
             shp = list(inarray.shape)
             shp[dimension] = 1
             sum = N.reshape(sum,shp)
     else: # must be a TUPLE of dims to average over
         dims = list(dimension)

 (respectively) are open/exclusive (0) or closed/inclusive (1).
 
 Usage:   atmean(a,limits=None,inclusive=(1,1))
 """
      if a.dtype in [N.int_, N.short,N.ubyte]:
          a = a.astype(N.float_)
      if limits == None:
          return mean(a)
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atmean"
+     assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atmean"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atmean)."
      elif limits[0]==None and limits[1]<>None:
          mask = upperfcn(a,limits[1])

 and upper limiting bounds (respectively) are open/exclusive (0) or
 closed/inclusive (1). ASSUMES A FLAT ARRAY (OR ELSE PREFLATTENS).
 
 Usage:   atvar(a,limits=None,inclusive=(1,1))
 """
      a = a.astype(N.float_)
      if limits == None or limits == [None,None]:
          return avar(a)
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atvar"
+     assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atvar"
      if inclusive[0]:    lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:    upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atvar)."
      elif limits[0]==None and limits[1]<>None:
          mask = upperfcn(a,limits[1])

 open/exclusive (0) or closed/inclusive (1).
 
 Usage:   atsem(a,limits=None,inclusive=(1,1))
 """
      sd = tstdev(a,limits,inclusive)
      if limits == None or limits == [None,None]:
          n = float(len(N.ravel(a)))
          limits = [min(a)-1, max(a)+1]
-     assert type(limits) in [ListType,TupleType,N.ndarray], "Wrong type for limits in atsem"
+     assert isinstance(limits, (list, tuple, N.ndarray)), "Wrong type for limits in atsem"
      if inclusive[0]:         lowerfcn = N.greater_equal
      else:               lowerfcn = N.greater
      if inclusive[1]:         upperfcn = N.less_equal
      else:               upperfcn = N.less
      if limits[0] > N.maximum.reduce(N.ravel(a)) or limits[1] < N.minimum.reduce(N.ravel(a)):
          raise ValueError, "No array values within given limits (atsem)."
      elif limits[0]==None and limits[1]<>None:
          mask = upperfcn(a,limits[1])

 dimension over which to operate), or a sequence (operate over multiple
 dimensions).
 
 Usage:   askew(a, dimension=None)
 Returns: skew of vals in a along dimension, returning ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),1.5)
     zero = N.equal(denom,0)
-    if type(denom) == N.ndarray and asum(zero) <> 0:
+    if isinstance(denom, N.ndarray) and asum(zero) <> 0:
         print("Number of zeros in askew: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero, 0, amoment(a,3,dimension)/denom)
 
 
  def akurtosis(a,dimension=None):
     """
 Returns the kurtosis of a distribution (normal ==> 3.0; >3 means
 heavier in the tails, and usually more peaked).  Use akurtosistest()
 to see if it's close enough.  Dimension can equal None (ravel array
 first), an integer (the dimension over which to operate), or a
 sequence (operate over multiple dimensions).
 
 Usage:   akurtosis(a,dimension=None)
 Returns: kurtosis of values in a along dimension, and ZERO where all vals equal
 """
     denom = N.power(amoment(a,2,dimension),2)
     zero = N.equal(denom,0)
-    if type(denom) == N.ndarray and asum(zero) <> 0:
+    if isinstance(denom, N.ndarray) and asum(zero) <> 0:
         print("Number of zeros in akurtosis: ", asum(zero))
     denom = denom + zero  # prevent divide-by-zero
     return N.where(zero,0,amoment(a,4,dimension)/denom)
 
 
  def adescribe(inarray,dimension=None):
      """
 Returns several descriptive statistics of the passed array.  Dimension
"""
     if dimension == None:
         inarray = N.ravel(inarray)
         dimension = 0
     if dimension == 1:
         mn = amean(inarray,dimension)[:,N.NewAxis]
     else:
         mn = amean(inarray,dimension,keepdims=1)
     deviations = inarray - mn 
-    if type(dimension) == ListType:
+    if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*inarray.shape[d]
     else:
         n = inarray.shape[dimension]
     svar = ass(deviations,dimension,keepdims) / float(n)
     return svar
 
"""
     if dimension == None:
         x = N.ravel(x)
         y = N.ravel(y)
         dimension = 0
     xmn = amean(x,dimension,1)  # keepdims
     xdeviations = x - xmn
     ymn = amean(y,dimension,1)  # keepdims
     ydeviations = y - ymn
-    if type(dimension) == ListType:
+    if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*x.shape[d]
     else:
         n = x.shape[dimension]
     covar = N.sum(xdeviations*ydeviations)/float(n-1)
     return covar
 
 
  def avar (inarray, dimension=None,keepdims=0):
     """
 Returns the estimated population variance of the values in the passed
 array (i.e., N-1).  Dimension can equal None (ravel array first), an
 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions).  Set keepdims=1 to return an array with the
 same number of dimensions as inarray.
 
 Usage:   avar(inarray,dimension=None,keepdims=0)
 """
     if dimension == None:
         inarray = N.ravel(inarray)
         dimension = 0
     mn = amean(inarray,dimension,1)
     deviations = inarray - mn
-    if type(dimension) == ListType:
+    if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*inarray.shape[d]
     else:
         n = inarray.shape[dimension]
     var = ass(deviations,dimension,keepdims)/float(n-1)
     return var
 

 over multiple dimensions).  Set keepdims=1 to return an array with the
 same number of dimensions as inarray.
 
 Usage:   asem(inarray,dimension=None, keepdims=0)
 """
     if dimension == None:
         inarray = N.ravel(inarray)
         dimension = 0
-    if type(dimension) == ListType:
+    if isinstance(dimension, list):
         n = 1
         for d in dimension:
             n = n*inarray.shape[d]
     else:
         n = inarray.shape[dimension]
     s = asamplestdev(inarray,dimension,keepdims) / N.sqrt(n-1)
     return s
 

 Calculates the t-obtained for the independent samples T-test on ONE group
 of scores a, given a population mean.  If printit=1, results are printed
 to the screen.  If printit='filename', the results are output to 'filename'
 using the given writemode (default=append).  Returns t-value, and prob.
 
 Usage:   attest_1samp(a,popmean,Name='Sample',printit=0,writemode='a')
 Returns: t-value, two-tailed prob
 """
-    if type(a) != N.ndarray:
+    if !isinstance(a, N.ndarray):
         a = N.array(a)
     x = amean(a)
     v = avar(a)
     n = len(a)
     df = n-1
     svar = ((n-1)*v) / float(df)
     t = (x-popmean)/math.sqrt(svar*(1.0/n))
     prob = abetai(0.5*df,0.5,df/(df+t*t))
"""
     df = n1+n2-2
     svar = ((n1-1)*v1+(n2-1)*v2) / float(df)
     zerodivproblem = N.equal(svar,0)
     svar = N.where(zerodivproblem,1,svar)  # avoid zero-division in 1st place
     t = (x1-x2)/N.sqrt(svar*(1.0/n1 + 1.0/n2))  # N-D COMPUTATION HERE!!!!!!
     t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
     probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
 
-    if type(t) == N.ndarray:
+    if isinstance(t, N.ndarray):
         probs = N.reshape(probs,t.shape)
     if probs.shape == (1,):
         probs = probs[0]
         
     if printit <> 0:
-        if type(t) == N.ndarray:
+        if isinstance(t, N.ndarray):
             t = t[0]
-        if type(probs) == N.ndarray:
+        if isinstance(probs, N.ndarray):
             probs = probs[0]
         statname = 'Independent samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n1,x1,v1,N.minimum.reduce(N.ravel(a)),
                           N.maximum.reduce(N.ravel(a)),
                           name2,n2,x2,v2,N.minimum.reduce(N.ravel(b)),
                           N.maximum.reduce(N.ravel(b)),
                           statname,t,probs)
"""
     d = (a-b).astype('d')
 
     denom = N.sqrt((n*N.add.reduce(d*d,dimension) - N.add.reduce(d,dimension)**2) /df)
     zerodivproblem = N.equal(denom,0)
     denom = N.where(zerodivproblem,1,denom)  # avoid zero-division in 1st place
     t = N.add.reduce(d,dimension) / denom      # N-D COMPUTATION HERE!!!!!!
     t = N.where(zerodivproblem,1.0,t)     # replace NaN/wrong t-values with 1.0
     probs = abetai(0.5*df,0.5,float(df)/(df+t*t))
-    if type(t) == N.ndarray:
+    if isinstance(t, N.ndarray):
         probs = N.reshape(probs,t.shape)
     if probs.shape == (1,):
         probs = probs[0]
 
     if printit <> 0:
         statname = 'Related samples T-test.'
         outputpairedstats(printit,writemode,
                           name1,n,x1,v1,N.minimum.reduce(N.ravel(a)),

 Usage:   achisqprob(chisq,df)    chisq=chisquare stat., df=degrees of freedom
 """
     BIG = 200.0
     def ex(x):
         BIG = 200.0
         exponents = N.where(N.less(x,-BIG),-BIG,x)
         return N.exp(exponents)
 
-    if type(chisq) == N.ndarray:
+    if isinstance(chisq, N.ndarray):
         arrayflag = 1
     else:
         arrayflag = 0
         chisq = N.array([chisq])
     if df < 1:
         return N.ones(chisq.shape,N.float)
     probs = N.zeros(chisq.shape,N.float_)
     probs = N.where(N.less_equal(chisq,0),1.0,probs)  # set prob=1 for chisq<0

 
  def aksprob(alam):
      """
 Returns the probability value for a K-S statistic computed via ks_2samp.
 Adapted from Numerical Recipies.  Can handle multiple dimensions.
 
 Usage:   aksprob(alam)
 """
-     if type(alam) == N.ndarray:
+     if isinstance(alam, N.ndarray):
          frozen = -1 *N.ones(alam.shape,N.float64)
          alam = alam.astype(N.float64)
          arrayflag = 1
      else:
          frozen = N.array(-1.)
          alam = N.array(alam,N.float64)
          arrayflag = 1
      mask = N.zeros(alam.shape)

  def afprob (dfnum, dfden, F):
     """
 Returns the 1-tailed significance level (p-value) of an F statistic
 given the degrees of freedom for the numerator (dfR-dfF) and the degrees
 of freedom for the denominator (dfF).  Can handle multiple dims for F.
 
 Usage:   afprob(dfnum, dfden, F)   where usually dfnum=dfbn, dfden=dfwn
 """
-    if type(F) == N.ndarray:
+    if isinstance(F, N.ndarray):
         return abetai(0.5*dfden, 0.5*dfnum, dfden/(1.0*dfden+dfnum*F))
     else:
         return abetai(0.5*dfden, 0.5*dfnum, dfden/float(dfden+dfnum*F))
 
 
  def abetacf(a,b,x,verbose=1):
     """
 Evaluates the continued fraction form of the incomplete Beta function,
 betai.  (Adapted from: Numerical Recipies in C.)  Can handle multiple
 dimensions for x.
 
 Usage:   abetacf(a,b,x,verbose=1)
 """
     ITMAX = 200
     EPS = 3.0e-7
 
     arrayflag = 1
-    if type(x) == N.ndarray:
+    if isinstance(x, N.ndarray):
         frozen = N.ones(x.shape,N.float_) *-1  #start out w/ -1s, should replace all
     else:
         arrayflag = 0
         frozen = N.array([-1])
         x = N.array([x])
     mask = N.zeros(x.shape)
     bm = az = am = 1.0
     qab = a+b

 where a,b>0 and B(a,b) = G(a)*G(b)/(G(a+b)) where G(a) is the gamma
 function of a.  The continued fraction formulation is implemented
 here, using the betacf function.  (Adapted from: Numerical Recipies in
 C.)  Can handle multiple dimensions.
 
 Usage:   abetai(a,b,x,verbose=1)
 """
     TINY = 1e-15
-    if type(a) == N.ndarray:
+    if isinstance(a, N.ndarray):
         if asum(N.less(x,0)+N.greater(x,1)) <> 0:
             raise ValueError, 'Bad x in abetai'
     x = N.where(N.equal(x,0),TINY,x)
     x = N.where(N.equal(x,1.0),1-TINY,x)
 
     bt = N.where(N.equal(x,0)+N.equal(x,1), 0, -1)
     exponents = ( gammln(a+b)-gammln(a)-gammln(b)+a*N.log(x)+b*
                   N.log(1.0-x) )
     # 746 (below) is the MAX POSSIBLE BEFORE OVERFLOW
     exponents = N.where(N.less(exponents,-740),-740,exponents)
     bt = N.exp(exponents)
-    if type(x) == N.ndarray:
+    if isinstance(x, N.ndarray):
         ans = N.where(N.less(x,(a+1)/(a+b+2.0)),
                       bt*abetacf(a,b,x,verbose)/float(a),
                       1.0-bt*abetacf(b,a,1.0-x,verbose)/float(b))
     else:
         if x<(a+1)/(a+b+2.0):
             ans = bt*abetacf(a,b,x,verbose)/float(a)
         else:
             ans = 1.0-bt*abetacf(b,a,1.0-x,verbose)/float(b)
def F_value_multivariate(ER, EF, dfnum, dfden):
      """
 Returns an F-statistic given the following:
         ER  = error associated with the null hypothesis (the Restricted model)
         EF  = error associated with the alternate hypothesis (the Full model)
         dfR = degrees of freedom the Restricted model
         dfF = degrees of freedom associated with the Restricted model
 where ER and EF are matrices from a multivariate F calculation.
 """
-     if type(ER) in [IntType, FloatType]:
+     if isinstance(ER, (int, float)):
          ER = N.array([[ER]])
-     if type(EF) in [IntType, FloatType]:
+     if isinstance(EF, (int, float)):
          EF = N.array([[EF]])
      n_um = (LA.det(ER) - LA.det(EF)) / float(dfnum)
      d_en = LA.det(EF) / float(dfden)
      return n_um / d_en
 
 
 #####################################
 #######  ASUPPORT FUNCTIONS  ########
 #####################################
 
  def asign(a):
     """
 Usage:   asign(a)
 Returns: array shape of a, with -1 where a<0 and +1 where a>=0
 """
     a = N.asarray(a)
-    if ((type(a) == type(1.4)) or (type(a) == type(1))):
+    if isinstance(a, (int, float)):
         return a-a-N.less(a,0)+N.greater(a,0)
     else:
         return N.zeros(N.shape(a))-N.less(a,0)+N.greater(a,0)
 
 
  def asum (a, dimension=None,keepdims=0):
      """
 An alternative to the Numeric.add.reduce function, which allows one to
 (1) collapse over multiple dimensions at once, and/or (2) to retain
 all dimensions in the original array (squashing one down to size.
 Dimension can equal None (ravel array first), an integer (the
 dimension over which to operate), or a sequence (operate over multiple
 dimensions).  If keepdims=1, the resulting array will have as many
 dimensions as the input array.
 
 Usage:   asum(a, dimension=None, keepdims=0)
 Returns: array summed along 'dimension'(s), same _number_ of dims if keepdims=1
 """
-     if type(a) == N.ndarray and a.dtype in [N.int_, N.short, N.ubyte]:
+     if isinstance(a, N.ndarray) and a.dtype in [N.int_, N.short, N.ubyte]:
          a = a.astype(N.float_)
      if dimension == None:
          s = N.sum(N.ravel(a))
-     elif type(dimension) in [IntType,FloatType]:
+     elif isinstance(dimension, (int, float)):
          s = N.add.reduce(a, dimension)
          if keepdims == 1:
              shp = list(a.shape)
              shp[dimension] = 1
              s = N.reshape(s,shp)
      else: # must be a SEQUENCE of dims to sum over
         dims = list(dimension)
         dims.sort()

 integer (the dimension over which to operate), or a sequence (operate
 over multiple dimensions, but this last one just barely makes sense).
 
 Usage:   acumsum(a,dimension=None)
 """
     if dimension == None:
         a = N.ravel(a)
         dimension = 0
-    if type(dimension) in [ListType, TupleType, N.ndarray]:
+    if isinstance(dimension, (list, tuple, N.ndarray)):
         dimension = list(dimension)
         dimension.sort()
         dimension.reverse()
         for d in dimension:
             a = N.add.accumulate(a,d)
         return a
     else:
         return N.add.accumulate(a,dimension)

 
 Usage:   asquare_of_sums(inarray, dimension=None, keepdims=0)
 Returns: the square of the sum over dim(s) in dimension
 """
     if dimension == None:
         inarray = N.ravel(inarray)
         dimension = 0
     s = asum(inarray,dimension,keepdims)
-    if type(s) == N.ndarray:
+    if isinstance(s, N.ndarray):
         return s.astype(N.float_)*s
     else:
         return float(s)*s
 
 
  def asumdiffsquared(a,b, dimension=None, keepdims=0):
     """
 Takes pairwise differences of the values in arrays a and b, squares

 
  #########################################################
  #########################################################
  ######  RE-DEFINE DISPATCHES TO INCLUDE ARRAYS  #########
  #########################################################
  #########################################################
 
 ## CENTRAL TENDENCY:
- geometricmean = Dispatch ( (lgeometricmean, (ListType, TupleType)),
+ geometricmean = Dispatch ( (lgeometricmean, (list, tuple)),
                             (ageometricmean, (N.ndarray,)) )
- harmonicmean = Dispatch ( (lharmonicmean, (ListType, TupleType)),
+ harmonicmean = Dispatch ( (lharmonicmean, (list, tuple)),
                            (aharmonicmean, (N.ndarray,)) )
- mean = Dispatch ( (lmean, (ListType, TupleType)),
+ mean = Dispatch ( (lmean, (list, tuple)),
                    (amean, (N.ndarray,)) )
- median = Dispatch ( (lmedian, (ListType, TupleType)),
+ median = Dispatch ( (lmedian, (list, tuple)),
                      (amedian, (N.ndarray,)) )
- medianscore = Dispatch ( (lmedianscore, (ListType, TupleType)),
+ medianscore = Dispatch ( (lmedianscore, (list, tuple)),
                           (amedianscore, (N.ndarray,)) )
- mode = Dispatch ( (lmode, (ListType, TupleType)),
+ mode = Dispatch ( (lmode, (list, tuple)),
                    (amode, (N.ndarray,)) )
  tmean = Dispatch ( (atmean, (N.ndarray,)) )
  tvar = Dispatch ( (atvar, (N.ndarray,)) )
  tstdev = Dispatch ( (atstdev, (N.ndarray,)) )
  tsem = Dispatch ( (atsem, (N.ndarray,)) )
 
 ## VARIATION:
- moment = Dispatch ( (lmoment, (ListType, TupleType)),
+ moment = Dispatch ( (lmoment, (list, tuple)),
                      (amoment, (N.ndarray,)) )
- variation = Dispatch ( (lvariation, (ListType, TupleType)),
+ variation = Dispatch ( (lvariation, (list, tuple)),
                         (avariation, (N.ndarray,)) )
- skew = Dispatch ( (lskew, (ListType, TupleType)),
+ skew = Dispatch ( (lskew, (list, tuple)),
                    (askew, (N.ndarray,)) )
- kurtosis = Dispatch ( (lkurtosis, (ListType, TupleType)),
+ kurtosis = Dispatch ( (lkurtosis, (list, tuple)),
                        (akurtosis, (N.ndarray,)) )
- describe = Dispatch ( (ldescribe, (ListType, TupleType)),
+ describe = Dispatch ( (ldescribe, (list, tuple)),
                        (adescribe, (N.ndarray,)) )
 
 ## DISTRIBUTION TESTS
 
- skewtest = Dispatch ( (askewtest, (ListType, TupleType)),
+ skewtest = Dispatch ( (askewtest, (list, tuple)),
                        (askewtest, (N.ndarray,)) )
- kurtosistest = Dispatch ( (akurtosistest, (ListType, TupleType)),
+ kurtosistest = Dispatch ( (akurtosistest, (list, tuple)),
                            (akurtosistest, (N.ndarray,)) )
- normaltest = Dispatch ( (anormaltest, (ListType, TupleType)),
+ normaltest = Dispatch ( (anormaltest, (list, tuple)),
                          (anormaltest, (N.ndarray,)) )
 
 ## FREQUENCY STATS:
- itemfreq = Dispatch ( (litemfreq, (ListType, TupleType)),
+ itemfreq = Dispatch ( (litemfreq, (list, tuple)),
                        (aitemfreq, (N.ndarray,)) )
- scoreatpercentile = Dispatch ( (lscoreatpercentile, (ListType, TupleType)),
+ scoreatpercentile = Dispatch ( (lscoreatpercentile, (list, tuple)),
                                 (ascoreatpercentile, (N.ndarray,)) )
- percentileofscore = Dispatch ( (lpercentileofscore, (ListType, TupleType)),
+ percentileofscore = Dispatch ( (lpercentileofscore, (list, tuple)),
                                  (apercentileofscore, (N.ndarray,)) )
- histogram = Dispatch ( (lhistogram, (ListType, TupleType)),
+ histogram = Dispatch ( (lhistogram, (list, tuple)),
                         (ahistogram, (N.ndarray,)) )
- cumfreq = Dispatch ( (lcumfreq, (ListType, TupleType)),
+ cumfreq = Dispatch ( (lcumfreq, (list, tuple)),
                       (acumfreq, (N.ndarray,)) )
- relfreq = Dispatch ( (lrelfreq, (ListType, TupleType)),
+ relfreq = Dispatch ( (lrelfreq, (list, tuple)),
                       (arelfreq, (N.ndarray,)) )
  
 ## VARIABILITY:
- obrientransform = Dispatch ( (lobrientransform, (ListType, TupleType)),
+ obrientransform = Dispatch ( (lobrientransform, (list, tuple)),
                               (aobrientransform, (N.ndarray,)) )
- samplevar = Dispatch ( (lsamplevar, (ListType, TupleType)),
+ samplevar = Dispatch ( (lsamplevar, (list, tuple)),
                         (asamplevar, (N.ndarray,)) )
- samplestdev = Dispatch ( (lsamplestdev, (ListType, TupleType)),
+ samplestdev = Dispatch ( (lsamplestdev, (list, tuple)),
                           (asamplestdev, (N.ndarray,)) )
  signaltonoise = Dispatch( (asignaltonoise, (N.ndarray,)),)
- var = Dispatch ( (lvar, (ListType, TupleType)),
+ var = Dispatch ( (lvar, (list, tuple)),
                   (avar, (N.ndarray,)) )
- stdev = Dispatch ( (lstdev, (ListType, TupleType)),
+ stdev = Dispatch ( (lstdev, (list, tuple)),
                     (astdev, (N.ndarray,)) )
- sterr = Dispatch ( (lsterr, (ListType, TupleType)),
+ sterr = Dispatch ( (lsterr, (list, tuple)),
                     (asterr, (N.ndarray,)) )
- sem = Dispatch ( (lsem, (ListType, TupleType)),
+ sem = Dispatch ( (lsem, (list, tuple)),
                   (asem, (N.ndarray,)) )
- z = Dispatch ( (lz, (ListType, TupleType)),
+ z = Dispatch ( (lz, (list, tuple)),
                 (az, (N.ndarray,)) )
- zs = Dispatch ( (lzs, (ListType, TupleType)),
+ zs = Dispatch ( (lzs, (list, tuple)),
                  (azs, (N.ndarray,)) )
  
 ## TRIMMING FCNS:
  threshold = Dispatch( (athreshold, (N.ndarray,)),)
- trimboth = Dispatch ( (ltrimboth, (ListType, TupleType)),
+ trimboth = Dispatch ( (ltrimboth, (list, tuple)),
                        (atrimboth, (N.ndarray,)) )
- trim1 = Dispatch ( (ltrim1, (ListType, TupleType)),
+ trim1 = Dispatch ( (ltrim1, (list, tuple)),
                     (atrim1, (N.ndarray,)) )
  
 ## CORRELATION FCNS:
- paired = Dispatch ( (lpaired, (ListType, TupleType)),
+ paired = Dispatch ( (lpaired, (list, tuple)),
                      (apaired, (N.ndarray,)) )
- lincc = Dispatch ( (llincc, (ListType, TupleType)),
+ lincc = Dispatch ( (llincc, (list, tuple)),
                        (alincc, (N.ndarray,)) )
- pearsonr = Dispatch ( (lpearsonr, (ListType, TupleType)),
+ pearsonr = Dispatch ( (lpearsonr, (list, tuple)),
                        (apearsonr, (N.ndarray,)) )
- spearmanr = Dispatch ( (lspearmanr, (ListType, TupleType)),
+ spearmanr = Dispatch ( (lspearmanr, (list, tuple)),
                         (aspearmanr, (N.ndarray,)) )
- pointbiserialr = Dispatch ( (lpointbiserialr, (ListType, TupleType)),
+ pointbiserialr = Dispatch ( (lpointbiserialr, (list, tuple)),
                              (apointbiserialr, (N.ndarray,)) )
- kendalltau = Dispatch ( (lkendalltau, (ListType, TupleType)),
+ kendalltau = Dispatch ( (lkendalltau, (list, tuple)),
                          (akendalltau, (N.ndarray,)) )
- linregress = Dispatch ( (llinregress, (ListType, TupleType)),
+ linregress = Dispatch ( (llinregress, (list, tuple)),
                          (alinregress, (N.ndarray,)) )
  
 ## INFERENTIAL STATS:
- ttest_1samp = Dispatch ( (lttest_1samp, (ListType, TupleType)),
+ ttest_1samp = Dispatch ( (lttest_1samp, (list, tuple)),
                           (attest_1samp, (N.ndarray,)) )
- ttest_ind = Dispatch ( (lttest_ind, (ListType, TupleType)),
+ ttest_ind = Dispatch ( (lttest_ind, (list, tuple)),
                         (attest_ind, (N.ndarray,)) )
- ttest_rel = Dispatch ( (lttest_rel, (ListType, TupleType)),
+ ttest_rel = Dispatch ( (lttest_rel, (list, tuple)),
                         (attest_rel, (N.ndarray,)) )
- chisquare = Dispatch ( (lchisquare, (ListType, TupleType)),
+ chisquare = Dispatch ( (lchisquare, (list, tuple)),
                         (achisquare, (N.ndarray,)) )
- ks_2samp = Dispatch ( (lks_2samp, (ListType, TupleType)),
+ ks_2samp = Dispatch ( (lks_2samp, (list, tuple)),
                        (aks_2samp, (N.ndarray,)) )
- mannwhitneyu = Dispatch ( (lmannwhitneyu, (ListType, TupleType)),
+ mannwhitneyu = Dispatch ( (lmannwhitneyu, (list, tuple)),
                            (amannwhitneyu, (N.ndarray,)) )
- tiecorrect = Dispatch ( (ltiecorrect, (ListType, TupleType)),
+ tiecorrect = Dispatch ( (ltiecorrect, (list, tuple)),
                          (atiecorrect, (N.ndarray,)) )
- ranksums = Dispatch ( (lranksums, (ListType, TupleType)),
+ ranksums = Dispatch ( (lranksums, (list, tuple)),
                        (aranksums, (N.ndarray,)) )
- wilcoxont = Dispatch ( (lwilcoxont, (ListType, TupleType)),
+ wilcoxont = Dispatch ( (lwilcoxont, (list, tuple)),
                         (awilcoxont, (N.ndarray,)) )
- kruskalwallish = Dispatch ( (lkruskalwallish, (ListType, TupleType)),
+ kruskalwallish = Dispatch ( (lkruskalwallish, (list, tuple)),
                              (akruskalwallish, (N.ndarray,)) )
- friedmanchisquare = Dispatch ( (lfriedmanchisquare, (ListType, TupleType)),
+ friedmanchisquare = Dispatch ( (lfriedmanchisquare, (list, tuple)),
                                 (afriedmanchisquare, (N.ndarray,)) )
  
 ## PROBABILITY CALCS:
- chisqprob = Dispatch ( (lchisqprob, (IntType, FloatType)),
+ chisqprob = Dispatch ( (lchisqprob, (int, float)),
                         (achisqprob, (N.ndarray,)) )
- zprob = Dispatch ( (lzprob, (IntType, FloatType)),
+ zprob = Dispatch ( (lzprob, (int, float)),
                     (azprob, (N.ndarray,)) )
- ksprob = Dispatch ( (lksprob, (IntType, FloatType)),
+ ksprob = Dispatch ( (lksprob, (int, float)),
                      (aksprob, (N.ndarray,)) )
- fprob = Dispatch ( (lfprob, (IntType, FloatType)),
+ fprob = Dispatch ( (lfprob, (int, float)),
                     (afprob, (N.ndarray,)) )
- betacf = Dispatch ( (lbetacf, (IntType, FloatType)),
+ betacf = Dispatch ( (lbetacf, (int, float)),
                      (abetacf, (N.ndarray,)) )
- betai = Dispatch ( (lbetai, (IntType, FloatType)),
+ betai = Dispatch ( (lbetai, (int, float)),
                     (abetai, (N.ndarray,)) )
- erfcc = Dispatch ( (lerfcc, (IntType, FloatType)),
+ erfcc = Dispatch ( (lerfcc, (int, float)),
                     (aerfcc, (N.ndarray,)) )
- gammln = Dispatch ( (lgammln, (IntType, FloatType)),
+ gammln = Dispatch ( (lgammln, (int, float)),
                      (agammln, (N.ndarray,)) )
  
 ## ANOVA FUNCTIONS:
- F_oneway = Dispatch ( (lF_oneway, (ListType, TupleType)),
+ F_oneway = Dispatch ( (lF_oneway, (list, tuple)),
                        (aF_oneway, (N.ndarray,)) )
- F_value = Dispatch ( (lF_value, (ListType, TupleType)),
+ F_value = Dispatch ( (lF_value, (list, tuple)),
                       (aF_value, (N.ndarray,)) )
 
 ## SUPPORT FUNCTIONS:
- incr = Dispatch ( (lincr, (ListType, TupleType, N.ndarray)), )
- sum = Dispatch ( (lsum, (ListType, TupleType)),
+ incr = Dispatch ( (lincr, (list, tuple, N.ndarray)), )
+ sum = Dispatch ( (lsum, (list, tuple)),
                   (asum, (N.ndarray,)) )
- cumsum = Dispatch ( (lcumsum, (ListType, TupleType)),
+ cumsum = Dispatch ( (lcumsum, (list, tuple)),
                      (acumsum, (N.ndarray,)) )
- ss = Dispatch ( (lss, (ListType, TupleType)),
+ ss = Dispatch ( (lss, (list, tuple)),
                  (ass, (N.ndarray,)) )
- summult = Dispatch ( (lsummult, (ListType, TupleType)),
+ summult = Dispatch ( (lsummult, (list, tuple)),
                       (asummult, (N.ndarray,)) )
- square_of_sums = Dispatch ( (lsquare_of_sums, (ListType, TupleType)),
+ square_of_sums = Dispatch ( (lsquare_of_sums, (list, tuple)),
                              (asquare_of_sums, (N.ndarray,)) )
- sumdiffsquared = Dispatch ( (lsumdiffsquared, (ListType, TupleType)),
+ sumdiffsquared = Dispatch ( (lsumdiffsquared, (list, tuple)),
                              (asumdiffsquared, (N.ndarray,)) )
- shellsort = Dispatch ( (lshellsort, (ListType, TupleType)),
+ shellsort = Dispatch ( (lshellsort, (list, tuple)),
                         (ashellsort, (N.ndarray,)) )
- rankdata = Dispatch ( (lrankdata, (ListType, TupleType)),
+ rankdata = Dispatch ( (lrankdata, (list, tuple)),
                        (arankdata, (N.ndarray,)) )
- findwithin = Dispatch ( (lfindwithin, (ListType, TupleType)),
+ findwithin = Dispatch ( (lfindwithin, (list, tuple)),
                          (afindwithin, (N.ndarray,)) )
 
 ######################  END OF NUMERIC FUNCTION BLOCK  #####################
 
 ######################  END OF STATISTICAL FUNCTIONS  ######################
 
 except ImportError:
  pass

lnt/server/db/regression.py

 def new_regression(session, ts, field_changes):
     """Make a new regression and add to DB."""
     MSG = "Regression of 0 benchmarks"
     title = MSG
     regression = ts.Regression(title, "", RegressionState.DETECTED)
     session.add(regression)
     new_ris = []
     for fc_id in field_changes:
-        if type(fc_id) == int:
+        if isinstance(fc_id, int):
             fc = get_fieldchange(session, ts, fc_id)
         else:
             fc = fc_id
         ri1 = ts.RegressionIndicator(regression, fc)
         new_ris.append(ri1)
     session.add_all(new_ris)
     rebuild_title(session, ts, regression)
     session.commit()

lnt/server/ui/api.py

def decorated(*args, **kwargs):
         return f(*args, **kwargs)
 
     return decorated
 
 
 def with_ts(obj):
     """For Url type fields to work, the objects we return must have a test-suite
     and database attribute set, the function attempts to set them."""
-    if type(obj) == list:
+    if isinstance(obj, list):
         # For lists, set them on all elements.
         return [with_ts(x) for x in obj]
-    if type(obj) == dict:
+    if isinstance(obj, dict):
         # If already a dict, just add the fields.
         new_obj = obj
     else:
         # SQLAlchemy objects are read-only and store their attributes in a
         # sub-dict.  Make a copy so we can edit it.
         new_obj = obj.__dict__.copy()
 
     new_obj['db'] = g.db_name

lnt/server/ui/app.py

class LNTObjectJSONEncoder(flask.json.JSONEncoder):
     method, use that instead."""
 
     def __init__(self,  *args, **kwargs):
         super(LNTObjectJSONEncoder, self).__init__(*args, **kwargs)
 
     def default(self, obj):
         if hasattr(obj, '__json__'):
             return obj.__json__()
-        if type(obj) is datetime.datetime:
+        if isinstance(obj, datetime.datetime):
             return obj.isoformat()
         if isinstance(obj.__class__, DeclarativeMeta):
             fields = {}
             for field in [x for x in dir(obj)
                           if not x.startswith('_') and x != 'metadata']:
                 data = obj.__getattribute__(field)
                 if isinstance(data, datetime.datetime):
                     fields[field] = data.isoformat()

lnt/tests/nt.py

class TestConfiguration(object):
 
     """
 
     def __init__(self, opts, start_time):
         """Prepare the configuration:
         opts -- the command line options object
         start_time -- the time the program was invoked as a string
         """
-        assert type(opts) == dict, "Options must be a dict."
+        assert isinstance(opts, dict), "Options must be a dict."
         self.opts = opts
         self.__dict__.update(opts)
         self.start_time = start_time
 
         # Report directory cache.
         self._report_dir = None
         # Compiler interrogation is a lot of work, this will cache it.
         self._cc_info = None