def test_floor(self): dt1 = das2.DasTime('2014-01-01T12:57:34.445') dt2 = das2.DasTime('2014-01-01T12:57') dt1.floor(60) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:57:34.445') dt2 = das2.DasTime('2014-01-01T12:57:30') dt1.floor(25) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:57:34.445') dt2 = das2.DasTime('2014-01-01T12:50') dt1.floor(600) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:57:34.445') dt2 = das2.DasTime('2014-01-01T12:40') dt1.floor(1200) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:57:34.445') dt2 = das2.DasTime('2014-01-01T12:00') dt1.floor(3600) self.assertEqual(dt1, dt2)
def checkAgeAccess(dConf, fLog, form, sResource, sValue): """Checks to see if the query string asks for data that is old enough. Only works for Das 2.1 queries right now. """ (sBeg, sEnd) = (form.getfirst('start_time',''), form.getfirst('end_time','')) if sBeg == '' or sEnd == '': (sBeg, sEnd) = (form.getfirst('time.min',''), form.getfirst('time.max','')) if sBeg == '' or sEnd == '': fLog.write(" Authorization: Can't determine query time range, start_time or end_time missing") return AUTH_FAIL try: dtBeg = das2.DasTime(sBeg) dtEnd = das2.DasTime(sEnd) except ValueError as e: fLog.write(" Authorization: Bad Query can't parse time range (%s to %s)"%(sBeg, sEnd)) return AUTH_FAIL # Get age in seconds dtLockBeg = _ageToTime(fLog, sResource, sValue) fLog.write(" Authorization: Lockout begins %s, query ends %s."%( str(dtLockBeg)[:-7], str(dtBeg)[:-7])) if dtLockBeg == None: return AUTH_SVR_ERR if dtBeg <= dtEnd and dtEnd < dtLockBeg: return AUTH_SUCCESS return AUTH_FAIL
def findWfr(log, sDataDir, dtBeg, dtEnd, bLowBand, bHighBand): log.info("Finding files between %s and %s" % (dtBeg, dtEnd)) lFiles = [] # For each 24 hours in the coverage period, try to find files dt = D.DasTime(dtBeg.year(), dtBeg.month(), dtBeg.dom()) lPtrns = [] if bLowBand: lPtrns.append("T%4d%1dXX/T%4d%03d/T%4d%03d_25HZ*.DAT") if bHighBand: lPtrns.append("T%4d%1dXX/T%4d%03d/T%4d%03d_2_5KHZ*.DAT") while dt < dtEnd: for sPtrn in lPtrns: sGlob = pjoin( sDataDir, sPtrn % (dt.year(), dt.doy() / 100, dt.year(), dt.doy(), dt.year(), dt.doy())) log.info("Checking time %s using pattern: %s" % (dt, sGlob)) lFiles += glob.glob(sGlob) dt.adjust(0, 0, 1) # Get next day return lFiles
def next(self): bytes = self.fIn.read(1024) if len(bytes) < 600: raise StopIteration if self.fIn.tell() == 1024: if sys.version_info[0] > 2: self.dtFrame = das2.DasTime(bytes[274:297].decode('utf-8')) else: self.dtFrame = das2.DasTime(bytes[274:297]) bytes = self.fIn.read(1024) if len(bytes) < 600: raise StopIteration else: return VgrWfrmRecord(self.dtFrame, bytes)
def findWbr(log, sDataDir, dtBeg, dtEnd, b10khz, b80khz, bHFR): lFiles = [] # For each hour in the coverage period, try to find files dt = D.DasTime(dtBeg.year(), dtBeg.month(), dtBeg.dom(), dtBeg.hour()) lPtrns = [] if b10khz: lPtrns.append("T%4d%1dXX/T%4d%03d/T%4d%03d_%02d_10KHZ*.DAT") elif b80khz: lPtrns.append("T%4d%1dXX/T%4d%03d/T%4d%03d_%02d_75KHZ*.DAT") elif bHFR: lPtrns.append("T%4d%1dXX/T%4d%03d/T%4d%03d_%02d_???*KHZ*.DAT") while dt < dtEnd: for sPtrn in lPtrns: sGlob = pjoin( sDataDir, sPtrn % (dt.year(), dt.doy() / 100, dt.year(), dt.doy(), dt.year(), dt.doy(), dt.hour())) log.debug(" Searching for files matching: %s" % sGlob) lFiles += glob.glob(sGlob) dt.adjust(0, 0, 0, 1) log.debug("%d files found" % len(lFiles)) return lFiles
def begin(self): """Returns the data collection initiation time of the first sample in the record as a Das2 Time object. Code assumes you've called pspice.furnsh() """ if not self.dtBeg: # Formats time from records (UTC) sSclk = "%d/%d:%d" % (self.nSclkPart, self.nSclkSec, self.nSclkFine) et = pspice.scs2e(-82, sSclk) sScet = pspice.et2utc(et, "ISOC", 6) self.dtBeg = D.DasTime(sScet) return self.dtBeg
def test_ceil(self): dt1 = das2.DasTime('2014-01-01T12:07:34.445') dt2 = das2.DasTime('2014-01-01T12:08') dt1.ceil(60) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:07:34.445') dt2 = das2.DasTime('2014-01-01T12:10') dt1.ceil(600) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:07:34.445') dt2 = das2.DasTime('2014-01-01T12:20') dt1.ceil(1200) self.assertEqual(dt1, dt2) dt1 = das2.DasTime('2014-01-01T12:07:34.445') dt2 = das2.DasTime('2014-01-01T13:00') dt1.ceil(3600) self.assertEqual(dt1, dt2)
def getVgrFileBegTime(sPath): """Read the Waveform Frame start time from the filename""" s = bname(sPath) if not s.startswith('VG'): return None try: nYr = int(s[4:8], 10) nMn = int(s[9:11], 10) nDom = int(s[12:14], 10) nHr = int(s[15:17], 10) nMin = int(s[18:20], 10) nSec = int(s[21:23], 10) nMilli = int(s[24:27], 10) fSec = float(nSec) + nMilli / 1000.0 except: #Doesn't look like a voyager file, skip it return None return das2.DasTime(nYr, nMn, nDom, nHr, nMin, fSec)
def main(argv): perr = sys.stderr.write if len(argv) < 2: perr("BUILD_DIRectory missing") return 4 if not os.path.isdir(argv[1]): perr("Directory %s doesn't exist"%argv[1]) sys.path.insert(0, "%s/%s"%(os.getcwd(), argv[1])) sys.path.insert(0, ".") import das2 as D dt = D.DasTime("1971-001") print("A parsed time") print(str(dt)[:-3]) print("") dt.adjust(0,0,364,23,59,59.999999) print("Adding 364 days, 23 hours, 59 minutes, and 59.999999 seconds") print(str(dt)) print("") print("Blindly printing to millisecond resolution (error)") print("%04d-%03dT%02d:%02d:%06.3f"%(dt.year(), dt.doy(), dt.hour(), dt.minute(), dt.sec())) print("") print("You can use the round_doy() function to help") print(dt.round_doy(dt.MILLISEC)) print("") print("Or the round() function too") print(dt.round(dt.MILLISEC)) print("") return 0
def sendDataPackets(cdf, dtBeg, dtEnd, lComp, bPolar): """Output all packets for a given file that are within the specified time range. Globals: g_bHdrSent: Tracks whether a header has been sent for this particular variable set, and if so what is it's packet ID. Args: sFile (str): The name of the CDF file dtBeg (DasTime): The inclusive lower bound minimum time to output dtEnd (DasTime): The exclusive upper bound maximum time to output lComp (list) : A list of the correlations to output, defaults to all the autocorrelations bPolar (bool) : If True output Magnitude and Phase angle instead of real and imaginary components Returns: bool : True if output should continue, False if done. """ global g_bHdrSent lCompInfo = getComp(cdf, lComp) aTime = cdf['Epoch'] # Output data in range nPkts = 0 for i in range( aTime.shape[0] ): dt = das2.DasTime(aTime[i]) if dt < dtBeg or dt >= dtEnd: continue if not g_bHdrSent: sendPktHdr(cdf, lComp, bPolar) g_bHdrSent = True write(':01:') # Various time encodings are supported by das2, we've somewhat randomly # chosen T2000, which happens to be seconds since 2000-01-01T00:00:00 # ignoring leap seconds xTime = struct.pack("=d", dt.t2000()) write( xTime ) # Write the data for all the selected components for tInfo in lCompInfo: (sComp, sVar, iIdx, bAuto) = tInfo aRe = cdf[sVar][i, iIdx, 0, : ] # Optimization: We specified numpy byte order so that we can # kick raw numpy bytes out the door without converting them. # only works if we don't have to do any calculations if bAuto: write( aRe.tobytes() ) else: aIm = cdf[sVar][i, iIdx, 1, : ] if bPolar: aCplx = np.empty(aRe.shape, dtype=complex) aCplx.real = aRe aCplx.imag = aIm # Make sure we use the same internal representation as the # original arrays because we are dumping binaries... aMag = np.absolute(aCplx).astype(aRe.dtype) aPhase = np.angle(aCplx, deg=True).astype(aRe.dtype) write(aMag.tobytes()) write(aPhase.tobytes()) else: write(aRe.tobytes()) write(aIm.tobytes()) # Flush packets as we go flush() nPkts += 1 return nPkts
def snapToTimeBlks(fLog, dsdf, sBeg, sEnd, nLevel, bCoverage=False): """Given a dsdf object which has fully initialize defaults and a cache level, stap begin and end times for cache generation to cache block boundaries. Returns a three tuple of (dtBeg, tAdj, dtEnd) dtBeg - A DasTime object for the begining of the cache period tAdj - A tuple of time adjustments needed to step from one file start time to the next. This has the format (nYear, nMonth, nDay, nHour, nMinute, nSec) dtEnd - A DasTime object for the ending of the cache period """ (nRes, sUnits, sPeriod, sParams) = dsdf['cacheLevel'][nLevel] sUnit = None if nRes != 0: if sUnits.lower() in ('sec', 's', 'second', 'seconds'): sUnit = 's' elif sUnits.lower() in ('ms', 'millisec', 'millisecond', 'milliseconds'): sUnit = 'ms' else: raise E.TodoError("Handling resolution in units other than seconds"+\ " or milliseconds is not yet implemented") sBeg = sBeg sEnd = sEnd dtB = das2.DasTime(sBeg) dtE = das2.DasTime(sEnd) if sPeriod == 'persecond': fFrac = dtE.sec() - int(dtE.sec()) if fFrac > 0.0: dtE.adjust(0, 0, 0, 0, 0, 1) return (das2.DasTime(dtB.year(), dtB.month(), dtB.dom(), dtB.hour(), dtB.minute(), dtB.sec()), (0, 0, 0, 0, 0, 1), das2.DasTime(dtE.year(), dtE.month(), dtE.dom(), dtE.hour(), dtE.minute(), dtE.sec())) elif sPeriod == 'perminute': if dtE.sec() > 0.0: dtE.adjust(0, 0, 0, 0, 1) return (das2.DasTime(dtB.year(), dtB.month(), dtB.dom(), dtB.hour(), dtB.minute()), (0, 0, 0, 0, 1, 0), das2.DasTime(dtE.year(), dtE.month(), dtE.dom(), dtE.hour(), dtE.minute())) elif sPeriod == 'hourly': if dtE.minute() > 0 or dtE.sec() > 0.0: dtE.adjust(0, 0, 0, 1) return (das2.DasTime(dtB.year(), dtB.month(), dtB.dom(), dtB.hour()), (0, 0, 0, 1, 0, 0), das2.DasTime(dtE.year(), dtE.month(), dtE.dom(), dtE.hour())) elif sPeriod == 'daily': if dtE.hour() > 0 or dtE.minute() > 0 or dtE.sec() > 0.0: dtE.adjust(0, 0, 1, 0) return (das2.DasTime(dtB.year(), dtB.month(), dtB.dom()), (0, 0, 1, 0, 0, 0), das2.DasTime(dtE.year(), dtE.month(), dtE.dom())) elif sPeriod == 'monthly': if dtE.dom() > 1 or dtE.hour() > 0 or dtE.minute() > 0 or dtE.sec( ) > 0.0: dtE.adjust(0, 1, 0, 0) return (das2.DasTime(dtB.year(), dtB.month(), 1), (0, 1, 0, 0, 0, 0), das2.DasTime(dtE.year(), dtE.month(), 1)) else: raise E.ServerError("Unknown storage period %s, in DSDF %s" % (sPeriod, sDsdf))
sys.stdout.buffer.write(thing.encode('utf-8')) else: sys.stdout.buffer.write(thing) def flush(): if sys.version_info[0] == 2: sys.stdout.flush() else: sys.stdout.buffer.flush() ############################################################################## # now for the reader ... arg = sys.argv start_time = das2.DasTime(arg[1]) end_time = das2.DasTime(arg[2]) ndata = 200 delta_t = (end_time - start_time) / 200. header = '''<stream version="2.2"> <properties double:zFill="-1.0e+31" DatumRange:xRange="%s to %s UTC" String:title="Random points" /> </stream> ''' % (str(start_time), str(end_time)) write("[00]{:06d}{}".format(len(header), header))
def main(argv): """Transmit a test dataset of 300 spectra given any input times """ perr = sys.stderr.write if len(argv) < 3: perr("Expected command line %s START_TIME END_TIME [PARAMETERS]\n") perr("Any times are fine as long as they are parseable and start < end\n") return 10 dtBeg = D.DasTime(argv[1]) dtEnd = D.DasTime(argv[2]) if dtBeg >= dtEnd: perr("Start time (%s) is >= end time (%s)"%(str(dtBeg), str(dtEnd))) return 11 sendHdr(dtBeg, dtEnd, sys.stdout) rSec = dtEnd - dtBeg rCadence = rSec/300 # Randomly pick 3 sets of ten vectors to skip lSkip = [] for i in range(0, 3): n = random.randrange(300) for j in range(0,10): if n < 289: lSkip.append(n + j) else: lSkip.append(n - j) # Randomly pick 30 other vectors to contain fill lFill = [] for i in range(0, 30): lFill.append( random.randrange(300) ) lSkip.sort() # Okay, start producing data dt = dtBeg.copy() for iX in range(0, 300): dt.adjust(0, 0, 0, 0, 0, rCadence) # Yea this can get round off errors # but it's only a test function if iX in lSkip: continue if iX in lFill: lVec = [-1.0]*100 else: lVec = getLogVec(300, iX, 100, -18.0, -6.0) buf = D.DasPktBuf(1) buf.add(dt.round(dt.MILLISEC)) buf.add(" ") for iY in range(0, 100): if iY < 99: buf.add("%10.3e "%lVec[iY]) else: buf.add("%10.3e\n"%lVec[iY]) buf.send(sys.stdout) return 0
def main(argv): sUsage = "%%prog [options] DATA_DIRECTORY BEGIN END" sDesc = """ Reads Themis spectral density auto-correlation values from archive CDFs. Format is similar to the Cluster Active Archive, see document: CAA-EST-UG-002 for details. """ psr = optparse.OptionParser( usage=sUsage, description=sDesc, prog=bname(argv[0]) ) psr.add_option('-l', "--log-level", dest="sLevel", metavar="LOG_LEVEL", help="Logging level one of [critical, error, warning, "+\ "info, debug]. The default is info.", type="string", action="store", default="info") (opts, lArgs) = psr.parse_args(argv[1:]) log = setupLogger(opts.sLevel) log = logging.getLogger('') if len(lArgs) < 1: return serverErr(log, "Misconfigured DSDF, data directory is missing") sRoot = lArgs[0] if len(lArgs) < 3: return queryErr(log, "Start and or Stop time is missing") try: dtBeg = das2.DasTime(lArgs[1]) except: return queryErr(log, "Couldn't parse time value '%s'"%lArgs[1]) try: dtEnd = das2.DasTime(lArgs[2]) except: return queryErr(log, "Couldn't parse time value '%s'"%lArgs[2]) # Take all the rest of the arguments and glop them together in a single # string. That way running the reader from the command line feels the # same as running it from Autoplot sParams = '' if len(lArgs) > 3: sParams = ' '.join(lArgs[3:]) # pull out the polar style output, i.e: Magnitude and Phase Angle bPolar = True if sParams.find('complex') != -1: sParams = sParams.replace('complex','').strip() bPolar = False # Default to printing all the autocorrelations sComp = 'BxBx ByBy BzBz ExEx EyEy EzEz' if len(sParams) > 0: sComp = sParams lComp = sComp.split() lComp.sort() # Look in directory tree for files that match. We sort the file names # under the assumption that sort order = numerical time order, but that # may not be true for some file types lDir = os.listdir(sRoot) lDir.sort() nSent = 0 bSentHdr = False for sF in lDir: if not sF.endswith('.cdf'): continue # only want CDFs if not sF.startswith('tha_l3_sm'): continue # Only want L3 SM # Make ISO-8601 strings sBeg = "%s-%s-%sT%s:%s:%s"%( sF[10:14], sF[14:16], sF[16:18], sF[19:21], sF[21:23], sF[23:25] ) sEnd = "%s-%s-%sT%s:%s:%s"%( sF[26:30], sF[30:32], sF[32:34], sF[35:37], sF[37:39], sF[39:41] ) sPath = pjoin(sRoot, sF) try: dtFileBeg = das2.DasTime(sBeg) dtFileEnd = das2.DasTime(sEnd) # Since the themis files truncate the seconds field, round up by # one second for the file end time... dtFileEnd += 1.0 except ValueError as e: log.waring("Unknown file %s in data area"%sPath) continue # If overlaps with desired range, include it in the output, send header # if haven't done so if (dtFileBeg < dtEnd) and (dtFileEnd > dtBeg): log.info("Reading %s"%sPath) cdf = pycdf.CDF(sPath) # Assmue all the files are similar enough that an informational # header can be created from the first one that fits the range if not bSentHdr: lIgnore = ['TIME_MAX','TIME_MIN', 'TIME_resolution'] dExtra = { 'title':getVespaTitle(cdf, 'THEMIS', lComp), 'Datum:xTagWidth':'0.5 s' # Max interp width for Autoplot } cdfToDas22Hdr(cdf, lIgnore, dExtra) bSentHdr = True nSent += sendDataPackets(cdf, dtBeg, dtEnd, lComp, bPolar) if nSent == 0: if not bSentHdr: writeHdrPkt(0, '<stream version="2.2" />\n') sFmt = '<exception type="NoDataInInterval" message="%s" />\n' sOut = sFmt%("No data in interval %s to %s UTC"%(str(dtBeg), str(dtEnd))) writeHdrPkt('xx', sOut) return 0
def main(argv): global g_bStrmHdrWritten sUsage = "%s [options] DATA_DIRECTORY BEGIN END"%bname(argv[0]) sDesc = """ Reads Voyager 1 High-Rate waveform values and produce a Das2 Stream. Three parameters are required, (1) The path to the directory where the datafiles reside, (2) The minmum time value of records to transmit, and (3) the maximum time value. """ psr = optparse.OptionParser(usage=sUsage, description=sDesc, prog=bname(argv[0])) psr.add_option('-l', "--log-level", dest="sLevel", metavar="LOG_LEVEL", help="Logging level one of [critical, error, warning, "+\ "info, debug]. The default is info.", type="string", action="store", default="info") (opts, lArgs) = psr.parse_args(argv[1:]) log = setupLogger(opts.sLevel) log = logging.getLogger('') if len(lArgs) < 1: return serverErr(log, "Misconfigured DSDF, data directory is missing") sRoot = lArgs[0] if len(lArgs) < 3: return queryErr(log, "Query error, Start and or Stop time is missing") try: dtBeg = das2.DasTime(lArgs[1]) except: return queryErr(log, "Couldn't parse time value '%s'"%lArgs[1]) try: dtEnd = das2.DasTime(lArgs[2]) except: return queryErr(log, "Couldn't parse time value '%s'"%lArgs[2]) # Send the stream header as soon as you can. This way if data loading # takes a while the client program knows the reader is alive and will # not shutoff the connection. sHdr = streamHeader({ 'String:renderer':'waveform',#<-- Tell Autoplot to use Waveform Rendering 'String:title':'Voyager PWS Wideband, Jupiter Encounter', 'Datum:xTagWidth': '120 ms', # Twice the time between rows 'DatumRange:xCacheRange': "%s to %s UTC"%(str(dtBeg)[:-3], str(dtEnd)[:-3]), 'String:xLabel' : 'SCET (UTC)' }) write(sHdr) g_bStrmHdrWritten = True write( VgrWfrmRecord.das2HeaderPacket(1) ) flush() # It's good to flush stdout output right after sending headers so # Autoplot get's something right a way. # File search range starts 48 seconds before given time range since Voyager # waveform frame files contain 48 seconds worth of data dtSearchBeg = dtBeg.copy() dtSearchBeg -= 48.0 # Though it's not needed for the small time extent of the sample dataset, # sending task progress messages allows Autoplot to display a data loading # progress bar (aka Human Amusement Device) progress = None lFiles = os.listdir(sRoot) lFiles.sort() # Interation below assumes file list and file records are in ascending # time order, this is typically the case. nSent = 0 for sFile in lFiles: dtFileBeg = getVgrFileBegTime(sFile) # Skip unknown files and files that are out of the query range if dtFileBeg == None: continue if dtFileBeg < dtSearchBeg or dtEnd <= dtFileBeg: continue if progress == None: progress = TimeProgressTracker(bname(argv[0]), dtFileBeg, dtEnd, 100) for rec in VgrFileReader(log, pjoin(sRoot, sFile)): # since input data are monotonic, quit when encountering a # record that is past the end point if rec.dtBeg >= dtEnd: break if rec.dtBeg < dtEnd and rec.dtEnd > dtBeg: write(rec.das2DataPacket(1)) nSent += 1 # Check/Send progress progress.status(rec.dtBeg) # If not data were available in the given time range inform the client if nSent == 0: sendNoData(log, dtBeg, dtEnd) return 0
def makePlot(log, sServer, sSource, sRange, sInterval, sParams, sJavaBin, sAltAutoplot=None): '''Returns: The 2-tuple (nRetCode, sMsg) then return codes are: 0 - Plot constructed properly 1 - 3 Setup problem, can't find autoplot or something like that 7 - Resource limit hit on sub-program 101-104 - Bad plot, but everything looked like it should have run 111 - DSDF problem ''' log.info("Testing %s" % sSource) lRange = sRange.split('|')[0].split() if len(lRange) < 3 or lRange[1].lower() != 'to': return (111, "Improper ExampleRange value") sMsg = "Range: %s to %s" % (lRange[0], lRange[2]) if sInterval: sUri = 'vap+das2server:%s?dataset=%s&start_time=%s&end_time=%s&interval=%s' % ( sServer, sSource, lRange[0], lRange[2], sInterval) sMsg += ", interval: %s" % sInterval else: fRes = (das2.DasTime(lRange[2]) - das2.DasTime(lRange[0])) / 1000 sMsg += ", resolution: %f s" % fRes sUri = 'vap+das2server:%s?dataset=%s&start_time=%s&end_time=%s&resolution=%f' % ( sServer, sSource, lRange[0], lRange[2], fRes) if sParams: sUri += "&%s" % sParams.replace(' ', '%20') sMsg += ", parameters: %s" % sParams log.info(sMsg) sPngPath = pjoin(os.getcwd(), sSource.replace('/', '_') + ".png") if os.path.isfile(sPngPath): os.remove(sPngPath) sScript = g_sScriptTplt % (sUri, sSource, sPngPath) sScriptName = sSource.replace('/', '_') + ".jy" fOut = open(sScriptName, 'w') fOut.write(sScript) fOut.close() sAutoplot = g_sJenkinsAutoplot if sAltAutoplot != None: sAutoplot = sAltAutoplot sScriptPath = pjoin(os.getcwd(), sScriptName) sCmd = '%s -cp %s -Djava.awt.headless=true org.autoplot.AutoplotUI --script "%s"' % ( sJavaBin, sAutoplot, sScriptPath) log.info("Exec: %s" % sCmd) # Run command for up to 5 minutes with 1MB StdOut and StdErr (nLimit, nReturn, sStdOut, sStdErr) = runProc(sCmd, 600, 1048576, 1048576) if nLimit != None: return (7, "Sub-process resource limit hit: %s" % g_LimitMsg[nLimit]) if nReturn != 0: if nReturn == 101: sMsg = "No data in interval" elif nReturn == 104: sMsg = "Dataset not created" elif nReturn == 105: sMsg = "Zero length data set, but NoData exception is missing." elif nReturn == 17: sMsg = "Network Connection Timeout" else: sMsg = sStdOut log.warning("Exec: %s\n Return: %d\n Reason: %s" % (sCmd, nReturn, sMsg)) return (nReturn, sMsg) if not os.path.isfile(sPngPath): log.error(sStdOut) return ( 1, "Proper Autoplot exit, but %s is missing (HINT: If using pyServer check TEST_FROM in das2server.conf." % sPngPath) return (0, "%s tested okay" % sSource)
(1980, 1, 1, 19.0), (1981, 7, 1, 20.0), (1982, 7, 1, 21.0), (1983, 7, 1, 22.0), (1985, 7, 1, 23.0), (1988, 1, 1, 24.0), (1990, 1, 1, 25.0), (1991, 1, 1, 26.0), (1992, 7, 1, 27.0), (1993, 7, 1, 28.0), (1994, 7, 1, 29.0), (1996, 1, 1, 30.0), (1997, 7, 1, 31.0), (1999, 1, 1, 32.0), (2006, 1, 1, 33.0), (2009, 1, 1, 34.0), (2012, 7, 1, 35.0), (2015, 7, 1, 36.0), (2017, 1, 1, 37.0) ] for t in l: dt = das2.DasTime(t[0], t[1], t[2]) t2K = dt.t2000() if t2K < 0: print("{%f, %.8e}, /* %04d-%02d-%02d */"%(32 - t[3] + 1, t2K*1e6, t[0], t[1], t[2]) ) else: print("{%f, %.8e}, /* %04d-%02d-%02d */"%(t[3] - 32, t2K*1e6, t[0], t[1], t[2]) )