def rec2csv(rec_array, csv_file, formatd=None, **kwargs): """ Convenience wrapper function on top of mlab.rec2csv to allow fixed- precision output to CSV files Parameters ---------- rec_aray : numpy 1-d recarray The recarray to be written out csv_file : str CSV file name kwargs : dict Keyword arguments to pass through to mlab.rec2csv Returns ------- None """ # Get the formatd objects associated with each field formatd = mlab.get_formatd(rec_array, formatd) # For all FormatFloat objects, switch to FormatDecimal objects for (k, v) in formatd.iteritems(): if isinstance(v, mlab.FormatFloat): formatd[k] = FormatDecimal() # Pass this specification to mlab.rec2csv mlab.rec2csv(rec_array, csv_file, formatd=formatd, **kwargs)
""" generate an editable gtk treeview widget for record arrays with custom formatting of the cells and show how to limit string entries to a list of strings """ import gtk import numpy as np import matplotlib.mlab as mlab import mpl_toolkits.gtktools as gtktools r = mlab.csv2rec('data/demodata.csv', converterd={'weekdays': str}) formatd = mlab.get_formatd(r) formatd['date'] = mlab.FormatDate('%Y-%m-%d') formatd['prices'] = mlab.FormatMillions(precision=1) formatd['gain'] = mlab.FormatPercent(precision=2) # use a drop down combo for weekdays stringd = dict(weekdays=['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']) constant = ['clientid'] # block editing of this field liststore = gtktools.RecListStore(r, formatd=formatd, stringd=stringd) treeview = gtktools.RecTreeView(liststore, constant=constant) def mycallback(liststore, rownum, colname, oldval, newval): print 'verify: old=%s, new=%s, rec=%s' % (oldval, newval, liststore.r[rownum][colname]) liststore.callbacks.connect('cell_changed', mycallback)
def __init__(self, r, formatd=None, stringd=None): """ r is a numpy record array formatd is a dict mapping dtype name to mlab.FormatObj instances stringd, if not None, is a dict mapping dtype names to a list of valid strings for a combo drop down editor """ if stringd is None: stringd = dict() if formatd is None: formatd = mlab.get_formatd(r) self.stringd = stringd self.callbacks = cbook.CallbackRegistry(['cell_changed']) self.r = r self.headers = r.dtype.names self.formats = [ gtkformat_factory(formatd.get(name, mlab.FormatObj()), i) for i, name in enumerate(self.headers) ] # use the gtk attached versions self.formatd = formatd = dict(zip(self.headers, self.formats)) types = [] for format in self.formats: if isinstance(format, mlab.FormatBool): types.append(gobject.TYPE_BOOLEAN) else: types.append(gobject.TYPE_STRING) self.combod = dict() if len(stringd): types.extend([gobject.TYPE_INT] * len(stringd)) keys = stringd.keys() keys.sort() valid = set(r.dtype.names) for ikey, key in enumerate(keys): assert (key in valid) combostore = gtk.ListStore(gobject.TYPE_STRING) for s in stringd[key]: combostore.append([s]) self.combod[key] = combostore, len(self.headers) + ikey gtk.ListStore.__init__(self, *types) for row in r: vals = [] for formatter, val in zip(self.formats, row): if isinstance(formatter, mlab.FormatBool): vals.append(val) else: vals.append(formatter.tostr(val)) if len(stringd): # todo, get correct index here? vals.extend([0] * len(stringd)) self.append(vals)
def rec2csv_pretty(r, fname, delimiter=',', formatd=None, missing='', missingd=None, withheader=True, overwrite_float_precision=True): """ Save the data from numpy recarray *r* into a comma-/space-/tab-delimited file. The record array dtype names will be used for column headers. *fname*: can be a filename or a file handle. Support for gzipped files is automatic, if the filename ends in '.gz' *withheader*: if withheader is False, do not write the attribute names in the first row *overwrite_float_precision*: if True, write out floats as raw, else use the implied precision of formatd .. seealso:: :func:`csv2rec` For information about *missing* and *missingd*, which can be used to fill in masked values into your CSV file. """ if missingd is None: missingd = dict() def with_mask(func): def newfunc(val, mask, mval): if mask: return mval else: return func(val) return newfunc formatd = get_formatd(r, formatd) funcs = [] for i, name in enumerate(r.dtype.names): if overwrite_float_precision: funcs.append(with_mask(csvformat_factory(formatd[name]).tostr)) else: funcs.append(with_mask(formatd[name].tostr)) fh, opened = cbook.to_filehandle(fname, 'wb', return_opened=True) writer = csv.writer(fh, delimiter=delimiter) header = r.dtype.names if withheader: writer.writerow(header) # Our list of specials for missing values mvals = [] for name in header: mvals.append(missingd.get(name, missing)) ismasked = False if len(r): row = r[0] ismasked = hasattr(row, '_fieldmask') for row in r: if ismasked: row, rowmask = row.item(), row._fieldmask.item() else: rowmask = [False] * len(row) srow = [ func(val, mask, mval) for func, val, mask, mval in zip(funcs, row, rowmask, mvals) ] writer.writerow(srow) if opened: fh.close()