def t2t_table(table_dict, units=None, **kwargs): """ Create a t2t format table. this is required by t2t for tables see for example: http://txt2tags.org/markup.html Example: >>> d=OrderedDict() >>> d['name']=['bright','dim'] >>> d['flux']=['large','small'] >>> print t2t_table(d) || name | flux | | bright | large | | dim | small | >>> print t2t_table(d, units=dict(flux='[ergs]')) || name | flux [ergs] | | bright | large | | dim | small | """ if units is not None: for k,v in units.items(): table_dict[k + ' %s' % v] = table_dict.pop(k) outtable=StringIO() asciitable.write(table_dict, outtable, Writer=asciitable.FixedWidth, names=table_dict.keys(), **kwargs ) t=outtable.getvalue() t='||' + t[2:] return t.strip()
def latex_table(table_dict, units=None, latexdict=None, **kwargs): r""" Format a dictionary into a latex table. Use the DefaultDict if you care about the order of the table. >>> d=OrderedDict() >>> d['name']=['bright','dim'] >>> d['flux']=['large','small'] >>> print latex_table(d, units=dict(flux='[ergs]')) \begin{deluxetable}{cc} \tablehead{\colhead{name} & \colhead{flux}\\ \colhead{ } & \colhead{[ergs]}} \startdata bright & large \\ dim & small \\ \enddata \end{deluxetable} """ if latexdict is None: latexdict=dict() if units is not None: latexdict['units']=units outtable=StringIO() asciitable.write(table_dict, outtable, Writer=asciitable.AASTex, names=table_dict.keys(), latexdict=latexdict, **kwargs ) t=outtable.getvalue() return t.strip()
def write_ascii(self, filename, **kwargs): ''' Read a table from an ASCII file using asciitable Optional Keyword Arguments: Writer - Writer class (default= Basic) delimiter - column delimiter string write_comment - string defining a comment line in table quotechar - one-character string to quote fields containing special characters formats - dict of format specifiers or formatting functions names - list of names corresponding to each data column include_names - list of names to include in output (default=None selects all names) exclude_names - list of names to exlude from output (applied after include_names) See the asciitable documentation at http://cxc.harvard.edu/contrib/asciitable/ for more details. ''' _check_asciitable_installed() if 'overwrite' in kwargs: overwrite = kwargs.pop('overwrite') else: overwrite = False if type(filename) is str and os.path.exists(filename): if overwrite: os.remove(filename) else: raise Exception("File exists: %s" % filename) asciitable.write(self.data, filename, **kwargs)
def spec_save(data, outfile): # Import modules import numpy as np import asciitable import os # Make a file to write the data to open(outfile, 'a') # Delete outfile if it exists for i in range(1, len(outfile) + 1): if outfile[-i] == '/': outdir = outfile[:-i + 1] outname = outfile[-i + 1:] break else: continue for file in os.listdir(outdir): if file == outname: os.listdir(outdir).remove(outname) break else: continue # Rearrange so that each frame is column, instead of row datalist = [] names = [] for i in range(np.shape(data)[0]): names.append('Frame ' + repr(i + 1)) for j in range(np.shape(data)[1]): datalist.append(list(data[:, j])) # Write data with asciitable asciitable.write(datalist, outfile, names=names)
def latexMatrix(cfMx, rowlabels=None): ''' if you have the asciitable package installed, avail through mac ports and other distributions, then we can output latex format tables for our data. This is handy for generating latex output of a confusion matrix. ''' try: import asciitable import asciitable.latex except: print "Error importing asciitable...you may not have this package installed." return None #build data dictionary, per-column structure if rowlabels != None: data = {'col000':rowlabels} col_align = ['l'] else: data = {} col_align = [] numCols = cfMx.shape[1] for i in range(numCols): data['col%s'%(str(i+1).zfill(3))] = cfMx[:,i] col_align.append('c') col_align_str = "|%s|"%("|".join(col_align)) asciitable.write(data, sys.stdout, Writer=asciitable.Latex, col_align=col_align_str)
def test_write_noheader_no_delimiter(numpy): """Write a table as a fixed width table with no delimiter.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthNoHeader, bookend=False, delimiter=None) assert_equal_splitlines(out.getvalue(), """\ 1.2 "hello" 1 a 2.4 's worlds 2 2 """)
def test_write_noheader_no_bookend(numpy): """Write a table as a fixed width table with no bookend.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthNoHeader, bookend=False) assert_equal_splitlines(out.getvalue(), """\ 1.2 | "hello" | 1 | a 2.4 | 's worlds | 2 | 2 """)
def test_write_noheader_no_pad(numpy): """Write a table as a fixed width table with no padding.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthNoHeader, delimiter_pad=None) assert_equal_splitlines(out.getvalue(), """\ |1.2| "hello"|1|a| |2.4|'s worlds|2|2| """)
def test_write_noheader_normal(numpy): """Write a table as a normal fixed width table.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthNoHeader) assert_equal_splitlines(out.getvalue(), """\ | 1.2 | "hello" | 1 | a | | 2.4 | 's worlds | 2 | 2 | """)
def dd_writer(packet, fpart): if fcs.dd: dd_fname = "%s.%s.dat" % (fcs.dd_prefix, fpart) if fcs.dd_test: print "@FILENAME: " + dd_fname asciitable.write(packet, sys.stdout) else: print "DD: " + dd_fname asciitable.write(packet, dd_fname)
def write_success_table(self,filename): boolthing = np.ones_like(hdudf_h.mstar_list) i_fail = np.where(np.asarray(hdudf_h.image_files)=='')[0] print boolthing.shape, i_fail.shape print boolthing, i_fail boolthing[i_fail] = 0 data = np.asarray([boolthing,hdudf_h.x_array,hdudf_h.y_array]) asciitable.write(data,filename) return
def __parseKnownIssues(self, jobs): for job in jobs: if job.parsed: continue if job.result["status"] != "Completed" and job.result["status"] != "Aborted": genLogger.warn( "%s J:%s status %s, not Completed or Aborted, SKIP" % (job.type, job.result["id"], job.result["status"]) ) continue if job.result["result"] == "Pass": genLogger.debug("%s J:%s result %s, SKIP" % (job.type, job.result["id"], job.result["result"])) continue for rs in job.result["recipeSet"]: if rs.result["response"] == "nak": continue skip_left = "" for r in rs.result["recipe"]: if r.result["result"] == "Pass" and not r.result["guestrecipe"]: continue if skip_left: skip_left = "" continue for t in r.result["task"]: if t.result["result"] == "Pass": continue ctx = {"job": job, "rs": rs, "r": r, "gr": "", "t": t} ret = self.__parseTask(ctx) if ret == "SKIP_LEFT": skip_left = True break skip_left_gr = "" for gr in r.result["guestrecipe"]: if gr.result["result"] == "Pass": continue if skip_left_gr: skip_left_gr = "" continue for gt in gr.result["task"]: if gt.result["result"] == "Pass": continue ctx = {"job": job, "rs": rs, "r": r, "gr": gr, "t": gt} ret = self.__parseTask(ctx) if ret == "SKIP_LEFT": skip_left_gr = True break self.__updateJobState(jobs, "Parsed") self.jobState.write() asciitable.write( self.knownIssuesTable, self.knownIssuesResult, names=self.columns, Writer=asciitable.FixedWidth ) asciitable.write( self.unknownIssuesTable, self.unknownIssuesResult, names=self.columns, Writer=asciitable.FixedWidth )
def test_write_formats(numpy): """Write a table as a fixed width table with no delimiter.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidth, formats={'Col1': '%-8.3f', 'Col2': '%-15s'}) assert_equal_splitlines(out.getvalue(), """\ | Col1 | Col2 | Col3 | Col4 | | 1.200 | "hello" | 1 | a | | 2.400 | 's worlds | 2 | 2 | """)
def test_write_twoline_normal(numpy): """Write a table as a normal fixed width table.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthTwoLine) assert_equal_splitlines(out.getvalue(), """\ Col1 Col2 Col3 Col4 ---- --------- ---- ---- 1.2 "hello" 1 a 2.4 's worlds 2 2 """)
def test_write_twoline_no_bookend(numpy): """Write a table as a fixed width table with no bookend.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthTwoLine, bookend=True, delimiter='|') assert_equal_splitlines(out.getvalue(), """\ |Col1| Col2|Col3|Col4| |----|---------|----|----| | 1.2| "hello"| 1| a| | 2.4|'s worlds| 2| 2| """)
def __call__(self): with open(_IMPORT_YAML_PATH, 'r') as f: i_txs = self._load_parsed_txs(f) processed_output = defaultdict(list) unprocessed_output = defaultdict(list) for i, i_tx in enumerate(i_txs, start=1): if i_tx.processed: output = processed_output else: output = unprocessed_output output['id'].append(i) output['date'].append(str(i_tx.parsed_tx.date)) output['account'].append(str(i_tx.parsed_tx.account)) output['description'].append( i_tx.parsed_tx.description[:130].replace('\n', ' ')) output['amount'].append(float(i_tx.parsed_tx.amount)) output['category'].append(i_tx.category) output_io = StringIO() def format_amount(x): if x < 0: color = Fore.RED else: color = Fore.GREEN output = "{}{:.2f}{}".format(color, x, Fore.RESET) return output if processed_output: output_io.write("Transactions ready to commit:\n\n") asciitable.write(processed_output, output_io, Writer=asciitable.FixedWidthNoHeader, names=[ 'id', 'date', 'account', 'description', 'category', 'amount' ], formats={'amount': lambda x: format_amount(x)}) if unprocessed_output: output_io.write("\n") if unprocessed_output: output_io.write("Transactions ready for processing:\n\n") asciitable.write(unprocessed_output, output_io, Writer=asciitable.FixedWidthNoHeader, names=[ 'id', 'date', 'account', 'description', 'category', 'amount' ], formats={'amount': lambda x: format_amount(x)}) return output_io.getvalue()
def __call__(self): # Get the category if it already exists, or create a new one. with session_scope() as session: categories = session.query(Category) \ .order_by(Category.name) \ .all() output = defaultdict(list) for category in categories: # If the category doesn't have a budget set, skip it. if category.budget_items is None or category.budget_items == []: continue txs = category.transactions # Remove income transactions and transactions outside the date # range. (_, num_days) = calendar.monthrange(self.year, self.month) beg_date = datetime.date(self.year, self.month, 1) end_date = beg_date + datetime.timedelta(days=num_days) txs = filter(lambda x: x.is_debit(), txs) txs = filter(lambda x: x.is_in_period(beg_date, end_date), txs) # Get the budget item for this category budget_item = category.budget_items[-1] # Get the total spent for this category # Only include debit transactions, which have a negative amount spent = sum([abs(tx.amount) for tx in txs], 0) rem = budget_item.amount - spent # Calculate percentage of budget spent_pct = (spent / budget_item.amount) * 100.0 rem_pct = (rem / budget_item.amount) * 100.0 # Add data to output dict output['category'].append(category.name) output['budget'].append("{:.2f}".format(budget_item.amount)) output['spent'].append("{:.2f} ({:.0f}%)".format(spent, spent_pct)) output['remaining'].append("{:.2f} ({:.0f}%)".format(rem, rem_pct)) output['transactions'].append(len(txs)) if not output: return "No budget set" output_io = StringIO() asciitable.write(output, output_io, Writer=asciitable.FixedWidth, names=['category', 'budget', 'spent', 'remaining', 'transactions'],) return output_io.getvalue()
def report(self, format='ascii'): if format == 'ascii': if len(self.data.keys()) > 0: asciitable.write([ (id, float(ir['v'])) for (id, ir) in self.data.items() ], names=['Cell ID', 'IR [mΩ]'], formats={ 'Cell ID': '%s', 'IR [mΩ]': '%s'}, Writer=asciitable.FixedWidth) else: self.log.warning('no data') else: log.error('unknown report format', format=format)
def test_write_twoline_no_pad(numpy): """Write a table as a fixed width table with no padding.""" out = io.StringIO() asciitable.write(dat, out, Writer=asciitable.FixedWidthTwoLine, delimiter_pad=' ', position_char='=') assert_equal_splitlines(out.getvalue(), """\ Col1 Col2 Col3 Col4 ==== ========= ==== ==== 1.2 "hello" 1 a 2.4 's worlds 2 2 """)
def report(self, format='ascii'): if format != 'ascii': log.error('unknown report format', format=format) return if len(self.cells.items()) == 0: self.log.warning('no data') return asciitable.write([ ([ group for group in key ] + [self.cells[key]]) for key in sorted(self.cells.keys()) ], names=[ query.program_string for query in self.config.key_queries ] + ['Count'], Writer=asciitable.FixedWidth)
def __init__(self): self.autoRerun = "" self.parseKnownIssues = "" self.errataName = "" self.errataLname = "" self.rerunedRSId = [] self.force = False self.__parseArgs() self.errataInfo = ErrataInfo(self.errataName, self.errataLname, False) self.resultPath = "./result" self.jobStatePath = "%s/%s.%s" % (self.resultPath, self.errataInfo.errataId, "jobstate") genLogger.info("jobStatePath : %s", self.jobStatePath) self.jobState = ConfigObj(self.jobStatePath, encoding="utf8") if self.parseKnownIssues == "y": self.knownIssuesPath = [] self.knownIssues = [] self.knownIssuesRPath = "./known_issues" self.knownIssuesPath.append( "%s/%s.%s" % (self.knownIssuesRPath, self.errataInfo.rhel_version, "known_issues") ) self.knownIssuesPath.append( "%s/RHEL-%s.%s" % (self.knownIssuesRPath, self.errataInfo.major, "known_issues") ) for i in range(0, len(self.knownIssuesPath)): str = "%d : %s" % (i, self.knownIssuesPath[i]) genLogger.info("knownIssuesPath%s" % str) self.knownIssues.append(ConfigObj(self.knownIssuesPath[i], encoding="utf8")) self.knownIssuesResult = "%s/%s.%s" % (self.resultPath, self.errataInfo.errataId, "knownIssues") self.unknownIssuesResult = "%s/%s.%s" % (self.resultPath, self.errataInfo.errataId, "unknownIssues") self.tableTemple = { "Path": ["---"], "TaskName": ["---"], "TaskResult": ["---"], "TaskStatus": ["---"], "ResultPath": ["---"], "PathResult": ["---"], "Checked": ["---"], } self.columns = ["Path", "TaskName", "TaskResult", "TaskStatus", "ResultPath", "PathResult", "Checked"] if not os.path.exists(self.knownIssuesResult): asciitable.write( self.tableTemple, self.knownIssuesResult, names=self.columns, Writer=asciitable.FixedWidth ) if not os.path.exists(self.unknownIssuesResult): asciitable.write( self.tableTemple, self.unknownIssuesResult, names=self.columns, Writer=asciitable.FixedWidth ) reader = asciitable.get_reader(Reader=asciitable.FixedWidth) self.knownIssuesTable = reader.read(self.knownIssuesResult) self.unknownIssuesTable = reader.read(self.unknownIssuesResult)
def __call__(self): with open(_IMPORT_YAML_PATH, 'r') as f: i_txs = self._load_parsed_txs(f) processed_output = defaultdict(list) unprocessed_output = defaultdict(list) for i, i_tx in enumerate(i_txs, start=1): if i_tx.processed: output = processed_output else: output = unprocessed_output output['id'].append(i) output['date'].append(str(i_tx.parsed_tx.date)) output['account'].append(str(i_tx.parsed_tx.account)) output['description'].append( i_tx.parsed_tx.description[:130].replace('\n', ' ')) output['amount'].append(float(i_tx.parsed_tx.amount)) output['category'].append(i_tx.category) output_io = StringIO() def format_amount(x): if x < 0: color = Fore.RED else: color = Fore.GREEN output = "{}{:.2f}{}".format(color, x, Fore.RESET) return output if processed_output: output_io.write("Transactions ready to commit:\n\n") asciitable.write( processed_output, output_io, Writer=asciitable.FixedWidthNoHeader, names=['id', 'date', 'account', 'description', 'category', 'amount'], formats={'amount': lambda x: format_amount(x)}) if unprocessed_output: output_io.write("\n") if unprocessed_output: output_io.write("Transactions ready for processing:\n\n") asciitable.write( unprocessed_output, output_io, Writer=asciitable.FixedWidthNoHeader, names=['id', 'date', 'account', 'description', 'category', 'amount'], formats={'amount': lambda x: format_amount(x)}) return output_io.getvalue()
def get_t2t_table(table, **kwargs): outtable=StringIO() asciitable.write(table, outtable, Writer=asciitable.FixedWidth, names=table.keys(), **kwargs ) t=outtable.getvalue() # this is required by t2t for tables # see for example: http://txt2tags.org/markup.html t='||' + t[2:] return t
def get_t2t_table(table, **kwargs): outtable = StringIO() asciitable.write(table, outtable, Writer=asciitable.FixedWidth, names=table.keys(), **kwargs) t = outtable.getvalue() # this is required by t2t for tables # see for example: http://txt2tags.org/markup.html t = '||' + t[2:] return t
def write_vals(self, filename): """Write dvals and mvals for each model component (as applicable) to an ascii table file. Some component have neither (couplings), some have just dvals (TelemData), others have both (Node, AcisDpaPower). Everything is guaranteed to be time synced, so write a single time column. """ colvals = OrderedDict(time=self.times) for comp in self.comps: if hasattr(comp, 'dvals'): colvals[comp.name + '_data'] = comp.dvals if hasattr(comp, 'mvals') and comp.predict: colvals[comp.name + '_model'] = comp.mvals asciitable.write(colvals, filename, names=colvals.keys())
def fixed_width_table(table_dict, table_kwargs=dict(bookend=False, delimiter=None), indent=None): outtable=StringIO() asciitable.write(table_dict, outtable, Writer=asciitable.FixedWidth, names=table_dict.keys(), **table_kwargs) t=outtable.getvalue() # remove final newline assert t[-1] == '\n' t=t[:-1] if indent is None: return t t=t.split('\n') return '\n'.join(['%s%s' % (indent,i) for i in t])
def rms_dict(values, filename="rms.dat"): """Iterates through the values dictionary in pairs calculating RMS""" def rms_pair(a,b): return numpy.mean(numpy.sqrt((a["y"]-b["y"])**2)) columns=["name"] formats=dict(name=lambda x: x) rows=[] for key2 in values.keys(): columns.append(key2) formats[key2]="%4.1F" for key1 in values.keys(): r=[key1] for key2 in values.keys(): r.append(rms_pair(values[key1], values[key2])) rows.append(r) asciitable.write(rows, names=columns, formats=formats, delimiter=",")
def report(self, format='ascii'): if format != 'ascii': log.error('unknown report format', format=format) return if len(self.cells.items()) == 0: self.log.warning('no data') return if len(self.config.infoset_queries) > 0: asciitable.write([ [id] + [ str(result) for result in self.cells[id] ] for id in sorted(self.cells.keys(), key=lambda key: self.sort_results[key]) ], # noqa names=['.id'] + [ query.program_string for query in self.config.infoset_queries ], formats={ f'{sort_query.program_string}': '%s' for sort_query in self.sort_queries }, Writer=asciitable.FixedWidth) else: for (id, item) in self.cells.items(): print(f"=== Infoset for {id}") print(item[0])
def fits2ascii(fitsfile, outpath=None, columns=['all'], verbose=True): """ Convert fits file into ascii (see ascii2fits for the reverse command) --- INPUT --- EXAMPLE OF USE --- NB! not tested as of 160118... download asciitable """ #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Loading fits file ' + fitsfile) datfits = afits.open(fitsfile) fitstab = datfits[1].data fitscol = fitstab.columns pdb.set_trace() #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Will write the following columns to the ascii file:') if 'all' in columns: keys = fitscol.names if verbose: print(' all ("all" was found in list of columns)') else: keys = columns if verbose: print(' ' + ','.join(keys)) #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Initializing and fillling dictionary with data') asciidata = {} for kk in keys: asciidata[kk] = [] asciidata[kk][:] = fitstab[kk][:] #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Write dictionary to ascii file:') head = fitsfile.split('.fit')[0] asciiname = head + '.ascii' if outpath != None: asciibase = outpath + asciiname.split('/')[-1] asciitable.write(asciidata, asciiname, Writer=asciitable.CommentedHeader, names=keys) #------------------------------------------------------------------------------------------------------------- if verbose: print(' - Wrote data to: ' + asciiname)
def save_multibench_results(multibench_results, samples_per_sample_size, save_path): formatting_number_precision = 3 columns = [ "Number of Samples", "Run time", "Memory", "Disk read", "Disk write", "List of Samples" ] def number_formatter(num): return round(num, formatting_number_precision) extracting_keys = multibench_results[0].keys() if os.path.exists(save_path): os.remove(save_path) for extracting_key in extracting_keys: data_lists = [] for ind, multibench_result in enumerate(multibench_results): samples = samples_per_sample_size[ind] multibench_result_target = multibench_result[extracting_key] row_list = [ len(samples), number_formatter(multibench_result_target["runtime"]), number_formatter(multibench_result_target["memory"]), number_formatter(multibench_result_target["disk_read"]), number_formatter(multibench_result_target["disk_write"]), ", ".join(samples) ] data_lists.append(row_list) with open(save_path, "a") as fstream: fstream.write('->%s\n' % extracting_key) asciitable.write(data_lists, fstream, names=columns, Writer=asciitable.FixedWidthTwoLine, bookend=True, delimiter="|", quotechar="'")
def process_stat(args): client = pysvn.Client() t1 = time.time() status = client.status(args.path) t2 = time.time() asciitable.write( get_status(status, args.path), sys.stdout, names=("status", "file", "modified"), Writer=asciitable.FixedWidthTwoLine, bookend=False, formats={ "modified": format_timestamp, "status": str }) print now = time.time() print "[svn st in %.2f sec, total %.2f]" % (t2 - t1, now - t1) print
def fits2ascii(fitsfile,outpath=None,columns=['all'],verbose=True): """ Convert fits file into ascii (see ascii2fits for the reverse command) --- INPUT --- EXAMPLE OF USE --- NB! not tested as of 160118... download asciitable """ #------------------------------------------------------------------------------------------------------------- if verbose: print ' - Loading fits file '+fitsfile datfits = pyfits.open(fitsfile) fitstab = datfits[1].data fitscol = fitstab.columns pdb.set_trace() #------------------------------------------------------------------------------------------------------------- if verbose: print ' - Will write the following columns to the ascii file:' if 'all' in columns: keys = fitscol.names if verbose: print ' all ("all" was found in list of columns)' else: keys = columns if verbose: print ' '+','.join(keys) #------------------------------------------------------------------------------------------------------------- if verbose: print ' - Initializing and fillling dictionary with data' asciidata = {} for kk in keys: asciidata[kk] = [] asciidata[kk][:] = fitstab[kk][:] #------------------------------------------------------------------------------------------------------------- if verbose: print ' - Write dictionary to ascii file:' head = fitsfile.split('.fit')[0] asciiname = head+'.ascii' if outpath != None: asciibase = outpath+asciiname.split('/')[-1] asciitable.write(asciidata, asciiname, Writer=asciitable.CommentedHeader, names=keys) #------------------------------------------------------------------------------------------------------------- if verbose: print ' - Wrote data to: ',asciiname
def fit_viking_data(input_file, vl1years="2,3", vl2years="2", nmodes=5): """Translate viking data from name year ls d h m s p(mb) VL1 1 97.073 0 18 0 49 7.534 to the same format as the model data ls, vl1, vl2 """ data = asciitable.read(input_file) data.dtype.names=["name","year","L_S","day","hour","minute","second","pressure"] #scale to Pascal pressure =data["pressure"] *100. lander_name = data["name"] year = data["year"] L_S = data["L_S"] #vl1 vl1_list_years = [int(y) for y in vl1years.split(",")] selection_year = [False]*len(year) for y in vl1_list_years: selection_year = selection_year | (year==y) selection = (lander_name=="VL1") & selection_year d_data = dict(L_S=L_S[selection],vl1=pressure[selection]) fit= fit_data(d_data, nmodes) #vl2 vl2_list_years = [int(y) for y in vl2years.split(",")] selection_year = [False]*len(year) for y in vl2_list_years: selection_year = selection_year | (year==y) selection = (lander_name=="VL2") & selection_year d_data2 = dict(L_S=L_S[selection],vl2=pressure[selection]) fit2= fit_data(d_data2, nmodes) fit.update(fit2) # d_data["vl2"] = d_data2["vl2"] # d_data["vl2_L_S"] = d_data2["L_S"] asciitable.write(d_data2, "vl2.data",delimiter=",") asciitable.write(d_data, "vl1.data",delimiter=",") return fit
def save(data, names, outfile): # Import modules import numpy as np import asciitable import os # Make a file to write the data to open(outfile, 'a') # Create dictionary of 'name':data data_dict = {} if len(names) == 1: data_dict[names[0]] = data if len(names) >= 2: for i in range(len(names)): if len(np.shape(data)) > 1: data_dict[names[i]] = data[i, :] if len(np.shape(data)) == 1: data_dict[names[i]] = [data[i]] # Write data with asciitable asciitable.write(data_dict, outfile, names=names)
def slot(config): sess = megacell_api_session(config.mcc_baseurl) if config.all_slots: config.slots = Slots if config.new_cells: cells_info = sess.get_cells_info() config.slots = [ slot for slot in cells_info.keys() if cells_info[slot].fetch('status_text') == StatusStrings.NEW_CELL_INSERTED ] log.info('selected slots', slots=config.slots) if config.action: # Start an action on slots sess.multiple_slots_action(config.slots, ActionCodes[config.action]) if config.info: # Print cells info cells_info = sess.get_cells_info() if len(config.infoset_queries) > 0: results = dict() for slot in config.slots: results[slot] = list() json_text = cells_info[slot].to_json() for query in config.infoset_queries: query_result = query.input(text=json_text).text() results[slot].append( query_result ) log.debug('jq query result', slot=slot, result=query_result, query=query) asciitable.write([ [slot] + [ result for result in results[slot] ] for slot in config.slots ], names=['Slot'] + [ query.program_string for query in config.infoset_queries ], formats={ 'Slot': '%s' }, Writer=asciitable.FixedWidth) else: print(json.dumps( { slot.name: cells_info[slot].fetch('.') for slot in config.slots } ))
def __call__(self): # Get all the transactions with session_scope() as session: txs = session.query(Transaction) \ .filter(Transaction.account.has( name=self.account_name)) \ .order_by(Transaction.date) \ .all() output = defaultdict(list) for tx in txs: output['id'].append(tx.id) output['date'].append(str(tx.date)) output['description'].append( tx.description[:130].replace('\n', ' ')) output['amount'].append(tx.amount) output['reconciled'].append(tx.reconciled) if tx.category: output['category'].append(tx.category.name) else: output['category'].append('') def format_amount(x): if x < 0: color = Fore.RED else: color = Fore.GREEN output = "{}{:.2f}{}".format(color, x, Fore.RESET) return output output_io = StringIO() asciitable.write(output, output_io, Writer=asciitable.FixedWidthNoHeader, names=['id', 'date', 'description', 'category', 'reconciled', 'amount'], formats={'amount': lambda x: format_amount(x), 'reconciled': lambda x: 'Y' if x else 'N'}) return output_io.getvalue()
def report(self): if len(self.cells.items()) > 0: for (id, rows) in self.cells.items(): print(f"=== Log for {id}") if len(rows) > 0: asciitable.write(rows, names=[ 'Timestamp', 'Type', 'Event', 'Equipment', 'Data' ], formats={ 'Timestamp': '%s', 'Type': '%s', 'Event': '%s', 'Equipment': '%s', 'Results': '%s' }, Writer=asciitable.FixedWidth) else: print("LOG EMPTY") else: self.log.warning('no data')
def confluence_table(table_dict, units=None, **kwargs): """ Format a dictionary into a confluence table. Use the DefaultDict if you care about the order of the table. Example: >>> d=OrderedDict() >>> d['name']=['bright','dim'] >>> d['flux']=['large','small'] >>> print confluence_table(d) || name || flux || || bright | large | || dim | small | >>> print confluence_table(d, units=dict(flux='[ergs]')) || name || flux [ergs] || || bright | large | || dim | small | """ if units is not None: for k,v in units.items(): table_dict[k + ' %s' % v] = table_dict.pop(k) outtable=StringIO() asciitable.write(table_dict, outtable, Writer=asciitable.FixedWidth, names=table_dict.keys(), **kwargs) t=outtable.getvalue() t=t.replace(' |',' |') t=t.strip().split('\n') t[0]=t[0].replace(' |','||') t=['|'+i for i in t] return '\n'.join(t)
def run_chain(): sequences = [] global a_old, b_old, sigma for j in range(1000): #take jump accept = False a_jump = np.random.normal(scale=0.03) b_jump = np.random.normal(scale=0.05) a_new = a_old + a_jump b_new = b_old + b_jump ratio = r(a_new,b_new,a_old,b_old,sigma) if ratio >= 1.0: a_old = a_new b_old = b_new accept = True else: u = np.random.uniform() if ratio >= u: a_old = a_new b_old = b_new accept = True sequences.append([j,ratio,accept,a_old,b_old]) asciitable.write(sequences,"runa.dat",names=["j","ratio","accept","a","b"])
def make_filetypes_dat(contents): filetypes = asciitable.read(msid_files['filetypes'].abs) test_filetypes = [x for x in filetypes if x['content'].lower() in contents] asciitable.write(test_filetypes, os.path.join(opt.data_root, 'filetypes.dat'), names=filetypes.dtype.names)
Mission = str(f[1].header['TELESCOP']) ObsID = str(f[0].header['OBS_ID']) DateObs = str(f[0].header['DATE-OBS']) MJD = str(f[0].header['MJD_OBS']) Observer = str(f[1].header['OBSERVER']) return Mission, Inst, ObsID, Observer, DateObs, MJD, ExpTime prst = [] for i in range(7): lst = [] for FileName in FileNames: lst.append(list_file(FileName)[i]) prst.append(lst) data = { 'Inst': prst[1], 'ObsID': prst[2], 'DateObs': prst[4], 'MJD': prst[5], 'ExpTime': prst[6] } asciitable.write(data, sys.stdout, Writer=asciitable.Latex, latexdict={ 'preamble': r'\begin{center}', 'tablefoot': r'\end{center}', 'tabletype': 'table*' })
def check_write_table(test_def, table): out = io.StringIO() asciitable.write(table, out, **test_def["kwargs"]) print("Expected:\n%s" % test_def["out"]) print("Actual:\n%s" % out.getvalue()) assert out.getvalue().splitlines() == test_def["out"].splitlines()
import asciitable,random gz2users = asciitable.read('/Users/willettk/Desktop/treemap/gz2_users.csv') ss5000 = random.sample(gz2users,5000) asciitable.write(ss5000,'/Users/willettk/Desktop/ss5000.csv')
print a, b, ww[w] sq = quad(qhansen, 0.01, 10, args=(a, b, ww[w])) sp = quad(phansen, 0.01, 10, args=(a, b)) qnorm.append(sq[0] / sp[0]) # plt.plot(ww, qnorm, 'g') c = col[u] s = sty[v] plt.plot(ww, qnorm, color=c, ls=s, label='a=%s [$\mu m$], b=%s' % (a, b)) plt.legend(bbox_to_anchor=(1.05, 1), loc=1, borderaxespad=0.) leg = plt.legend(fancybox=True, loc=1, prop={'size': 7}) leg.get_frame().set_alpha(0.5) #plt.xlim(1, 12) #plt.ylim(1, 4) #plt.title('extinction at long wavelengths') #plt.title('Model Grid') plt.xlabel('wavelength [$\mu m$]') plt.ylabel('forsterite extinction coefficient') plt.savefig('Plots/Qex_long_%s.pdf' % (timestr)) #plt.savefig('Plots/Qex_small.pdf') plt.clf() quit() obj2 = {'a': aaa, 'b': bbb, 'wave': www, 'Qex_averaged': qnorm} #cPickle.dump(obj2, open('../../Documents/Kaystuff/pickles/hansenmieff.pkl', 'wb')) #cPickle.dump(obj2, open('pickles/hansenmieff.pkl', 'wb')) asciitable.write(obj2, 'Files/hansensmall.txt')
aaa.append(a) bbb.append(b) # wwww.append(ww[w]) # www.append(ww[w]) print a, b, ww[w] sq = quad(qhansen, 0.01, 10, args = (a,b,ww[w])) sp = quad(phansen, 0.01, 10, args = (a,b)) qnorm.append(sq[0]/sp[0]) # plt.plot(ww, qnorm, 'g') c = col[u] s = sty[v] plt.plot(ww, qnorm, color = c, ls = s, label = 'a=%s [$\mu m$], b=%s'%(a,b)) plt.legend(bbox_to_anchor=(1.05, 1), loc=1, borderaxespad=0.) leg = plt.legend(fancybox=True, loc=1, prop={'size':7}) leg.get_frame().set_alpha(0.5) #plt.xlim(1, 12) #plt.ylim(1, 4) #plt.title('extinction at long wavelengths') #plt.title('Model Grid') plt.xlabel('wavelength [$\mu m$]') plt.ylabel('forsterite extinction coefficient') plt.savefig('Plots/Qex_long_%s.pdf'%(timestr)) #plt.savefig('Plots/Qex_small.pdf') plt.clf() quit() obj2 = {'a':aaa, 'b':bbb, 'wave':www, 'Qex_averaged': qnorm} #cPickle.dump(obj2, open('../../Documents/Kaystuff/pickles/hansenmieff.pkl', 'wb')) #cPickle.dump(obj2, open('pickles/hansenmieff.pkl', 'wb')) asciitable.write(obj2, 'Files/hansensmall.txt')
asciitable.write(d_data2, "vl2.data",delimiter=",") asciitable.write(d_data, "vl1.data",delimiter=",") return fit if __name__=="__main__": parser = argparse.ArgumentParser() parser.add_argument("input_filename", type=str) parser.add_argument("output_filename", type=str) parser.add_argument("--vl1years", type=str, default="2,3") parser.add_argument("--vl2years", type=str, default="3") # parser.add_argument("--startrow", type=int, default=0) # parser.add_argument("--stoprow", type=int, default=None) parser.add_argument("--delimiter", type=str, default=',') parser.add_argument("--nmodes", type=int, default=5) args = parser.parse_args() fit = fit_viking_data(args.input_filename, nmodes=args.nmodes, vl1years = args.vl1years, vl2years = args.vl2years ) output = dict(mode=range(len(fit["p1"])), p1=fit["p1"], p2=fit["p2"]) target = open(args.output_filename, 'w') target.write("#Fit to VL data from {0} with {1} harmonic modes\n".format(args.input_filename, args.nmodes)) asciitable.write(output,target, delimiter=args.delimiter) target.close()
symb = 'go' dJK.append(J[l] - K[l] - JKavg) a_emc.append(a_mcmc[0]) a_plus.append(a_mcmc[1]) a_minus.append(a_mcmc[2]) n_emc.append(n_mcmc[0]) n_plus.append(n_mcmc[1]) n_minus.append(n_mcmc[2]) lgname_conf.append(red) print red lgname0.append(red) shape.append(symb) # Write delta(J-K),a,N in a file for future use data = {'filename': lgname0, 'd(J-K)': dJK0, 'a': a_emc0, 'N': n_emc0} asciitable.write(data, 'Files/emceeresults_lg.txt') # plota.errorbar(dJK[l], a_emc[l], yerr = (a_plus[l], a_minus[l]), fmt = 'go', alpha = 0.8) # Write confident delta(J-K),a,N in a file for future use dataa = {'filename': lgname_conf, 'd(J-K)': dJK, 'a': a_emc, 'N': n_emc} asciitable.write(dataa, 'Files/emceeresults_lg_conf.txt') #quit() #quit() print len(lgname0) #plt.show() #quit() stypeo = [] colo = [] dcol = []
import pyfits import os, sys import numpy as np import asciitable import asciitable.latex from cudakde import * def FoldInput(infile): inf = open(infile) lines = inf.readlines() #print lines pars = [] for line in lines: #print line.split()[0] pp = read_data(line.split()[0]) pars.append(pp) prst = [] for j in range(8): lst = [] for i in range(len(lines)): lst.append(r'$%1.2f^{+%1.2f}_{-%1.2f}$'%(pars[i][1,j],pars[i][2,j]-pars[i][1,j],pars[i][1,j]-pars[i][0,j])) prst.append(lst) return prst prst = FoldInput(sys.argv[1]) models = ['bb','nsa12','nsa13','ns1260','ns123100','ns123190','ns130100','ns130190'] data = {r'A $Mod.$': models, r'B Bol. lum.': prst[0], r'B Bol. flux': prst[1], r'C $Psr. flux$': prst[2], r'D PWN flux': prst[3], r'E Psr. Lum.': prst[4], r'F PWN Lum': prst[5], r'G Psr. eff.': prst[6], r'H PWN eff': prst[7]} asciitable.write(data, sys.stdout, Writer = asciitable.Latex, latexdict = {'preamble': r'\begin{center}', 'tablefoot': r'\end{center}', 'tabletype': 'table*', 'units':{'$N_{\rm H}$':'$\rm 10^{21} ./ cm^{-2}$'}})
def compare(lineid, specid, column='flux', posid="positions_mosaic"): fieldpairs = mosaic.find_overlaps(posid=posid) fitsfilename = "%s_mosaic_%s.fits" % (lineid, specid) table = mosaic.read_fits_table(fitsfilename) # initialise a table to save the results outtable = dict(field1=list(), field2=list(), s_mean=list(), s_std=list(), N=list(), rat_med=list(), rat_q25=list(), rat_q75=list()) for fieldpair, indices in fieldpairs.items(): field, otherfield = fieldpair values = table[column][[i-1 for i in indices.keys()]] otherindices = list() seps = list() for neighbours in indices.values(): # first attempt - just use the nearest neighbour sep, otherindex = neighbours[0] otherindices.append(otherindex) seps.append(sep) othervalues = table[column][[i-1 for i in otherindices]] seps = np.array(seps) # plot the data try: datamax = 1.1*max(values.max(), othervalues.max()) except ValueError: # something wrong with this pair: skip it continue # The color of the points represents the separations plt.scatter(x=values, y=othervalues, c=seps, marker="o", vmin=0.0, vmax=2.68, alpha=0.6) plt.axis([0.0, datamax, 0.0, datamax]) cb = plt.colorbar() cb.set_label("aperture\nseparation") # plt.axis('scaled') plt.xlabel(field) plt.ylabel(otherfield) # plot line y =x x = np.linspace(0.0, datamax) plt.plot(x, x, 'r--') # Median gradient medgrad = np.median(othervalues/values) quart25 = scipy.stats.scoreatpercentile(othervalues/values, 25) quart75 = scipy.stats.scoreatpercentile(othervalues/values, 75) dyplus = quart75 - medgrad dyminus = medgrad - quart25 y = medgrad*x plt.plot(x, y, 'g') # Add info to title plt.title("%s %s %s\n N = %i, median(%s/%s) = %.2f + %.2f - %.2f\n sep = %.2f +/- %.2f" % (lineid, specid, column, len(values), otherfield, field, medgrad, dyplus, dyminus, seps.mean(), seps.std()), fontsize="small") plt.savefig("%s-%s-compare-%s-%s-%s.png" % (lineid, specid, column, field, otherfield)) plt.clf() # save the data to the output table outtable["field1"].append(field) outtable["field2"].append(otherfield) outtable["s_mean"].append(seps.mean()) outtable["s_std"].append(seps.std()) outtable["N"].append(len(values)) outtable["rat_med"].append(medgrad) outtable["rat_q25"].append(quart25) outtable["rat_q75"].append(quart75) # Write output table to file fmt = "%.3f" fmts = dict(s_mean=fmt, s_std=fmt, rat_med=fmt, rat_q25=fmt, rat_q75=fmt) asciitable.write(outtable, "%s-%s-compare-%s.dat" % (lineid, specid, column), delimiter="\t", formats=fmts)
else: keys = args.columns #------------------------------------------------------------------------------------------------------------- # Initialize and fill dictionary with data asciidata = {} for kk in keys: asciidata[kk] = [] asciidata[kk][:] = fitstab[kk][:] #------------------------------------------------------------------------------------------------------------- # write dictionary to ascii file head = re.compile('\.fi', re.IGNORECASE).split( args.fitsfile)[0] # making sure case is ignored asciiname = head + '.ascii' #commentstr = '# File created on ',str(datetime.datetime.now()),' with fits2ascii.py from ',args.fitsfile asciitable.write(asciidata, asciiname, Writer=asciitable.CommentedHeader, names=keys) #------------------------------------------------------------------------------------------------------------- if args.verbose: print 'Wrote the columns: ', keys print 'From fits file : ', args.fitsfile print 'to the ascii file: ', asciiname else: #------------------------------------------------------------------------------------------------------------- # ASCII 2 FITS #------------------------------------------------------------------------------------------------------------- # reading ascii file hdr = open(args.fitsfile).readlines()[0] hdrkeys = hdr.split()[1:] data = np.genfromtxt(args.fitsfile, comments='#') #-------------------------------------------------------------------------------------------------------------
def pow_ave(filedir, dx, units, **kwargs): # Import numpy and asciitable import asciitable import numpy as np import os # Keywords zvals = kwargs.get('zvals', 'default') # Get filenames from filedir filenames = os.listdir(filedir) filenames.sort() avpow = [] after_shot = False for filename in filenames: if filename == 'ave.txt': os.remove(filedir + '/' + filename) continue if filename[-4:] != '.txt': continue datafile = open(filedir + '/' + filename, 'r') if zvals == 'default': z = filename[:3] if zvals != 'default': z = 1 gnarpow = [] for line in datafile: line = line.strip() columns = line.split() gnarpow.append(float(columns[2])) if filename[-5:] == 'a.txt': after_shot = True after = np.mean(gnarpow) if filename[-5:] != 'a.txt': avpow.append(np.mean(gnarpow)) datafile.close() pows = np.array(avpow) # Make position array pos = np.zeros(np.shape(pows), dtype=float) if units == 'standard': conv = 25.4 if units == 'mm': conv = 1 if units == 'micron': conv = 1E-3 for i in range(1, len(pos)): pos[i] = pos[i - 1] + (dx * conv) # Make file to write data to writefile = filedir + '/ave.txt' newfile = open(writefile, 'a') # Convert to numpy array and write to ascii asciitable.write({ 'Position': pos, 'Average Power': pows }, newfile, names=['Position', 'Average Power']) newfile.close() if after_shot == False: return pos, pows, z if after_shot == True: return pos, pows, z, after
# along with this program. If not, see <http://www.gnu.org/licenses/>. import asciitable, sqlite3, datetime # # Parse command line options # from optparse import OptionParser parser = OptionParser() parser.add_option('-d', '--db', dest='db_filename', help='Use DB as the source sqlite database', metavar='DB') (options, args) = parser.parse_args() db = sqlite3.connect(options.db_filename) cur = db.cursor() cur.execute("select strftime('%s', 'now') - strftime('%s', ts) as delta,disc_80211_networks,disc_cells,global_rank from wigle_net order by ts desc limit 1") delta, disc_80211_networks, disc_cells, global_rank = cur.fetchone() delta = datetime.timedelta(seconds=delta) asciitable.write({ 'UPD': [ str(delta) ], 'Disc. Nets w/ GPS': [ str(disc_80211_networks) ], 'Disc. cells w/ GPS': [ str(disc_cells) ], 'Rank': [ str(global_rank) ], }, names = ['UPD', 'Disc. Nets w/ GPS', 'Disc. cells w/ GPS', 'Rank'], Writer=asciitable.FixedWidth)
tmp = dict(link_small=pattern_s, link_big=pattern_b, link=link, idISS=idISS ) photos.append(tmp) return photos,pattern_s_L,pattern_b_L,link_L,idiss photos,link_small,link_big,link,idiss=get_iss_photos(lista,mission) photos=np.array(photos) photos=list(photos.astype(str)) f = open('tasks_darkskies.csv', 'w') f.write("\n".join(photos)) f.close() for h in list(np.array(range(len(idiss)/100+1))+1): idiss_j=np.array(idiss[(h-1)*100:h*100]) link_j=np.array(link[(h-1)*100:h*100]) link_small_j=np.array(link_small[(h-1)*100:h*100]) link_big_j=np.array(link_big[(h-1)*100:h*100]) print "Creating" asciitable.write({'idiss': idiss_j, 'link': link_j,'link_small':link_small_j,'link_big':link_big_j}, 'test2.csv', names=['idiss','link','link_small','link_big'],delimiter=',') print "Uploading" os.system('pbs add_tasks --tasks-file test2.csv --tasks-type csv --redundancy 5') print (h-1)*100 print h*100 print "Waiting" time.sleep(900)
def lv_ave(date, **kwargs): # Define keyword arguments df = kwargs.get('darkframe', False) s = kwargs.get('save', True) rep = kwargs.get('repeats', []) ratio = kwargs.get('ratio', 1) f1 = kwargs.get('f1_ratio', False) # Import Modules import numpy as np import matplotlib.pyplot as plt import os from decimal import Decimal # Make a directory to store plots and averages in create_dir('/home/chris/anaconda2/plots/' + str(date) + '/lv') # Extract all the filenames in the folder .../date/lv filenames = os.listdir('/home/chris/anaconda2/data/' + str(date) + '/lv') filenames.sort() # Add the full path onto the front filepaths = [] for name in filenames: if name == 'ave_pows.txt': filenames.remove(name) continue if name[-3:] == 'txt': filepaths.append('/home/chris/anaconda2/data/' + str(date) + '/lv/' + name) # Get lv number from file name lv_nums = [] for path in filepaths: j = 1 # j is the incrementor for characters in the run name/number for i in range(1, len(path) + 1): lv = '' if path[-i] == '/': # Steps backwards in path until it finds a '/' while path[-i + j] != '_': lv += path[ -i + j] # Adds on characters after the '/' until it finds a '_' j += 1 break else: continue lv_nums.append(lv) lv_nums = np.array(lv_nums) # Insert new number for repeat files into lv_nums for i in rep: lv_nums = np.insert(lv_nums, np.where(lv_nums == str(i))[0] + 1, int(i * 10 + 1)) # Import data from file(s) av_pow = np.zeros(len(filepaths) + len(rep)) f1ratio = [] for i in filepaths: datafile = open(i, 'r') frame = [] power = [] n = 1 for line in datafile: line = line.strip() columns = line.split(';') frame.append(int(columns[0])) power.append(1000 * ratio * float(columns[1])) # 1000 converts to mW if lv_nums[filepaths.index(i)] in rep: n = 2 for j in range(n): power_part = power[j * (len(power) / n):(j + 1) * (len(power) / n)] if df == True: av_pow[filepaths.index(i) + j] = np.mean(power_part[1:]) if df == False: av_pow[filepaths.index(i) + j] = np.mean(power_part) # Plot the power for each frame plt.figure('lv') plt.clf() plt.plot(frame, power_part, 'bo', label='Measured Power') plt.xlabel('Frame') plt.ylabel('Measured Power (mW)') plt.title( str(date) + ': lv ' + str(lv_nums[filepaths.index(i) + j])) avestr = '%.2E' % Decimal(av_pow[filepaths.index(i) + j]) h_line(av_pow[filepaths.index(i) + j], label='Average: ' + avestr + 'mW') plt.axis([0, frame[-1] + 1, 0, 1.1 * np.amax(power_part)]) plt.legend(loc=4) plt.savefig('/Users/christopherchambers/Py/plots/' + str(date) + '/lv/lv' + str(lv_nums[filepaths.index(i) + j]) + '.png') plt.draw() if f1 == True: f1ratio.append(np.mean(power[1:]) / power[0]) if s == True: # Make a file to write to open( '/Users/christopherchambers/Py/plots/' + str(date) + '/lv/ave_pows.txt', 'w') import asciitable # Make into a structured numpy array if ratio == 1: p_type = 'Ave Power (ref)' else: p_type = 'Ave Power (trans)' data = np.zeros(len(av_pow), dtype=[('lv', 'S4'), (p_type, 'float64')]) data[:] = zip(lv_nums, av_pow) asciitable.write( data, '/Users/christopherchambers/Py/plots/' + str(date) + '/lv/ave_pows.txt') if f1 == True: return lv_nums, av_pow, f1ratio else: return lv_nums, av_pow
def check_write_table(test_def, table): out = io.StringIO() asciitable.write(table, out, **test_def['kwargs']) print('Expected:\n%s' % test_def['out']) print('Actual:\n%s' % out.getvalue()) assert(out.getvalue().splitlines() == test_def['out'].splitlines())
for x in range(len(bdnyc.targets)): spt = bdnyc.targets[x].sptype if len(spt) >= 3: if (spt[-3] in ('p',':')): continue if not spt[-2]==':': if not spt[-1] in ('g','b',':','d'): inst = bdnyc.targets[x].nir['low'].keys() if len(inst) > 0: for y in range(len(inst)): date = bdnyc.targets[x].nir['low'][inst[y]].keys() if len(date) > 0: for z in range(len(date)): filter = bdnyc.targets[x].nir['low'][inst[y]][date[z]].keys() if len(filter) > 0: for t in range(len(filter)): wl = bdnyc.targets[x].nir['low'][inst[y]][date[z]][filter[t]]['wl'] flux = bdnyc.targets[x].nir['low'][inst[y]][date[z]][filter[t]]['flux'] data = bdnyc.targets[x].nir['low'][inst[y]][date[z]][filter[t]].keys() if wl[0] < 0.965 and wl[-1] > 2.120: specData.append([[wl],[flux]]) targetinfo.append(bdnyc.targets[x]) UNUM.append(bdnyc.targets[x].unum) INST.append(inst[y]) TYPE.append('nir') RES.append('low') DATE.append(date[z]) FILTER.append(filter[t]) asciitable.write({'unum':UNUM,'type':TYPE,'res':RES,'inst':INST,'date':DATE,'filter':FILTER},'fieldtable.dat') return [specData,targetinfo]
parser = OptionParser() parser.add_option('-d', '--db', dest='db_filename', help='Use DB as the source sqlite database', metavar='DB') (options, args) = parser.parse_args() db = sqlite3.connect(options.db_filename) cur = db.cursor() cur.execute( "select strftime('%s', 'now') - strftime('%s', ts) as delta,imsi,aero2_dataplans.name,expiration_ts,data_used,data_available from aero2_data join aero2_dataplans where aero2_dataplans.id = aero2_data.dataplan_id order by ts desc limit 1" ) delta, imsi, dataplan_name, expiration_ts, data_used, data_available = cur.fetchone( ) delta = datetime.timedelta(seconds=delta) asciitable.write( { 'UPD': [str(delta)], 'IMSI': [imsi], 'Dataplan': [dataplan_name], 'Expiration date': [str(expiration_ts)], 'Data usage': ["%s of %s MB" % (data_used, data_available)], }, names=['UPD', 'IMSI', 'Dataplan', 'Expiration date', 'Data usage'], Writer=asciitable.FixedWidth)