Exemplo n.º 1
0
    def apply_holidays(self):
        for h in self.bh.holidays:
            if h[1] == "Holidays":
                continue

            d = h[0]

            if not (self.start <= d <= self.end):
                continue

            weekday = d.weekday() + 1
            if weekday in self.bh.weekends:
                log.warning(f"Skipping weekend day {d}")
                continue

            if d not in self.days:
                log.info(f"Adding new day entry list for day {d}")
                self.days[d] = StrictList(Entry)

            dwh = self.bh.get_daily_working_hours() - self.bh.breaks
            dwstart = self.bh.worktimings[0]
            dtime = add_hours(d, dwstart)
            dtime = self.get_timezone().localize(dtime)

            self.project_seconds[h[1]] += tdelta(hours=dwh).total_seconds()
            self.total_time += tdelta(hours=dwh)
            entry = Entry(h[1], dtime, add_hours(dtime, dwh),
                          tdelta(hours=dwh), ["off"])
            pause_entry = Entry(h[1], entry.end,
                                add_hours(entry.end, self.bh.breaks),
                                tdelta(hours=self.bh.breaks), ["pause", "off"])
            log.info(f"Adding entry {entry} to {d}")
            self.days[d].append(entry)
Exemplo n.º 2
0
    def __init__(self, startDate, fhr, flagged, lat, lon, mslp, maxwind, 
                 fcstDate=None):
        self.start_date = startDate
        self.fhr = fhr
        if str(flagged) == '0' or str(flagged) == 'False':
            self.flagged = False
        elif str(flagged) == '1' or str(flagged) == 'True':
            self.flagged = True
        else:
            print 'Unable to determine Flag status'
            sys.exit(1)
        self.lat  = lat
        self.lon = lon
        self.mslp_value = mslp
        self.maxwind_value = maxwind
        #self.mslp = mslp
        #self.maxwind = maxwind

        if fcstDate:
            self.fcst_date = fcstDate
        elif fhr is not None:
            if not isinstance(self.start_date, dtime):
                # TODO : Shoudl be datetime going forward, so shouldn't need this
                #sd = dtime.fromtimestamp(self.start_date).strftime('%c')
                sd = dtime.fromtimestamp(self.start_date)
                self.fcst_date = sd + tdelta(hours=fhr)
            else:
                self.fcst_date = self.start_date + tdelta(hours=fhr)
def main():
    today = dt.utcnow()
    dateobj = dt.utcnow()
    dates = []
    
    done = False
    while not done:
        date = dateobj.strftime('%Y-%m-%d')
        print(f"Checking: {date}")
        if args.sa == get_SA(date=date, tel=1):
            dates.append([date, 1])
        elif args.sa == get_SA(date=date, tel=2):
            dates.append([date, 2])
        else:
            if len(dates) != 0:
                done = True
            if today > today + tdelta(30,0):
                done = True
        dateobj += tdelta(1,0)

    for date in dates:
        result = get_telsched(from_date=date[0], ndays=1, telnr=date[1])[0]
        print(result)
        print(result['PiEmail'])
        print(result['Observers'])
Exemplo n.º 4
0
def parse_iso8601(text):
    """Parse an iso 8601 string, must be in extended format, currently only
    supports dates."""
    date_text = text.split('T')[0]
    try:
        time_text = text.split('T')[1]
    except IndexError:
        time_text = None
    date_parts = date_text.split('-')
    if len(date_parts) < 1:
        raise ValueError('date %s is invalid')
    elif len(date_parts) == 3:
        first_day = date(int(date_parts[0]), int(date_parts[1]), int(date_parts[2]))
        last_day = first_day+tdelta(days=1)
    elif len(date_parts) == 2:
        year = int(date_parts[0])
        month = int(date_parts[1])
        first_day = date(year, month, 1)
        days = calendar.monthrange(year, month)[1]
        last_day = first_day + tdelta(days)
    elif len(date_parts) == 1:
        year = int(date_parts[0])
        first_day = date(year, 1, 1)
        last_day = date(year+1, 1, 1)
    else:
        raise ValueError('too many date_parts in iso 8601 date')
    if time_text:
        raise NotImplementedError('can only parse dates at this time')
    else:
        first_time = last_time = time(0, 0, 0)
    return combine_dt(first_day, first_time), combine_dt(last_day, last_time)
Exemplo n.º 5
0
def parse_iso8601(text):
    """Parse an iso 8601 string, must be in extended format, currently only
    supports dates."""
    date_text = text.split('T')[0]
    try:
        time_text = text.split('T')[1]
    except IndexError:
        time_text = None
    date_parts = date_text.split('-')
    if len(date_parts) < 1:
        raise ValueError('date %s is invalid')
    elif len(date_parts) == 3:
        first_day = date(int(date_parts[0]), int(date_parts[1]),
                         int(date_parts[2]))
        last_day = first_day + tdelta(days=1)
    elif len(date_parts) == 2:
        year = int(date_parts[0])
        month = int(date_parts[1])
        first_day = date(year, month, 1)
        days = calendar.monthrange(year, month)[1]
        last_day = first_day + tdelta(days)
    elif len(date_parts) == 1:
        year = int(date_parts[0])
        first_day = date(year, 1, 1)
        last_day = date(year + 1, 1, 1)
    else:
        raise ValueError('too many date_parts in iso 8601 date')
    if time_text:
        raise NotImplementedError('can only parse dates at this time')
    else:
        first_time = last_time = time(0, 0, 0)
    return combine_dt(first_day, first_time), combine_dt(last_day, last_time)
Exemplo n.º 6
0
    def get(self, telescope):
        tlog.app_log.info('Get request for ListOfNights recieved')
        telescope = telescope.strip('/')

        ## Create Telescope Object
        #         config_file = os.path.join(os.path.expanduser('~'), '.{}.yaml'.format(telescope))
        tel = Telescope(telescope)
        telescopename = tel.name

        client = MongoClient(tel.mongo_address, tel.mongo_port)
        db = client[tel.mongo_db]
        collection = db[tel.mongo_collection]

        #         first_date_string = sorted(collection.distinct("date"), reverse=False)[0]
        #         first_date = dt.strptime('{} 00:00:00'.format(first_date_string), '%Y%m%dUT %H:%M:%S')
        first_date = sorted(collection.distinct("date"), reverse=False)[0]

        tlog.app_log.info('  Building date_list')
        date_list = []
        while first_date <= dt.utcnow():
            date_list.append(first_date.strftime('%Y%m%dUT'))
            first_date += tdelta(1, 0)
        date_list.append(first_date.strftime('%Y%m%dUT'))
        tlog.app_log.info('  Done')

        night_plot_path = os.path.abspath('/var/www/nights/')

        tlog.app_log.info('  Looping over date_list')
        nights = []
        for date_string in date_list:
            night_info = {'date': date_string}

            night_graph_file = '{}_{}.png'.format(date_string, telescope)
            if os.path.exists(os.path.join(night_plot_path, night_graph_file)):
                night_info['night graph'] = night_graph_file

#             night_info['n images'] = collection.find( {"date":date_string} ).count()

            start = dt.strptime(date_string, '%Y%m%dUT')
            end = start + tdelta(1)
            night_info['n images'] = collection.find({
                "date": {
                    "$gt": start,
                    "$lt": end
                }
            }).count()

            if night_info['n images'] > 0:
                nights.append(night_info)
        nights.reverse()  # reverse sort to put recent dates at top of page
        tlog.app_log.info('  Done')

        tlog.app_log.info('  Rendering ListOfNights')
        self.render("night_list.html", title="{} Results".format(telescopename),\
                    telescope = telescope,\
                    telescopename = telescopename,\
                    nights = nights,\
                   )
        tlog.app_log.info('  Done')
Exemplo n.º 7
0
def multiRW(dimx, h, pot, nsamples, nchains, thin, L, verbose=True):
    parallelchains = mp.cpu_count()
    if (verbose):
        print("--- Multichain MC ---")
        print("TOTAL number of chains: ", nchains)
        print("Chains in parallel: ", parallelchains)
        print("samples of dimension ", dimx)
#        input("press ENTER to continue")
    chains = []
    acceptrates = []

    # Function to read the results produced by a single chainRW
    def addChain(chainRW_result):
        chains.append(chainRW_result[0])
        acceptrates.append(chainRW_result[2])

    # Prepare #nchains random starting point, each is a startx for a chain
    startpoints = []
    for i in range(nchains):
        startpoints.append(np.random.uniform(-L, L, dimx))
    # Run a single chain to have a time estimation
    starttime = time.time()
    addChain(chainRW(startpoints[0], h, pot, nsamples, thin, L, 2, None))
    if (verbose):
        linear_time = int((time.time() - starttime) * nchains)
        optim_time = linear_time / parallelchains
        print("Approx. MAX running time: " + str(tdelta(seconds=linear_time)))
        print("Approx. MIN running time: " + str(tdelta(seconds=optim_time)))
        print("staring with parallels chains")
    # Produce multiple chains in parallel
#    print("FLAG1")
    pool = mp.Pool(parallelchains)
    #    print("FLAG2")
    for j in range(1, nchains):
        pool.apply_async(chainRW,
                         args=(startpoints[j], h, pot, nsamples, thin, L, 2,
                               j),
                         callback=addChain)
    pool.close()
    pool.join()
    #    print("FLAG3")
    #    if (verbose):
    #        print("Chains = ", chains)
    #        input("Press ENTER: building the single final chain.")
    # Now, construct a SINGLE chain by taking random samples from the chains
    X = []
    for i in range(nsamples):
        # Add to X a random sample from a random chain, counting from the end
        # (in order to avoid the burning time samples)
        nth = np.random.random_integers(1, nsamples - 1)
        X.append(chains[np.random.random_integers(0, nchains - 1)][-nth])
    X = np.asanyarray(X)
    acceptrates = np.asanyarray(acceptrates)
    mean_acceptance = sum([x for x in acceptrates]) / len(acceptrates)
    print("Averge rate: ", mean_acceptance)
    expect = sum([x for x in X]) / nsamples
    print("Multichain expectation: ", expect)
    return X, mean_acceptance, expect
Exemplo n.º 8
0
    def get(self, telescope):
        tlog.app_log.info('Get request for ListOfNights recieved')
        telescope = telescope.strip('/')

        ## Create Telescope Object
#         config_file = os.path.join(os.path.expanduser('~'), '.{}.yaml'.format(telescope))
        tel = Telescope(telescope)
        telescopename = tel.name

        client = MongoClient(tel.mongo_address, tel.mongo_port)
        db = client[tel.mongo_db]
        collection = db[tel.mongo_collection]

#         first_date_string = sorted(collection.distinct("date"), reverse=False)[0]
#         first_date = dt.strptime('{} 00:00:00'.format(first_date_string), '%Y%m%dUT %H:%M:%S')
        first_date = sorted(collection.distinct("date"), reverse=False)[0]
        
        tlog.app_log.info('  Building date_list')
        date_list = []
        while first_date <= dt.utcnow():
            date_list.append(first_date.strftime('%Y%m%dUT'))
            first_date += tdelta(1, 0)
        date_list.append(first_date.strftime('%Y%m%dUT'))
        tlog.app_log.info('  Done')

        night_plot_path = os.path.abspath('/var/www/nights/')

        tlog.app_log.info('  Looping over date_list')
        nights = []
        for date_string in date_list:
            night_info = {'date': date_string }

            night_graph_file = '{}_{}.png'.format(date_string, telescope)
            if os.path.exists(os.path.join(night_plot_path, night_graph_file)):
                night_info['night graph'] = night_graph_file

#             night_info['n images'] = collection.find( {"date":date_string} ).count()
            
            start = dt.strptime(date_string, '%Y%m%dUT')
            end = start + tdelta(1)
            querydict = {"date": {"$gt": start, "$lt": end},
                         "telescope": tel.name}
            night_info['n images'] = collection.find(querydict).count()
            
            if night_info['n images'] > 0:
                nights.append(night_info)
        nights.reverse() # reverse sort to put recent dates at top of page
        tlog.app_log.info('  Done')

        tlog.app_log.info('  Rendering ListOfNights')
        self.render("night_list.html", title="{} Results".format(telescopename),\
                    telescope = telescope,\
                    telescopename = telescopename,\
                    nights = nights,\
                   )
        tlog.app_log.info('  Done')
Exemplo n.º 9
0
    def __init__(self, info, subject_day_index, weeks_interval, denominator):
        self.type, self.name, self.auditorium, self.professor = info

        time_shift = denominator * 7 + subject_day_index
        self.start_date = (self.semester_start_date +
                           tdelta(days=time_shift)).strftime('%Y%m%d')
        self.weeks_interval = weeks_interval
Exemplo n.º 10
0
    def addReplayToTracker(self, rep: dict, row):
        self.gameTracker.insertRow(self.gameTracker.rowCount())
        GT = self.gameTracker
        RC = GT.rowCount()

        timeStr = str(
            tdelta(0, float(rep['time']) / self.framerate))
        if '.' not in timeStr:
            timeStr += '.000'
        timeStr = timeStr[:10]

        GTItemStrings = [
            '✓' if rep['fileName'] not in ignoredReplaysList else '✖',
            rep['fileName'],
            rep['mode'],
            str(round(float(rep['pps']), 3)).ljust(5, '0'),
            timeStr,
            rep['score'],
            rep['pieces'],
            rep['lines'],
        ]

        for col, i in zip(range(9), GTItemStrings):
            item = QTableWidgetItem()
            item.setText(i)
            item.setWhatsThis(str(row))
            if i == '✓' or i == '✖':
                item.setTextAlignment(Qt.AlignCenter)
            elif i.replace('.', '').isnumeric():
                item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
            GT.setItem(RC - 1, col, item)
Exemplo n.º 11
0
 def computeVWSP(self, stockSymbol):
     """
     Computes the Volume Weighted Stock Price based on trades in past 15 minutes
     :param stockSymbol: Must be recognised from the data in sampleData
     :return:
     """
     currentTime = dt.now()
     deltaTime = tdelta(minutes=15)
     gen = ((trade['tradePrice'], trade['quantityShares'])
            for trade in self.histTrade if (trade['stock'] == stockSymbol)
            & (currentTime - trade['timestamp'] < deltaTime))
     res = 0.
     totalQuantity = 0.
     for price, quantity in gen:
         res += price * quantity
         totalQuantity += quantity
         # for higher precision, consider using numpy:
     # for price, quantity in gen:
     #   prices.append(price)
     #  quantities.append(quantity)
     #result = numpy.average(prices, 0, quantities) . Note that numpy specific types could also be used
     if totalQuantity == 0:
         raise ValueError(
             "The stock {stock} has not been traded during the last 15 minutes."
             .format(stock=stockSymbol))
         #prossibly give other information, like the last trade price for that given stock if exists
     return res / totalQuantity
Exemplo n.º 12
0
 def test_completed(self):
     due_date = get_day(-1)
     start_date = get_day(-2)
     finish_date = start_date + tdelta(days=1)
     action0 = Action(self.text, due=due_date, start=start_date,
             finish=finish_date)
     self.assertEqual(action0.text, self.text)
     self.assertEqual(action0.due, due_date)
     self.assertEqual(action0.start_time, start_date)
     self.assertEqual(action0.finish_time, finish_date)
     self.assertEqual(action0.is_task, True)
     self.assertEqual(action0.is_event, True)
     self.assertEqual(action0.completed, True)
     self.assertEqual(action0.duration, tdelta(days=1))
     self.assertEqual(action0.latent, False)
     self.assertEqual(action0.ongoing, False)
Exemplo n.º 13
0
 def init_by_config(self,
                    start_date,
                    end_date,
                    capital,
                    benchmark,
                    data_path='Data/test_data/',
                    save_path='Output/'):
     if data_path[-1] == '/':
         self._data_path = data_path
     else:
         self._data_path = data_path + '/'
     if save_path[-1] == '/':
         self._save_path = save_path
     else:
         self._save_path = save_path + '/'
     self._start_date = pd.Timestamp(start_date)
     self._end_date = pd.Timestamp(end_date)
     times = start_date.split('-')
     self._date_sequence.append(
         pd.Timestamp(
             dt(int(times[0]), int(times[1]), int(times[2])) +
             tdelta(days=-1)))
     for date in pd.date_range(self._start_date, self._end_date, freq='D'):
         date_str = str(date).split(' ')[0]
         if self._has_date(date_str):
             self._date_sequence.append(date_str)
     self._period = len(self._date_sequence) - 1
     self._total_capital = capital
     self._benchmark = benchmark
Exemplo n.º 14
0
    def __init__(self, date_string=None, data_file=None, *args, **kwargs):
        super(WeatherPlotter, self).__init__()
        self.args = args
        self.kwargs = kwargs

        config = load_config(config_files=['peas'])
        self.cfg = config['weather']['plot']
        location_cfg = config.get('location', None)

        self.thresholds = config['weather'].get('aag_cloud', None)

        if not date_string:
            self.today = True
            self.date = dt.utcnow()
            self.date_string = self.date.strftime('%Y%m%dUT')
            self.start = self.date - tdelta(1, 0)
            self.end = self.date
            self.lhstart = self.date - tdelta(0, 60 * 60)
            self.lhend = self.date + tdelta(0, 5 * 60)

        else:
            self.today = False
            self.date = dt.strptime('{} 23:59:59'.format(date_string),
                                    '%Y%m%dUT %H:%M:%S')
            self.date_string = date_string
            self.start = dt(self.date.year, self.date.month, self.date.day, 0, 0, 0, 0)
            self.end = dt(self.date.year, self.date.month, self.date.day, 23, 59, 59, 0)
        print('Creating weather plotter for {}'.format(self.date_string))

        self.twilights = self.get_twilights(location_cfg)

        self.table = self.get_table_data(data_file)

        if self.table is None:
            warnings.warn("No data")
            sys.exit(0)

        self.time = pd.to_datetime(self.table['date'])
        first = self.time[0].isoformat()
        last = self.time[-1].isoformat()
        print('  Retrieved {} entries between {} and {}'.format(
              len(self.table), first, last))

        if self.today:
            self.current_values = self.table[-1]
        else:
            self.current_values = None
Exemplo n.º 15
0
    def get_all_work_days(self, month=-1, year=-1):
        if month != -1:
            if year == -1:
                year = self.start.year

            _, diff_days = monthrange(year, month)
            diff_s_dt = dt(self.start.year, month, 1)
            diff_e_dt = dt(self.end.year, month, diff_days)
            diff = (diff_e_dt + tdelta(days=1)) - diff_s_dt
        else:
            diff = (self.end + tdelta(days=1)) - self.start

        for i in range(diff.days):
            day = self.start + tdelta(i)
            wd = day.weekday() + 1
            if wd not in self.weekends:
                yield day
Exemplo n.º 16
0
def compare_twilights():
    date = dt.strptime(f'2018-08-01 18:00:00', '%Y-%m-%d %H:%M:%S')
    enddate = dt.strptime(f'2019-02-01 18:00:00', '%Y-%m-%d %H:%M:%S')
    while date < enddate:
        datestr = date.strftime('%Y-%m-%d')
        diff = compare_twilights_on(datestr)
        print(f"{date}: {diff[0]:+5.1f}, {diff[1]:+5.1f}, {diff[2]:+5.1f}")
        date += tdelta(0, 24 * 60 * 60)
Exemplo n.º 17
0
def retrieve_weather(lookbackdays=0):
    delta_time = tdelta(lookbackdays, 120)
    client = pymongo.MongoClient('192.168.1.101', 27017)
    db = client.vysos
    weather = db.weather
    weatherdata = [x for x in weather.find( {"date": {"$gt": dt.utcnow()-delta_time} } )]
    client.close()
    return weatherdata
def compare_twilights():
    date = dt.strptime(f'2018-08-01 18:00:00', '%Y-%m-%d %H:%M:%S')
    enddate = dt.strptime(f'2019-02-01 18:00:00', '%Y-%m-%d %H:%M:%S')
    while date < enddate:
        datestr = date.strftime('%Y-%m-%d')
        diff = compare_twilights_on(datestr)
        print(f"{date}: {diff[0]:+5.1f}, {diff[1]:+5.1f}, {diff[2]:+5.1f}")
        date += tdelta(0,24*60*60)
Exemplo n.º 19
0
    def av_unit_price(self, symbol, at_date):
        # TODO improve error handling
        # TODO improve multiple attempt failure handling
        """Uses AlphaVantage to find the unit price of a symbol at a date"""

        url = "https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&"\
              "outputsize=full&symbol={0}&apikey={1}"\
              .format(symbol, self.av_key)
        fail = True
        attempt = 0
        while (fail is True) and (attempt < 10):
            try:
                r = requests.get(url)
                time_series = json.loads(r.text)["Time Series (Daily)"]
                fail = False
                logging.info("Time series retreival was successful")
            except:
                fail = True
                time.sleep(10)
                attempt += 1
                logging.warning(
                    "Time series unsuccessful. Attempt {}".format(attempt))
            check_date_strings = [
                (at_date - tdelta(days=3)).strftime("%Y-%m-%d"),
                (at_date - tdelta(days=2)).strftime("%Y-%m-%d"),
                (at_date - tdelta(days=1)).strftime("%Y-%m-%d"),
                (at_date + tdelta(days=1)).strftime("%Y-%m-%d"),
                at_date.strftime("%Y-%m-%d")
            ]
        for check_date in check_date_strings:
            try:
                unit_price = time_series[check_date]['4. close']
            except Exception as e:
                logging.warning(
                    "Unit price not recorded for {}".format(check_date))
                logging.error(e)
        try:
            logging.debug(
                "Unit price for {} on {} is ${} (using AlphaVantage)".format(
                    symbol, at_date, unit_price))
        except:
            logging.error("Unit price not located for {}".format(symbol))
            sys.exit(1)

        return float(unit_price)
Exemplo n.º 20
0
 def test_completed(self):
     due_date = get_day(-1)
     start_date = get_day(-2)
     finish_date = start_date + tdelta(days=1)
     action0 = Action(self.text,
                      due=due_date,
                      start=start_date,
                      finish=finish_date)
     self.assertEqual(action0.text, self.text)
     self.assertEqual(action0.due, due_date)
     self.assertEqual(action0.start_time, start_date)
     self.assertEqual(action0.finish_time, finish_date)
     self.assertEqual(action0.is_task, True)
     self.assertEqual(action0.is_event, True)
     self.assertEqual(action0.completed, True)
     self.assertEqual(action0.duration, tdelta(days=1))
     self.assertEqual(action0.latent, False)
     self.assertEqual(action0.ongoing, False)
def get_twilights(date):
    """ Get twilight times from Keck API """
    url = f"https://www.keck.hawaii.edu/software/db_api/metrics.php?date={date}"
    r = requests.get(url)
    result = json.loads(r.text)
    assert len(result) == 1
    t = result[0]

    # In Keck API, date is HST, but time is UT (ugh!)
    h, m = t['sunset'].split(':')
    t['sunset HST'] = f"{int(h)+14:02d}:{m}" # correct to HST
    
    t['seto'] = dt.strptime(f"{t['udate']} {t['sunset HST']}", '%Y-%m-%d %H:%M')
    t['seto'] += tdelta(0,10*60*60) # correct to UT
    t['riseo'] = dt.strptime(f"{t['udate']} {t['sunrise']}", '%Y-%m-%d %H:%M')
    t['riseo'] += tdelta(0,24*60*60) # correct to UT

    return t
Exemplo n.º 22
0
def last_weeks_points(today=None):
    """Returns today's points and the last 7 days (i.e. 8 days total)"""
    if today is None:
        today = dtime.now().date()
    week = []
    for i in xrange(8):
        day = today-tdelta(days=i)
        week.append((day, get_daily_points(day)))
    return week
Exemplo n.º 23
0
def last_weeks_points(today=None):
    """Returns today's points and the last 7 days (i.e. 8 days total)"""
    if today is None:
        today = dtime.now().date()
    week = []
    for i in xrange(8):
        day = today - tdelta(days=i)
        week.append((day, get_daily_points(day)))
    return week
Exemplo n.º 24
0
 def __init__(self, ws):
     self.ws = ws
     self.days = {}
     self.seconds = {}
     self.total_time = tdelta(0)
     self.project_durations_in_secs = {"Vacations": 0.0, "Sick": 0.0}
     self.projects = []
     self.native_projects = []
     self.load_projects()
Exemplo n.º 25
0
def open_dataset(input,
                 variables=[],
                 time_calendar=None,
                 time_raw=None,
                 time_units=None,
                 time_offset=0,
                 time_from=None,
                 eta_rho_slice=None,
                 xi_rho_slice=None,
                 s_rho_slice=None):
    """
        Load dataset and grid file, overwrite calendar and units.
        """
    # open data
    dataset = open_glob_dataset(input,
                                keep_vars=variables + ['time'],
                                time_slice=None)
    # slice data
    if eta_rho_slice is not None or xi_rho_slice is not None or s_rho_slice is not None:
        dataset = slice_on_rho_grid(dataset,
                                    eta_rho_slice=eta_rho_slice,
                                    xi_rho_slice=xi_rho_slice,
                                    s_rho_slice=s_rho_slice)
    # open another dataset to copy its time array to the opened dataset
    if time_from is not None:
        aux_ds = open_glob_dataset(time_from,
                                   keep_vars=['time'],
                                   time_slice=None)
        attrs = aux_ds.time.attrs
        dataset['time'] = xr.DataArray(aux_ds['time'].values, dims=('time', ))
        dataset['time'].attrs = attrs
        aux_ds.close()

    # if no time to process, skip
    if 'time' not in dataset:
        return dataset

    # reset calendar and units
    if time_raw is not None:
        dataset['time'] = xr.DataArray(time_raw, dims=('time', ))
    if time_calendar is not None:
        dataset.time.attrs['calendar'] = time_calendar
    if time_units is not None:
        dataset.time.attrs['units'] = time_units

    # initialize time
    dataset = set_time(dataset, dt=tdelta(seconds=time_offset))

    # calculate day of year
    time_attrs = {**dataset.time.attrs}
    doy = np.array([a.dayofyr for a in dataset.time.values]) - 1

    # create doy variable on data
    dataset['doy'] = xr.DataArray(doy, dims=('time', ))
    dataset.time.attrs = time_attrs

    return dataset
Exemplo n.º 26
0
def get_status(telescope, db):
    collection = db[f'{telescope}status']
    two_min_ago = dt.utcnow() - tdelta(0, 2*60)
    values = [x for x in
              collection.find( {'date': {'$gt': two_min_ago}} ).sort('date')]
    try:
        current = status_values[-1]
    except:
        current = None
    return current
Exemplo n.º 27
0
def get_status(telescope, db):
    collection = db[f'{telescope}status']
    two_min_ago = dt.utcnow() - tdelta(0, 2*60)
    values = [x for x in
              collection.find( {'date': {'$gt': two_min_ago}} ).sort('date')]
    try:
        current = status_values[-1]
    except:
        current = None
    return current
Exemplo n.º 28
0
def get_twilights(date):
    """ Get twilight times from Keck API """
    url = f"https://www.keck.hawaii.edu/software/db_api/metrics.php?date={date}"
    r = requests.get(url)
    result = json.loads(r.text)
    assert len(result) == 1
    t = result[0]

    # In Keck API, date is HST, but time is UT (ugh!)
    h, m = t['sunset'].split(':')
    t['sunset HST'] = f"{int(h)+14:02d}:{m}"  # correct to HST

    t['seto'] = dt.strptime(f"{t['udate']} {t['sunset HST']}",
                            '%Y-%m-%d %H:%M')
    t['seto'] += tdelta(0, 10 * 60 * 60)  # correct to UT
    t['riseo'] = dt.strptime(f"{t['udate']} {t['sunrise']}", '%Y-%m-%d %H:%M')
    t['riseo'] += tdelta(0, 24 * 60 * 60)  # correct to UT

    return t
Exemplo n.º 29
0
    def calculate_percents(self):
        for ws in self.ws:
            ws_obj = Workspace(ws)

            log.info(mk_headline(f"Times in Workspace {ws}", "*"))
            # seconds = {}
            self.total_time = tdelta(0)

            self.project_seconds = {
                "Vacations": 0.0,
                "Courses": 0.0,
                "Sick": 0.0
            }

            for project in ws_obj.native_projects:
                p_name = project.name
                times = project.time_entries.list()

                for i in times:
                    if not hasattr(i, "stop"):
                        log.warn("Entry %s seems to still be running" %
                                 i.description)
                        continue
                    start = i.start.replace(tzinfo=pytz.timezone("UTC"))
                    end = i.stop.replace(tzinfo=pytz.timezone("UTC"))

                    if start.date() < self.start or end.date() > self.end:
                        continue

                    dur = end - start

                    if dur.total_seconds() / 3600. > 11:
                        log.warn("Warning: the entry seems to be too long:")
                        log.warn(
                            f"{p_name} from {start} to {end}; duration {dur}")

                    if start.date() not in self.days:
                        self.days[start.date()] = StrictList(Entry)

                    if p_name not in self.project_seconds:
                        self.project_seconds[p_name] = 0.0

                    e = None

                    tags = list(set([t.lower() for t in i.tags])) if hasattr(
                        i, "tags") else []

                    e = Entry(p_name, start, end, dur, tags)
                    add_dur = not (p_name == "Holidays" or
                                   (hasattr(i, "tags") and "Pause" in i.tags))
                    if add_dur:
                        self.project_seconds[p_name] += dur.total_seconds()

                    self.days[start.date()].append(e)
Exemplo n.º 30
0
 def postpone(self, dlt_time, ky_word):
     """
     this function edits hour part of datetime object
     :param dlt_time: date-time object to edit
     :param dlt_time: delta-time of old and new time
     :param ky_word: represent type of dlt_time if
      it is hour, day, week or month
     """
     if ky_word == 'hour':
         self.work_datetime = self.work_datetime + tdelta(seconds=dlt_time *
                                                          3600)
     elif ky_word == 'day':
         self.work_datetime = self.work_datetime + tdelta(days=dlt_time)
     elif ky_word == 'week':
         self.work_datetime = self.work_datetime + tdelta(weeks=dlt_time)
     elif ky_word == 'month':
         self.work_datetime = self.work_datetime + tdelta(days=dlt_time *
                                                          30)
     self.eisenhower_priority()
     return self.work_datetime
Exemplo n.º 31
0
def add_hours(date, number):
    """

    :param date:
    :type date: datetime.date or datetime.datetime
    :param number:
    :return:
    """
    if not hasattr(date, "time"):
        date = datetime.datetime.combine(date, datetime.datetime.min.time())
    return date + tdelta(hours=number)
Exemplo n.º 32
0
def is_valid_session():
    """Validate a session."""
    stale_threshold = dtime.now() - tdelta(minutes=config.TIMEOUT_MINUTES)
    try:
        too_old = (session['last_check'] < stale_threshold)
        if session['username'] in users.ALLOWED and not too_old:
            return True
    except KeyError as err:
        pass
    # bad session if we fell through
    return False
Exemplo n.º 33
0
class FilesView(MyBaseView):
    column_list = [
        'id', 'name', 'sha1', 'date_b', 'status_f', 'score', 'message',
        'evals_count'
    ]
    column_sortable_list = [
        'id', 'name', 'sha1', 'date_b', 'status_f', 'score', 'message',
        'evals_count'
    ]
    column_exclude_list = [
        'uuid_f', 'evals_len', 'results', 'md5', 'mtype', 'exec_time',
        'expect_sandbox', 'hash'
    ]
    column_details_list = [
        'id', 'name', 'mtype', 'md5', 'sha1', 'hash', 'date_b', 'exec_time',
        'status_f', 'score', 'message', 'results', 'evals_count', 'evals'
    ]
    column_export_list = [
        'id', 'name', 'mtype', 'md5', 'sha1', 'hash', 'date_b', 'exec_time',
        'status_f', 'score', 'message', 'evals_count'
    ]
    column_export_exclude_list = ['evals', 'results']
    column_formatters_export = {}
    column_searchable_list = []
    column_default_sort = ('date_b', True)
    column_filters = ['name', 'mtype', 'sha1', 'score', 'evals_count']
    column_formatters_export = dict(
        score=fmt_render_score,
        date_b=lambda v, c, m, p: str(getattr(m, p)),
        exec_time=lambda v, c, m, p: str(tdelta(seconds=getattr(m, p))))
    column_formatters = dict(evals_count=fmt_counts,
                             evals=macro('render_evals_cname'),
                             exec_time=fmt_elapsed_time_secs,
                             name=fmt_file_details,
                             score=macro('render_score'),
                             status_f=fmt_text_bold,
                             message=macro('render_message'),
                             results=fmt_file_results)
    column_labels = dict(id='Id',
                         name='Filename',
                         mtype='MIME Type',
                         md5='MD5 Hash',
                         sha1='SHA1 Hash',
                         hash='SHA256 Hash',
                         uuid_f='UUID',
                         status_f='Status',
                         date_b='Status Date',
                         exec_time='Elapsed Time',
                         score='Is Malicious?',
                         expect_sandbox='Expect Sandbox?',
                         message='Message',
                         evals_count='# of Evaluations',
                         evals='List of Evaluations',
                         results='Results')
Exemplo n.º 34
0
def retrieve_telstatus(telescope):
    client = pymongo.MongoClient('192.168.1.101', 27017)
    db = client.vysos

    telstatus = {}
    for telescope in ['V20', 'V5']:
        results = db[f'{telescope}status'].find(limit=1, sort=[('date', pymongo.DESCENDING)])
        if results.count() > 0:
            telstatus[telescope] = results.next()
            try:
                if telstatus[telescope]['slewing'] is True:
                    telstatus[telescope]['status'] = 'Slewing'
                elif telstatus[telescope]['tracking'] is True:
                    telstatus[telescope]['status'] = 'Tracking'
                elif telstatus[telescope]['park'] is True:
                    telstatus[telescope]['status'] = 'Parked'
                else:
                    telstatus[telescope]['status'] = 'Stationary'
            except:
                telstatus[telescope]['status'] = 'Unknown'
            
            if 'RA' in telstatus[telescope] and 'DEC' in telstatus[telescope]:
                coord = SkyCoord(telstatus[telescope]['RA'],
                                 telstatus[telescope]['DEC'], unit=u.deg)
                telstatus[telescope]['RA'], telstatus[telescope]['DEC'] = coord.to_string('hmsdms', sep=':', precision=0).split()
        else:
            telstatus[telescope] = {'date': dt.utcnow()-tdelta(365),
                                    'status': 'Unknown',
                                    'connected': False}
        ## Format Values and fill in missing keys
        if 'alt' not in telstatus[telescope].keys():
            telstatus[telescope]['altstr'] = ''
        else:
            telstatus[telescope]['altstr'] = '{:.1f} deg'.format(telstatus['V20']['alt'])
        if 'az' not in telstatus[telescope].keys():
            telstatus[telescope]['azstr'] = ''
        else:
            telstatus[telescope]['azstr'] = '{:.1f} deg'.format(telstatus['V20']['az'])
        if 'RA' not in telstatus[telescope].keys():
            telstatus[telescope]['RAstr'] = ''
        else:
            telstatus[telescope]['RAstr'] = '{}'.format(telstatus['V20']['RA'])
        if 'Dec' not in telstatus[telescope].keys():
            telstatus[telescope]['Decstr'] = ''
        else:
            telstatus[telescope]['Decstr'] = '{}'.format(telstatus['V20']['Dec'])
        telstatus[telescope]['age'] = (dt.utcnow() - telstatus[telescope]['date']).total_seconds()/60.
    client.close()

    return telstatus
Exemplo n.º 35
0
    def eisenhower_priority(self):
        """
        this method sets priority and time of notification based on importance attribute of work
        notification repeat:
        priority 1 -->  every 5 minutes during the day
        priority 2 --> just in time
        priority 3 --> at the end of the day (18:00:00)
        priority 4 --> at the end of the week (sunday)
            :return: a tuple of priority and notification time
        """
        if self.status != 'done':
            if self.importance and self.urgency:
                self.priority = 1
                self.time_ntf = self.work_datetime
                return self.time_ntf
            elif not self.importance and self.urgency:
                self.priority = 2
                self.time_ntf = self.work_datetime
                return self.time_ntf

            elif self.importance and not self.urgency:
                self.priority = 3
                if self.work_datetime.hour < 18:
                    hours = (18 - self.work_datetime.hour)
                else:
                    hours = 0
                self.time_ntf = self.work_datetime + tdelta(seconds=hours *
                                                            3600)
                return self.time_ntf

            elif not self.importance and not self.urgency:
                self.priority = 4
                dys = (6 - self.work_datetime.weekday())
                self.time_ntf = self.work_datetime + tdelta(days=dys)
                return self.time_ntf
        else:
            return 0
Exemplo n.º 36
0
 def xrate_to_aud(self, at_date, from_currency):
     """Uses AlphaVantage to find X rate from currency to AUD on date"""
     # TODO Find more elegant solution than wait 15 seconds
     if from_currency == "AUD":
         exchange_rate = 1
     else:
         url = "https://www.alphavantage.co/query?function=FX_DAILY&"\
               "from_symbol={}&to_symbol=AUD&outputsize=full&apikey={}"\
               .format(from_currency, self.av_key)
         fail = True
         attempt = 0
         while (fail is True) and (attempt < 10):
             try:
                 r = requests.get(url)
                 time_series = json.loads(r.text)["Time Series FX (Daily)"]
                 fail = False
                 logging.info("Time series retreival was successful")
             except:
                 fail = True
                 time.sleep(10)
                 attempt += 1
                 logging.warning(
                     "Time series unsuccessful. Attempt {}".format(attempt))
         check_date_strings = [
             (at_date - tdelta(days=1)).strftime("%Y-%m-%d"),
             (at_date + tdelta(days=1)).strftime("%Y-%m-%d"),
             at_date.strftime("%Y-%m-%d")
         ]
         for check_date in check_date_strings:
             try:
                 exchange_rate = time_series[check_date]['4. close']
             except:
                 pass
     logging.debug("Exchange rate from {} to AUD on {} is {}".format(
         from_currency, at_date, exchange_rate))
     return float(exchange_rate)
Exemplo n.º 37
0
    def dump_gfdltrk_fort12(self, outfile=None, fhr=0):
        """
        Dump the fort.12 file expected by the gfdl tracker, for the given
        `fhr' (default 0). This consists of a single line like so:
        AOML 01L ONEARW01L 20050801 0600 167N  400W -99 -99  998 -999 -999 -9 -99 -999 -999 -999 -999 X
        [center]   [storm name]     [hhmm]     [cenlon] [wind spd]        [rest will all be -9* (ignored)]
             [storm id]     [ymd]       [cenlat]   [wind dir] [mslp]
               
        See also: http://www.emc.ncep.noaa.gov/mmb/data_processing/tcvitals_description.htm
        """
        center = self.originating_center if self.originating_center else "ACME"
        basin = self.basin if self.basin else "99"
        storm_number = self.storm_number if self.storm_number else 0
        storm_name = self.storm_name if self.storm_name else "  UNNAMED"
        storm_name = storm_name.rjust(9)
        startDate = to_datetime(self.start_date) 
        fcstDate = startDate + tdelta(hours=fhr)
        fcstYMD = "{0:%Y%m%d}".format(fcstDate)
        fcstHHMM = "{0:%H%M}".format(fcstDate)
        trkentry = self.fcst_date_dict[fcstDate]
        latstr = str(abs(int(round(trkentry.lat*10,0))))
        lonstr = str(abs(int(round(trkentry.lon*10,0))))
        if trkentry.lat < 0 : latstr += "S"
        else: latstr += "N"
        if trkentry.lon < 0: lonstr += "W"
        else: lonstr += "E"
        latstr = latstr.rjust(4)
        lonstr = lonstr.rjust(5)
        
        windspeed_kts = trkentry.maxwind_value # TODO : assuming maxwind is in kts but this is not enforced by object
        windspeed_mps = windspeed_kts * 0.51444444444
        windspeed_str = str(int(round(windspeed_mps*10,0))).rjust(3)
        mslp = str(int(round(trkentry.mslp_value,0))).rjust(4)
        
        #import pdb ;pdb.set_trace()
        dataType = "03" # fcst data
        atcfName = "9999" #5
        s = "{center} {snum:02d}{basinId} {name} {fdate:%Y%m%d %H%M} {latstr} {lonstr}"\
            " {spd} -99 {mslp} -999 -999 -9 -99 -999 -999 -999 -999 X"\
            .format(center=center, snum=storm_number, basinId=basin, 
                    name=storm_name, fdate=fcstDate,
                    latstr=latstr, lonstr=lonstr, spd=windspeed_str, mslp=mslp)
        
        if outfile: 
            with open(outfile, 'w') as f:
                f.write(s + "\n")

        return s
Exemplo n.º 38
0
    def get(self, telescope):
        tlog.app_log.info('Get request for ListOfNights recieved')
        telescope = telescope.strip('/')

        ## Create Telescope Object
        config_file = os.path.join(os.path.expanduser('~'), '.{}.yaml'.format(telescope))
        tel = IQMon.Telescope(config_file)
        telescopename = tel.name

        client = MongoClient(tel.mongo_address, tel.mongo_port)
        db = client[tel.mongo_db]
        collection = db[tel.mongo_collection]

        first_date_string = sorted(collection.distinct("date"), reverse=False)[0]
        first_date = dt.strptime('{} 00:00:00'.format(first_date_string), '%Y%m%dUT %H:%M:%S')
        oneday = tdelta(1, 0)

        tlog.app_log.info('  Building date_list')
        date_list = []
        thisdate = dt.utcnow()
        while thisdate >= first_date:
            date_list.append(thisdate.strftime('%Y%m%dUT'))
            thisdate -= oneday
        tlog.app_log.info('  Done')

        night_plot_path = os.path.abspath('/var/www/nights/')

        tlog.app_log.info('  Looping over date_list')
        nights = []
        for date_string in date_list:
            night_info = {'date': date_string }

            night_graph_file = '{}_{}.png'.format(date_string, telescope)
            if os.path.exists(os.path.join(night_plot_path, night_graph_file)):
                night_info['night graph'] = night_graph_file

            night_info['n images'] = collection.find( {"date":date_string} ).count()

            nights.append(night_info)
        tlog.app_log.info('  Done')

        tlog.app_log.info('  Rendering ListOfNights')
        self.render("night_list.html", title="{} Results".format(telescopename),\
                    telescope = telescope,\
                    telescopename = telescopename,\
                    nights = nights,\
                   )
        tlog.app_log.info('  Done')
Exemplo n.º 39
0
    def gridClickHandler(self):
        GTI = gameTrackerIndexes
        selectedRow = self.gameTracker.selectedItems()
        rowNumber = self.gameTracker.selectedIndexes()[0].row()
        CSV_SELECTION = list(CSV_READER)[rowNumber]
        self.SelectionNameStat.setText(selectedRow[GTI.FILE_NAME].text())
        self.SelectionModeStat.setText(selectedRow[GTI.MODE].text())

        self.SelectionPPSStat.setText(CSV_SELECTION['pps'])
        self.SelectionTimeStat.setText(
            str(tdelta(0, (float(CSV_SELECTION['time']) / self.framerate))
                ).rstrip('0').ljust(7, '0'))
        self.selectionScoreName.setText('Score:')
        self.selectionScoreStat.setText(selectedRow[GTI.SCORE].text())
        self.SelectionLinesStat.setText(selectedRow[GTI.LINES].text())
        self.SelectionPiecesStat.setText(selectedRow[GTI.PIECES].text())
Exemplo n.º 40
0
    def set_date_segment(self):
        """
        Creates the string segment for the current UTC date

        :return f"{year}{doy}{hour}": String with the format YYDOYHH
            (year, day of the year, hour)
        """
        minutes2save = 47  # 23.5  # Estimated time it takes to save each file
        time_file = self.utc_time - tdelta(minutes=minutes2save)
        year = time_file.strftime(
            '%y')  # Year without century as a decimal number [00,99]
        doy = time_file.strftime(
            '%j')  # Day of the year as a decimal number [001,366]
        hour = time_file.strftime(
            "%H")  # Hour (24-hour clock) as a decimal number [00,23]
        return f"{year}{doy}{hour}"  # Date segment
Exemplo n.º 41
0
 def __iter__(self):
     numDays = (self.e_dt - self.s_dt).days
     count = 0
     titleSet = set()
     sys.stderr.write("iterator started... \n" )
     for x in range(numDays+1):
         fileDate = self.s_dt + tdelta(days = x)
         filename = fileDate.strftime("%Y-%m-%d")+'.txt'
         if os.path.isfile(newsPre+filename):
             sys.stderr.write("file processing: " + filename +'\r'),
             for item in parsefile(filename,self.newsDIR,titleSet,self.per,self.loc,self.org,self.other):
                 self.ind2obj[count] = item[1]
                 yield item[0]
                 count +=1
     sys.stderr.write('\n')
     sys.stderr.write("final count = " + str(count) + '\n')
Exemplo n.º 42
0
def loop_over_nights():
    date = dt(2018, 1, 1, 1, 0, 0, 0)
    end = dt(2018, 12, 31, 2, 0, 0, 0)

    ##-------------------------------------------------------------------------
    ## Create Logger Object
    ##-------------------------------------------------------------------------
    l = logging.getLogger('make_nightly_plots')
    l.setLevel(logging.DEBUG)
    ## Set up console output
    LogConsoleHandler = logging.StreamHandler()
    LogConsoleHandler.setLevel(logging.INFO)
    LogFormat = logging.Formatter('%(asctime)23s %(levelname)8s: %(message)s')
    LogConsoleHandler.setFormatter(LogFormat)
    l.addHandler(LogConsoleHandler)

    while date < end:
        make_plots(date.strftime('%Y%m%dUT'), 'V20', l)
        date += tdelta(1,0)
Exemplo n.º 43
0
def build(ax1, servicio, unit):
    fechas, consumos = zip(*sorted(servicio.items()))

    f = interp1d(date2num(fechas), consumos)          # generate interpolation func
    x = drange(fechas[0], fechas[-1], tdelta(days=1)) # generate range of points

    ax1.plot_date(fechas, consumos, 'g-')       # plot original data
    ax1.set_ylabel('Consumo en ' + unit, color='g')

    ax2 = ax1.twinx()
    ax2.plot(x, np.gradient(f(x)), 'b-')
    ax2.set_ylabel(unit + ' / dia', color='b')       # plot rate of change

    dt = date2num((fechas[0], fechas[-1]))
    dc = (consumos[-1] - consumos[0]) / (date2num(fechas[-1]) - date2num(fechas[0]))

    ax3 = ax1.twinx()
    ax3.plot(dt, (dc, dc), 'r-')
    ax3.set_ylabel(unit + '/dia periodo', color='r') # plot rate of change
Exemplo n.º 44
0
    def get(self, telescope, subject):
        tlog.app_log.info('Get request for ListOfImages recieved')

        ## Create Telescope Object
#         tlog.app_log.info('  Creating telescope object')
#         config_file = os.path.join(os.path.expanduser('~'), '.{}.yaml'.format(telescope))
        tel = Telescope(telescope)
        telescopename = tel.name
        tlog.app_log.info('  Done.')

        tlog.app_log.info('  Linking to mongo')
        client = MongoClient(tel.mongo_address, tel.mongo_port)
        tlog.app_log.info('  Connected to client.')
        db = client[tel.mongo_db]
        collection = db[tel.mongo_collection]
        tlog.app_log.info('  Retrieved collection.')

        tlog.app_log.info('  Getting list of images from mongo')

        ##---------------------------------------------------------------------
        ## If subject is formatted like a date, then get images from a date
        ##---------------------------------------------------------------------
        if re.match('\d{8}UT', subject):
            start = dt.strptime(subject, '%Y%m%dUT')
            end = start + tdelta(1)
            querydict = {"date": {"$gt": start, "$lt": end},
                         "telescope": tel.name}
            image_list = [entry for entry in\
                          collection.find(querydict).sort(\
                          [('date', pymongo.ASCENDING)])]
            tlog.app_log.info('  Got list of {} images for night.'.format(len(image_list)))
        ##---------------------------------------------------------------------
        ## If subject matches a target name, then get images for that target
        ##---------------------------------------------------------------------
        else:
            tlog.app_log.info('    Getting list of target names from mongo')
            target_name_list = sorted(collection.distinct("target name"))
            if subject in target_name_list:
                tlog.app_log.info('    Getting list of image list for {} from mongo'.format(subject))
                image_list = [entry for entry in\
                              collection.find({"target name":subject}).sort(\
                              [('date', pymongo.DESCENDING)])]
                tlog.app_log.info('  Got list of {} images for target.'.format(len(image_list)))
        ##---------------------------------------------------------------------
        ## If subject is not a date or target, then render a list of targets
        ##---------------------------------------------------------------------
            else:
                image_list = []
                self.write('<html><head><style>')
                self.write('table{border-collapse:collapse;margin-left:auto;margin-right:auto;}')
                self.write('table,th,td{border:1px solid black;vertical-align:top;text-align:left;')
                self.write('padding-top:5px;padding-right:5px;padding-bottom:5px;padding-left:5px;}')
                self.write('</style></head>')
                if (len(subject) > 0) and not re.match('[tT]argets', subject):
                    self.write('<p style="text-align:center;">Could not find {} in target list:</p>'.format(subject))
                self.write('<table style="border:1px solid black;">')
                self.write('<tr><th>Target</th><th>n Images</th>')
                tlog.app_log.info(f"Listing all targets")
                for target in target_name_list:
                    target_images = [entry for entry in collection.find( { "target name": target } ) ]
                    self.write('<tr><td><a href="{0}">{0}</a></td><td>{1:d}</td></tr>'.format(target, len(target_images)))
                self.write('</table></html>')

        if tel.units_for_FWHM == u.arcsec:
            FWHM_multiplier = tel.pixel_scale.value
        elif tel.units_for_FWHM == u.pix:
            FWHM_multiplier = 1.0
        else:
            FWHM_multiplier = 1.0

        if len(image_list) > 0:
            tlog.app_log.info('  Determining Flags')
            flags = []
            for i,image in enumerate(image_list):
                flags.append({'FWHM': False,
                              'ellipticity': False,
                              'pointing error': False,
                              'zero point': False,
                             })
                try:
                    flags[i]['FWHM'] = image['FWHM_pix'] > tel.FWHM_limit_pix.value
                except:
                    pass
                try:
                    flags[i]['ellipticity'] = image['ellipticity'] > tel.ellipticity_limit
                except:
                    pass
                try:
                    flags[i]['pointing error'] = image['perr_arcmin'] > tel.pointing_error_limit
                except:
                    pass
            tlog.app_log.info('  Rendering ListOfImages')
            self.render("image_list.html", title="{} Results".format(telescopename),\
                        telescope = telescope,\
                        telescopename = telescopename,\
                        subject = subject,\
                        image_list = image_list,\
                        FWHM_units = tel.units_for_FWHM.to_string(),\
                        FWHM_multiplier = FWHM_multiplier,\
                        flags=flags,\
                       )
            tlog.app_log.info('  Done.')
Exemplo n.º 45
0
def generate_weather_table():
    now = dt.now()
    nowut = now + tdelta(0, 10*60*60)
    weatherdata = retrieve_weather(lookbackdays=0)[-1]
    condition, color = get_conditions(weatherdata)
    weather_data_age = (nowut - weatherdata['date']).total_seconds()
    if weather_data_age < 60:
        weather_str = {True: 'Safe', False: 'Unsafe'}[weatherdata['safe']]
        if weatherdata['safe'] is True:
            weather_status = html.Span(weather_str, style={'color': 'green'})
        else:
            weather_status = html.Span(weather_str, style={'color': 'red'})
    else:
        weather_status = html.Span('Unsafe', style={'color': 'red'})

    telstatus = retrieve_telstatus('V20')
    sun, moon = update_astronomy()
    sunstrings = [f"Next sunrise is at {sun['rise'].strftime('%Y/%m/%d %H:%M:%S UT')}",
                  f"Next sunset is at {sun['set'].strftime('%Y/%m/%d %H:%M:%S UT')}"]
    if sun['rise'] > sun['set']:
        sunstrings.reverse()


    paths = {'Drobo': os.path.join('/', 'Volumes', 'DataCopy'),\
             'macOS': os.path.expanduser('~'),\
             'DroboPro': os.path.join('/', 'Volumes', 'MLOData')}
    disks = {}
    for disk in paths.keys():
        if os.path.exists(paths[disk]):
            size_GB, avail_GB, pcnt_used = free_space(paths[disk])
            disks[disk] = [size_GB, avail_GB, pcnt_used]

    tdcw300 = styles['tdc'].copy()
    tdcw300['width'] = '300px'
    tdrw200 = styles['tdc'].copy()
    tdrw200['width'] = '200px'
    tdlw150 = styles['tdl'].copy()
    tdlw150['width'] = '150px'
    tdcw250 = styles['tdc'].copy()
    tdcw250['width'] = '250px'

    tdcw200 = styles['tdc'].copy()
    tdcw200['width'] = '200px'
    tdcw150 = styles['tdc'].copy()
    tdcw150['width'] = '150px'
    tdcw400 = styles['tdc'].copy()
    tdcw400['width'] = '400px'

    weather_table = html.Table([
                    html.Tr([
                             html.Td(html.Span('Time', style={'font-weight': 'bold'}), style=tdcw300),
                             html.Td(html.Span('Weather', style={'font-weight': 'bold'}), style=tdrw200),
                             html.Td(html.Span(weather_status, style={'font-weight': 'bold'}), style=tdlw150),
                             html.Td(html.Span('Disks', style={'font-weight': 'bold'}), style=tdcw250),
                            ]),
                    html.Tr([
                             html.Td(now.strftime('%Y/%m/%d %H:%M:%S HST'), style=styles['tdl']),
                             html.Td('Ambient Temperature', style=styles['tdr']),
                             html.Td(f"{weatherdata['temp']:.1f} C, {weatherdata['temp']*1.8+32.:.1f} F", style=styles['tdl']),
                             html.Td([html.Span('MLOData', style={'font-family': 'Courier, monospace'}),
                                      f": {disks['DroboPro'][1]:.0f}GB free ({disks['DroboPro'][2]:.0f}% full)"],  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(nowut.strftime('%Y/%m/%d %H:%M:%S UT'), style=styles['tdl']),
                             html.Td('Cloudiness', style=styles['tdr']),
                             html.Td([html.Span(condition['cloud'], style={'color': color['cloud']}),
                                      html.Span(' ({0:.1f} F)'.format(weatherdata['clouds']*1.8+32.), style=styles['p']),
                                     ], style=styles['tdl']),
                             html.Td([html.Span('DataCopy', style={'font-family': 'Courier, monospace'}),
                                      f": {disks['Drobo'][1]:.0f}GB free ({disks['Drobo'][2]:.0f}% full)"],  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(f"It is currently {sun['now']} (Sun alt = {sun['alt']:.0f})", style=styles['tdl']),
                             html.Td('Wind Speed', style=styles['tdr']),
                             html.Td([html.Span(condition['wind'], style={'color': color['wind']}),
                                      html.Span(' ({0:.1f} kph)'.format(weatherdata['wind']), style=styles['p']),
                                     ], style=styles['tdl']),
                             html.Td([html.Span('macOS', style={'font-family': 'Courier, monospace'}),
                                      f": {disks['macOS'][1]:.0f}GB free ({disks['macOS'][2]:.0f}% full)"],  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(f"A {moon['phase']:.0f}% illuminated moon is {moon['now']}", style=styles['tdl']),
                             html.Td('Gusts', style=styles['tdr']),
                             html.Td([html.Span(condition['gust'], style={'color': color['gust']}),
                                      html.Span(' ({0:.1f} kph)'.format(weatherdata['gust']), style=styles['p']),
                                     ], style=styles['tdl']),
                             html.Td('',  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(sunstrings[0], style=styles['tdl']),
                             html.Td('Rain', style=styles['tdr']),
                             html.Td([html.Span(condition['rain'], style={'color': color['rain']}),
                                      html.Span(' ({0:.0f})'.format(weatherdata['rain']), style=styles['p']),
                                     ], style=styles['tdl']),
                             html.Td('',  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(sunstrings[1], style=styles['tdl']),
                             html.Td('Weather Data Age', style=styles['tdr']),
                             html.Td('{:.1f}s'.format(weather_data_age), style=styles['tdl']),
                             html.Td('',  style=styles['tdr']),
                            ]),
                    html.Tr([
                             html.Td(html.Img(src='http://127.0.0.1:80/static/weather.png', width=800), colSpan=4, style=styles['tdc']),
                            ]),
                   ], style=styles['table'])

    telstatus_table = html.Table([
                      html.Tr([
                               html.Td(html.Span('Status', style={'font-weight': 'bold'}), style=tdcw200),
                               html.Td(html.Span('VYSOS-5', style={'font-weight': 'bold'}), style=tdcw150),
                               html.Td(html.Span('VYSOS-20', style={'font-weight': 'bold'}), style=tdcw150),
                               html.Td(html.Span('ATLAS All Sky Image', style={'font-weight': 'bold'}), style=tdcw400),
                              ]),
                      html.Tr([
                               html.Td('ACP Connected', style=styles['tdr']),
                               html.Td('{}'.format(telstatus['V5']['connected']), style=styles['tdl']),
                               html.Td('{}'.format(telstatus['V20']['connected']), style=styles['tdl']),
                               html.Td(html.Img(src='http://www.fallingstar.com/weather/mlo/latest_bw400.jpg', width=400), rowSpan=8, style=styles['tdc']),
                              ]),
                      html.Tr([
                               html.Td('Status', style=styles['tdr']),
                               html.Td('{}'.format(telstatus['V5']['status']), style=styles['tdl']),
                               html.Td('{}'.format(telstatus['V20']['status']), style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('Alt', style=styles['tdr']),
                               html.Td(telstatus['V5']['altstr'], style=styles['tdl']),
                               html.Td(telstatus['V20']['altstr'], style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('Az', style=styles['tdr']),
                               html.Td(telstatus['V5']['azstr'], style=styles['tdl']),
                               html.Td(telstatus['V20']['azstr'], style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('Target RA', style=styles['tdr']),
                               html.Td(telstatus['V5']['RAstr'], style=styles['tdl']),
                               html.Td(telstatus['V20']['RAstr'], style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('Target Dec', style=styles['tdr']),
                               html.Td(telstatus['V5']['Decstr'], style=styles['tdl']),
                               html.Td(telstatus['V20']['Decstr'], style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('ACP Data Age', style=styles['tdr']),
                               html.Td('{:.1f} min'.format(telstatus['V5']['age']), style=styles['tdl']),
                               html.Td('{:.1f} min'.format(telstatus['V20']['age']), style=styles['tdl']),
                              ]),
                      html.Tr([
                               html.Td('', style=styles['tdr']),
                               html.Td('', style=styles['tdl']),
                               html.Td('', style=styles['tdl']),
                              ]),
                     ], style=styles['table'])


    components = [weather_table,
                  html.Hr(),
                  telstatus_table,
                  ]
    return components
def get_weather(logger, robust=True):
    logger.info('Getting Weather status from PANOPTES')

    now = dt.utcnow()
    end = now + tdelta(0,900)
    start = end - tdelta(0,3600)

    pan001_client = pymongo.MongoClient('192.168.1.50', 27017)
    pan001_db = pan001_client.panoptes
    pan001_weather = pan001_db.weather
    pan001_data = [x for x in pan001_weather.find({'date': {'$gt': start, '$lt': end}},
                                    sort=[('date', pymongo.DESCENDING)])]
    latest = pan001_data[0]

    weatherdoc = {"date": latest['date'],
                  "querydate": now,
                  "clouds": float(latest['data']['sky_temp_C']),
                  "temp": float(latest['data']['ambient_temp_C']),
                  "wind": float(latest['data']['wind_speed_KPH']),
                  "gust": float(latest['data']['wind_speed_KPH']),
                  "rain": int(latest['data']['rain_frequency']),
                  "light": 0,
                  "switch": latest['data']['safe'],
                  "safe": latest['data']['safe'],
                 }


    threshold = 30
    age = (weatherdoc["querydate"] - weatherdoc["date"]).total_seconds()
    logger.debug('Data age = {:.1f} seconds'.format(age))
    if age > threshold:
        logger.warning('Age of weather data ({:.1f}) is greater than {:.0f} seconds'.format(
                       age, threshold))

    logger.info('Saving weather document')
    logger.info('Connecting to mongoDB')
    client = pymongo.MongoClient('192.168.1.101', 27017)
    db = client.vysos
    weather = db.weather

    try:
        inserted_id = weather.insert_one(weatherdoc).inserted_id
        logger.info("  Inserted document with id: {}".format(inserted_id))
    except:
        e = sys.exc_info()[0]
        logger.error('Failed to add new document')
        logger.error(e)

    client.close()

    # Example sld
    # 2017-02-25 17:27:31.00 C K    3.8    8.8    8.8    1.0  -1  100.0  25 2 2 00000 042791.72744 0 1 3 1 1 1
    # From Boltwood manual:
    # Date       Time        T V   SkyT   AmbT   SenT   Wind Hum  DewPt Hea R W Since  Now() Day's c w r d C A
    # 2005-06-03 02:07:23.34 C K  -28.5   18.7   22.5   45.3  75   10.3   3 0 0 00004 038506.08846 1 2 1 0 0 0
    # NowDays = date/time given as the VB6 Now() function result (in days) when Clarity II last wrote this file
    tref1 = dt.strptime('2005-06-03 02:07:23.34', '%Y-%m-%d %H:%M:%S.%f')
    dtref1 = 038506.08846
    to1 = tref1 - tdelta(days=dtref1)
    tref2 = dt.strptime('2017-02-25 17:27:31.00', '%Y-%m-%d %H:%M:%S.%f')
    dtref2 = 042791.72744
    to2 = tref2 - tdelta(days=dtref2)
    to = to2

    sld_file = os.path.expanduser('~/V20Data/aag_sld.dat')
    logger.info(f'Writing Single Line Data File to {sld_file}')
    local_time_str = dt.strftime(weatherdoc['date']-tdelta(0,10*3600), '%Y-%m-%d %H:%M:%S.00')
    SkyT = weatherdoc['clouds']
    AmbT = weatherdoc['temp']
    SenT = weatherdoc['temp'] # using ambient
    Wind = weatherdoc['wind']
    Hum = -1
    DewPt = 100.0
    Hea = 25
    R = {'Dry':0, 'Wet':1, 'Rain':1, 'Unknown':1}[latest['data']['rain_condition']]
    W = {'Dry':0, 'Wet':1, 'Rain':1, 'Unknown':1}[latest['data']['rain_condition']]
    Since = 00000
    NowDays = (weatherdoc['date']-tdelta(0,10*3600)-to).total_seconds()/3600/24
    c = {'Unknown':0, 'Very Cloudy':3, 'Cloudy':2, 'Clear':1}[latest['data']['sky_condition']]
    w = {'Unknown':0, 'Very Windy':3, 'Windy':2, 'Calm':1}[latest['data']['wind_condition']]
    r = {'Unknown':0, 'Rain':3, 'Wet':2, 'Dry':1}[latest['data']['rain_condition']]
    d = 1
    C = {True:0 , False:1}[latest['data']['safe']]
    A = C
    sld = f"{local_time_str:22s} C K {SkyT:6.1f} {AmbT:6.1f} {SenT:6.1f} {Wind:6.1f} {Hum:3.0f} {DewPt:6.1f} {Hea:3d} {R:1d} {W:1d} {Since:05d} {NowDays:012.5f} {c:1d} {w:1d} {r:1d} {d:1d} {C:1d} {A:1d}"
    logger.info("  Date       Time        T V   SkyT   AmbT   SenT   Wind Hum  DewPt Hea R W Since  Now() Day's c w r d C A")
    logger.info(f"  {sld}")
    if os.path.exists(sld_file):
        os.remove(sld_file)
    with open(sld_file, 'x') as sldFO:
        sldFO.write(f"{sld}\n")
    logger.info(f'  Done')
    e_dt = dt.strptime(sys.argv[3],"%Y-%m-%d")
    tweetPre = sys.argv[4]
    k = int(sys.argv[5])
    t_topK = int(sys.argv[6])
    dataop = sys.argv[7]
    outfile = codecs.open(sys.argv[8], 'w', encoding = 'utf-8')
    knnNum = 30

############## readfile news. Two copies: lines (for scikit-learn's convenience) and objects (for later print use)
    numDays = (e_dt - s_dt).days
#    k = 20*(numDays+1)
    count = 0
    lines = []
    ind2obj = {}
    for x in range(numDays+1):
            fileDate = s_dt + tdelta(days = x)
            dtpure = fileDate.strftime("%Y-%m-%d")
            filename = newsPre + dtpure +".txt"
            print(filename)
            if os.path.isfile(filename):
                file = codecs.open(filename, encoding = 'utf-8')
                count = readfile(file,dataop,count,ind2obj,dtpure,lines)
    vocab = None
############# clustering on news
    X,vectorizer = getVec(lines,vocab)
    #clus2doc index of newsID
    clusModel,clus2doc,knn_graph = getCluster(X.toarray(),k,knnNum,opts)

############# print cluster + rank tweets    
    # place holder
    order_centroids=None
Exemplo n.º 48
0
 def FillSummaryMatrix(self):
     print "\nExtracting Column Info for CMS sites\n"
     prog = ProgressBar(0, 100, 77)
     for sitename in self.matrices.xmlInfo:
         prog.increment(100./len(self.matrices.xmlInfo))
         if not self.matrices.columnValues.has_key(sitename): # add site if not already there
             self.matrices.columnValues[sitename] = {}
         for col in self.cinfo.urls:
             if not self.matrices.xmlInfo[sitename].has_key(col) or col == 'Downtimes_top':
                 continue
 
             # set to null (default) values
             for iday in daterange(self.tinfo.today - tdelta(60), self.tinfo.today + tdelta(1)):
                 idaystamp = iday.strftime("%Y-%m-%d")
                 if not self.matrices.columnValues[sitename].has_key(idaystamp):
                     self.matrices.columnValues[sitename][idaystamp] = {}
                 if not self.matrices.columnValues[sitename][idaystamp].has_key(col):
                     self.matrices.columnValues[sitename][idaystamp][col] = {}
                 nullValues = {}
                 nullValues['Status'] = 'n/a'
                 nullValues['Color'] = 'white'
                 nullValues['URL'] = ' '
                 nullValues['validity'] = 0
                 self.matrices.columnValues[sitename][idaystamp][col] = nullValues
 
             items = self.matrices.xmlInfo[sitename][col].keys()
             items.sort()
             for coldate in items: # loop over each time/date combination
                 xmltime = datetime.datetime(*time.strptime(self.matrices.xmlInfo[sitename][col][coldate]['Time'], "%Y-%m-%d %H:%M:%S")[0:6])
                 xmlendtime = datetime.datetime(*time.strptime(self.matrices.xmlInfo[sitename][col][coldate]['EndTime'], "%Y-%m-%d %H:%M:%S")[0:6])
 
                 startxmldatetmp = xmltime.strftime("%Y-%m-%d 00:00:00")
                 startxmldate = datetime.datetime(*time.strptime(startxmldatetmp, "%Y-%m-%d %H:%M:%S")[0:6])
 
                 EndTXML = True
                 i = 0
                 while ( EndTXML ):
                     d = datetime.timedelta(i) # convert i to number of days
                     i += 1
                     dayloop = startxmldate + d
                     dayloopstamp = dayloop.strftime("%Y-%m-%d")
                     dayloopstamp2 = dayloop.strftime("%Y-%m-%d 00:00:00")
                     looptime = datetime.datetime(*time.strptime(dayloopstamp2, "%Y-%m-%d %H:%M:%S")[0:6])
                     if dayloop > self.tinfo.today:
                         EndTXML = False
                         continue
                     diff1  = xmltime-looptime
                     diff1s = (diff1.days*86400+diff1.seconds)
                     diff2  = xmlendtime-looptime
                     diff2s = (diff2.days*86400+diff2.seconds)
                     diff3  = xmlendtime-xmltime
                     diff3s = (diff3.days*86400+diff3.seconds)
                     if diff1s<=0 and diff2s>0:
                         if diff2s>=86400: validity=86400
                         else: validity=diff2s
                     if diff1s>0 and diff1s<86400:
                         if diff2s>86400: validity=86400-diff1s
                         else: validity=diff3s
                     if diff1s<0 and diff2s<=0:
                         EndTXML=False
                         continue
                       
                     if self.cinfo.colorCodes[col][self.matrices.xmlInfo[sitename][col][coldate]['COLOR']] == "green":
                         status=self.matrices.xmlInfo[sitename][col][coldate]['Status']
                         statusu=self.matrices.xmlInfo[sitename][col][coldate]['URL']
                         statusc='green'
                         if self.matrices.xmlInfo[sitename][col][coldate]['Status']=="pend":
                             status='-'
                             statusc='orange'
                     elif self.cinfo.colorCodes[col][self.matrices.xmlInfo[sitename][col][coldate]['COLOR']] == "red":
                         status=self.matrices.xmlInfo[sitename][col][coldate]['Status']
                         statusu=self.matrices.xmlInfo[sitename][col][coldate]['URL']
                         statusc='red'
                     elif self.cinfo.colorCodes[col][self.matrices.xmlInfo[sitename][col][coldate]['COLOR']] == "yellow":
                         status=self.matrices.xmlInfo[sitename][col][coldate]['Status']
                         statusu=self.matrices.xmlInfo[sitename][col][coldate]['URL']
                         statusc='yellow'
                     elif self.cinfo.colorCodes[col][self.matrices.xmlInfo[sitename][col][coldate]['COLOR']] == "white":
                         status='n/a'
                         statusu=' '
                         statusc='white'
                     else:
                         status=self.matrices.xmlInfo[sitename][col][coldate]['Status']
                         statusu=self.matrices.xmlInfo[sitename][col][coldate]['URL']
                         statusc=self.cinfo.colorCodes[col][self.matrices.xmlInfo[sitename][col][coldate]['COLOR']]
 
                     dayloopstamp3 = self.ShiftDayForMetric(dayloop,col)
                     todayst = date(int(self.tinfo.todaystamp[0:4]),int(self.tinfo.todaystamp[5:7]),int(self.tinfo.todaystamp[8:10]))
                     dayloop3 = date(int(dayloopstamp3[0:4]),int(dayloopstamp3[5:7]),int(dayloopstamp3[8:10]))
 
                     if abs((dayloop3-todayst).days) > self.cinfo.days:
                         continue
                     if status == "Ready":
                        status = "R"
                     elif status == "NotReady":
                        status = "NR"
                     elif status == "Downtime":
                        status = "SD"
                     elif status == "Waiting_Room":
                        status = "WR"
                     elif status == "Morgue":
                        status = "M" 
                     elif status == "OK" or status == "Ok":
                        status = "O"
                     elif status == "Error":
                        status = "E"
                     # set the actual values in self.matrices.columnValues
                     infocol = {}
                     infocol['Status'] = status
                     infocol['Color'] = statusc
                     infocol['URL'] = statusu
                     infocol['validity'] = validity
                     if self.matrices.columnValues[sitename][dayloopstamp3][col].has_key('validity'):
                         if validity > self.matrices.columnValues[sitename][dayloopstamp3][col]['validity']:
                             self.matrices.columnValues[sitename][dayloopstamp3][col] = infocol
                     else:
                         self.matrices.columnValues[sitename][dayloopstamp3][col] = infocol
                                 
                     if dayloopstamp == self.tinfo.todaystamp:
                         infocol = {}
                         infocol['Status'] = ' '
                         infocol['Color'] = 'white'
                         infocol['URL'] = ' '
                         infocol['validity'] = '0'                       
                         self.matrices.columnValues[sitename][dayloopstamp][col] = infocol
 
     prog.finish()
Exemplo n.º 49
0
def main(startdate, enddate, logger, nice=False, skip=False):
    if startdate > enddate:
        oneday = tdelta(-1, 0)
    else:
        oneday = tdelta(1, 0)

    ##------------------------------------------------------------------------
    ## Use pyephem determine sunrise and sunset times
    ##------------------------------------------------------------------------
    now = dt.utcnow()
    if nice:
        Observatory = ephem.Observer()
        Observatory.lon = "-155:34:33.9"
        Observatory.lat = "+19:32:09.66"
        Observatory.elevation = 3400.0
        Observatory.temp = 10.0
        Observatory.pressure = 680.0
        Observatory.horizon = '0.0'
        Observatory.date = now.strftime('%Y/%m/%d %H:%M:%S')
        TheSun = ephem.Sun()

    MatchFilename = re.compile("(.*)\-([0-9]{8})at([0-9]{6})\.fts")
    MatchEmpty = re.compile(".*\-Empty\-.*\.fts")

    date = startdate
    while True:
        date_string = date.strftime('%Y%m%dUT')
        logger.info('Checking for images from {}'.format(date_string))
        images = []
        V5_path = os.path.join("/Volumes", "Drobo", "V5", "Images", date_string)
        V20_path = os.path.join("/Volumes", "Drobo", "V20", "Images", date_string)
        if os.path.exists(V5_path):
            V5_images = glob(os.path.join(V5_path, '*.fts'))
            logger.info('  Found {} images for the night of {} for V5'.format(\
                        len(V5_images), date_string))
            images.extend(V5_images)
        if os.path.exists(V20_path):
            V20_images = glob(os.path.join(V20_path, '*.fts'))
            logger.info('  Found {} images for the night of {} for V20'.format(\
                        len(V20_images), date_string))
            images.extend(V20_images)
        ## Sort Images by Observation time
        properties = []
        for image in images:
            skip_this_image = False
            imagename = os.path.split(image)[1]
            FNmatch = MatchFilename.match(imagename)
            Ematch = MatchEmpty.match(imagename)
            ## If skip is enabled, skip images which are already in mongo db
            if skip:
                telescope = None
                V5match = re.match("V5.*\.fi?ts", imagename)
                V20match = re.match("V20.*\.fi?ts", imagename)
                if V5match and not V20match:
                    telescope = "V5"
                elif V20match and not V5match:
                    telescope = "V20"
                else:
                    with fits.open(image) as hdulist:
                        if hdulist[0].header['OBSERVAT']:
                            if re.search('VYSOS-?20', hdulist[0].header['OBSERVAT']):
                                telescope = "V20"
                            elif re.search('VYSOS-?5', hdulist[0].header['OBSERVAT']):
                                telescope = "V5"
                            else:
                                print("Can not determine valid telescope from arguments or filename or header.")
                        else:
                            print("Can not determine valid telescope from arguments or filename or header.")
                if telescope:
                    config_file = os.path.join(os.path.expanduser('~'), '.{}.yaml'.format(telescope))
                    tel = IQMon.Telescope(config_file)
                    client = MongoClient(tel.mongo_address, tel.mongo_port)
                    db = client[tel.mongo_db]
                    data = db[tel.mongo_collection]
                    matches = [item for item in data.find( {"filename" : imagename} )]
                    if len(matches) > 0:
#                         images.remove(image)
                        skip_this_image = True
            ## Remove images with Empty in filenme
            if Ematch:
#                 images.remove(image)
                skip_this_image = True

            if not FNmatch:
#                 images.remove(image)
                skip_this_image = True

            if not skip_this_image:
                try:
                    image_dt = dt.strptime('{} {}'.format(\
                       FNmatch.group(2), FNmatch.group(3)), '%Y%m%d %H%M%S')
                except:
                    image_dt = dt.utcnow()
                properties.append([image, image_dt])
        properties = sorted(properties, key=lambda entry:entry[1])
        ## Process Images
        count = 0
        for entry in properties:
            count += 1
            print('')
            print('Examining image {} out of {} for the night of {}'.format(\
                   count, len(properties), date_string))
            image = entry[0]
            if nice:
                now = dt.utcnow()
                Observatory.date = now.strftime('%Y/%m/%d %H:%M:%S')
                TheSun.compute(Observatory)
                if TheSun.alt < 0:
                    print('The Sun is down (alt = {:.1f})'.format(TheSun.alt*180./ephem.pi))
                    sunrise = Observatory.next_rising(TheSun).datetime()
                    until_sunrise = (sunrise - now).total_seconds()/60./60.
                    logger.info('Sleeping {:.1f} hours until sunrise'.format(until_sunrise))
                    time.sleep(until_sunrise + 300)
                    now = dt.utcnow()
                    Observatory.date = now.strftime('%Y/%m/%d %H:%M:%S')
                    sunset  = Observatory.next_setting(ephem.Sun()).datetime()
                    sunrise = Observatory.next_rising(ephem.Sun()).datetime()
                    logger.info('Resuming processing ...')
                    logger.info('  Next sunset at {}'.format(sunset.strftime('%Y/%m/%d %H:%M:%S')))
            if MatchFilename.match(image) and not MatchEmpty.match(image):
                try:
                    measure_image.MeasureImage(image,\
                                 clobber_logs=True,\
                                 zero_point=True,\
                                 analyze_image=True)
                except:
                    logger.warning('MeasureImage failed on {}'.format(image))
                    measure_image.MeasureImage(image,\
                                 clobber_logs=False,\
                                 zero_point=True,\
                                 analyze_image=False)
        make_nightly_plots.make_plots(date_string, 'V5', logger)
        make_nightly_plots.make_plots(date_string, 'V20', logger)
        if date == enddate:
            break
        date += oneday
Exemplo n.º 50
0
    def get(self, input):
        tlog.app_log.info('Get request for Status "{}" recieved'.format(input))
        nowut = dt.utcnow()
        now = nowut - tdelta(0,10*60*60)

        client = pymongo.MongoClient('192.168.1.101', 27017)
        db = client['vysos']

        ##------------------------------------------------------------------------
        ## Use pyephem determine sunrise and sunset times
        ##------------------------------------------------------------------------
        Observatory = ephem.Observer()
        Observatory.lon = "-155:34:33.9"
        Observatory.lat = "+19:32:09.66"
        Observatory.elevation = 3400.0
        Observatory.temp = 10.0
        Observatory.pressure = 680.0
        Observatory.horizon = '0.0'

        Observatory.date = nowut
        TheSun = ephem.Sun()
        TheSun.compute(Observatory)
        sun = {}
        sun['alt'] = float(TheSun.alt) * 180. / ephem.pi
        sun['set'] = Observatory.next_setting(TheSun).datetime()
        sun['rise'] = Observatory.next_rising(TheSun).datetime()
        if sun['alt'] <= -18:
            sun['now'] = 'night'
        elif sun['alt'] > -18 and sun['alt'] <= -12:
            sun['now'] = 'astronomical twilight'
        elif sun['alt'] > -12 and sun['alt'] <= -6:
            sun['now'] = 'nautical twilight'
        elif sun['alt'] > -6 and sun['alt'] <= 0:
            sun['now'] = 'civil twilight'
        elif sun['alt'] > 0:
            sun['now'] = 'day'

        TheMoon = ephem.Moon()
        Observatory.date = nowut
        TheMoon.compute(Observatory)
        moon = {}
        moon['phase'] = TheMoon.phase
        moon['alt'] = TheMoon.alt * 180. / ephem.pi
        moon['set'] = Observatory.next_setting(TheMoon).datetime()
        moon['rise'] = Observatory.next_rising(TheMoon).datetime()
        if moon['alt'] > 0:
            moon['now'] = 'up'
        else:
            moon['now'] = 'down'

        tlog.app_log.info('  Ephem data calculated')

        ##---------------------------------------------------------------------
        ## Get disk use info
        ##---------------------------------------------------------------------
        paths = {'Drobo': os.path.join('/', 'Volumes', 'VYSOSData'),\
                 'macOS': os.path.expanduser('~'),\
                }

        disks = {}
        for disk in paths.keys():
            if os.path.exists(paths[disk]):
                size_GB, avail_GB, pcnt_used = free_space(paths[disk])
                disks[disk] = [size_GB, avail_GB, pcnt_used]

        tlog.app_log.info('  Disk use data determined')

        ##---------------------------------------------------------------------
        ## Get Telescope Status
        ##---------------------------------------------------------------------
        telstatus = {}
        tlog.app_log.info(f"Getting telescope status records from mongo")
        for telescope in ['V20', 'V5']:
            try:
                telstatus[telescope] = (db[f'{telescope}status'].find(limit=1, sort=[('date', pymongo.DESCENDING)])).next()
                if 'RA' in telstatus[telescope] and 'DEC' in telstatus[telescope]:
                    coord = SkyCoord(telstatus[telescope]['RA'],
                                     telstatus[telescope]['DEC'], unit=u.deg)
                    telstatus[telescope]['RA'], telstatus[telescope]['DEC'] = coord.to_string('hmsdms', sep=':', precision=0).split()
                tlog.app_log.info(f"  Got telescope status record for {telescope}")
            except StopIteration:
                telstatus[telescope] = {'date': dt.utcnow()-tdelta(365),
                                        'connected': False}
                tlog.app_log.info(f"  No telescope status records for {telescope}.")
                tlog.app_log.info(f"  Filling in blank data for {telescope}.")
        
        
        ##---------------------------------------------------------------------
        ## Get Current Weather
        ##---------------------------------------------------------------------
        tlog.app_log.info(f"Getting weather records from mongo")
        weather = client.vysos['weather']
        if weather.count() > 0:
            cw = weather.find(limit=1, sort=[('date', pymongo.DESCENDING)]).next()
        else:
            cw = None
        tlog.app_log.info(f"  Done")
        
        ##---------------------------------------------------------------------
        ## Render
        ##---------------------------------------------------------------------
        link_date_string = nowut.strftime('%Y%m%dUT')
        files_string = "Tonight's Files"
        if nowut.hour < 3:
            link_date_string = (nowut - tdelta(1,0)).strftime('%Y%m%dUT')
            files_string = "Last Night's Files"

        tlog.app_log.info('  Rendering Status')
        cctv = False
        if input.lower() in ["cctv", "cctv.html"]:
            cctv = True
        self.render("status.html", title="VYSOS Status",
                    now = (now, nowut),
                    disks = disks,
                    link_date_string = link_date_string,
                    moon = moon,
                    sun = sun,
                    telstatus=telstatus,
                    files_string = files_string,\
                    v5_images = get_image_list('V5', link_date_string),\
                    v20_images = get_image_list('V20', link_date_string),\
                    v5_flats = get_image_list('V5', link_date_string, flats=True),\
                    v20_flats = get_image_list('V20', link_date_string, flats=True),\
                    v5_cals = get_image_list('V5', link_date_string, cals=True),\
                    v20_cals = get_image_list('V20', link_date_string, cals=True),\
                    cctv=cctv,
                    currentweather=cw,
                    weather_limits=weather_limits,
                    )
        tlog.app_log.info('  Done')
Exemplo n.º 51
0
def correlate_temps():

    if not os.path.exists('tempcompdata.txt'):
        client = pymongo.MongoClient('192.168.1.101', 27017)
        db = client['vysos']
        images = db['V5.images']
        status = db['V5.status']

        results = images.find( {'FWHM pix': {'$lt': 2.0}} )

        tab = Table(names=('time', 'focuspos', 'tubetemp', 'ambtemp'),
                    dtype=('a25', 'i4', 'f4', 'f4'))
        for i,result in enumerate(results):
            when = result['exposure start']
            exptime = result['exposure time']
            telemetry = status.find( {'UT timestamp': {'$gte': when,
                                                       '$lte': when+tdelta(0,exptime)} } )
            if i in np.arange(0,results.count(),100):
                print('{:4d} {} {:d}'.format(i, when.isoformat(), telemetry.count()))
            try:
                assert 'FocusMax temperature (tube)' in telemetry[0].keys()
                assert 'boltwood ambient temp' in telemetry[0].keys()
                assert 'FocusMax focuser position' in telemetry[0].keys()
                row = {'time': when.isoformat(),
                       'focuspos': int(telemetry[0]['FocusMax focuser position']),
                       'tubetemp': float(telemetry[0]['FocusMax temperature (tube)']),
                       'ambtemp': float(telemetry[0]['boltwood ambient temp'])}
                tab.add_row(row)
            except:
                print('Failed on data at {}'.format(when.isoformat()))
        tab.write('tempcompdata.txt', format='ascii.csv')
    else:
        tab = Table.read('tempcompdata.txt', format='ascii.csv')

    time = [ dt.strptime(t, '%Y-%m-%dT%H:%M:%S') for t in tab['time'] ]


    # -------------------------------------------------------------------------
    # Plot correlation between tube and ambient temperature
    # -------------------------------------------------------------------------
    diff = tab['ambtemp'] - tab['tubetemp']
    line0 = models.Linear1D(slope=1, intercept=np.median(diff))
    line0.slope.fixed = True

#     fitter = fitting.LinearLSQFitter()
#     line = fitter(line0, tab['tubetemp'], tab['ambtemp'])
    line = line0


    plt.figure()
    plt.plot(tab['tubetemp'], tab['ambtemp'], 'bo', markersize=3, markeredgewidth=0)
    plt.plot(tab['tubetemp'], tab['ambtemp'], 'k-', alpha=0.3)
    plt.plot(tab['tubetemp'], line(tab['tubetemp']), 'g-',
             label='slope={:.1f}, intercept={:.1f}'.format(
                    line.slope.value, line.intercept.value) )
    plt.xlabel('FocusMax Temperature')
    plt.ylabel('Ambient Temperature')
    plt.grid()
    plt.legend(loc='best')
    plt.savefig('temperature_correlation_V5.png')


    # -------------------------------------------------------------------------
    # Plot focus position over time to check for discontinuities
    # -------------------------------------------------------------------------
    plt.figure()
    ax = plt.gca()
    plt.plot_date(time, tab['focuspos'], 'bo', markersize=3, markeredgewidth=0)
    plt.xlabel('Time')
    plt.ylabel('Focuser Position')
    days = DayLocator(interval=2)
    fmt = DateFormatter('%Y/%m/%d')
    ax.xaxis.set_major_locator(days)
    ax.xaxis.set_major_formatter(fmt)
    plt.grid()
    plt.savefig('focus_vs_time.png')


    # -------------------------------------------------------------------------
    # Plot focus position vs. tube temperature to determine compensation
    # -------------------------------------------------------------------------
    line0 = models.Linear1D()
    fitter = fitting.LinearLSQFitter()
    line = fitter(line0, tab['tubetemp'], tab['focuspos'])
    plt.figure()
    plt.scatter(tab['tubetemp'], tab['focuspos'], c=range(len(time)), norm=None, cmap='Blues')
    plt.plot(tab['tubetemp'], tab['focuspos'], 'k-', alpha=0.3)
    plt.plot(tab['tubetemp'], line(tab['tubetemp']), 'g-',
             label='slope={:.1f}, intercept={:.1f}'.format(
                    line.slope.value, line.intercept.value) )
    plt.xlabel('FocusMax Temperature')
    plt.ylabel('FocusMax Position')
    plt.grid()
    plt.legend(loc='best')
    plt.savefig('temperature_compensation_V5.png')
Exemplo n.º 52
0
 def was_published_recently(self):
     now = timezone.now()
     return now - tdelta(days=-1) >= self.pub_date <= now
Exemplo n.º 53
0
    def get(self):
        tlog.app_log.info('Get request for Status recieved')
        nowut = dt.utcnow()
        now = nowut - tdelta(0,10*60*60)

        client = MongoClient('192.168.1.101', 27017)

        ##------------------------------------------------------------------------
        ## Use pyephem determine sunrise and sunset times
        ##------------------------------------------------------------------------
        Observatory = ephem.Observer()
        Observatory.lon = "-155:34:33.9"
        Observatory.lat = "+19:32:09.66"
        Observatory.elevation = 3400.0
        Observatory.temp = 10.0
        Observatory.pressure = 680.0
        Observatory.horizon = '0.0'

        Observatory.date = nowut
        TheSun = ephem.Sun()
        TheSun.compute(Observatory)
        sun = {}
        sun['alt'] = float(TheSun.alt) * 180. / ephem.pi
        sun['set'] = Observatory.next_setting(TheSun).datetime()
        sun['rise'] = Observatory.next_rising(TheSun).datetime()
        if sun['alt'] <= -18:
            sun['now'] = 'night'
        elif sun['alt'] > -18 and sun['alt'] <= -12:
            sun['now'] = 'astronomical twilight'
        elif sun['alt'] > -12 and sun['alt'] <= -6:
            sun['now'] = 'nautical twilight'
        elif sun['alt'] > -6 and sun['alt'] <= 0:
            sun['now'] = 'civil twilight'
        elif sun['alt'] > 0:
            sun['now'] = 'day'

        TheMoon = ephem.Moon()
        Observatory.date = nowut
        TheMoon.compute(Observatory)
        moon = {}
        moon['phase'] = TheMoon.phase
        moon['alt'] = TheMoon.alt * 180. / ephem.pi
        moon['set'] = Observatory.next_setting(TheMoon).datetime()
        moon['rise'] = Observatory.next_rising(TheMoon).datetime()
        if moon['alt'] > 0:
            moon['now'] = 'up'
        else:
            moon['now'] = 'down'

        tlog.app_log.info('  Ephem data calculated')

        ##---------------------------------------------------------------------
        ## Get Latest V20 Data
        ##---------------------------------------------------------------------
        v20status = client.vysos['V20.status']
#         v20entries = []
#         while (len(v20entries) < 1) and (nowut > dt(2015,1,1)):
#             v20entries = [entry for entry\
#                           in v20status.find(\
#                           {"UT date" : nowut.strftime('%Y%m%dUT')}\
#                           ).sort([('UT time', pymongo.ASCENDING)])]
#             if len(v20entries) > 0: v20data = v20entries[-1]
#             else: nowut = nowut - tdelta(1, 0)
#         nowut = dt.utcnow()

        v20data = v20status.find_one( {'current': True} )
        tlog.app_log.info('  v20data retrieved')

        try:
            try:
                v20clarity_time = v20data['boltwood timestamp']
            except:
                v20clarity_time = dt.strptime('{} {}'.format(\
                                  v20data['boltwood date'],\
                                  v20data['boltwood time'][:-3]),\
                                  '%Y-%m-%d %H:%M:%S')        
            v20clarity_age = (now - v20clarity_time).total_seconds()
            if v20clarity_age > 60: v20clarity_color = 'red'
            else: v20clarity_color = 'black'
        except:
            v20clarity_age = float('nan')
            v20clarity_color = 'red'
        tlog.app_log.info('  v20clarity_color determined')

        try:
            try:
                v20data_time = v20data['UT timestamp']
            except:
                v20data_time = dt.strptime('{} {}'.format(\
                               v20data['UT date'],\
                               v20data['UT time']),\
                               '%Y%m%dUT %H:%M:%S')
            v20data_age = (nowut - v20data_time).total_seconds()
            if v20data_age > 60: v20data_color = 'red'
            else: v20data_color = 'black'
        except:
            v20data_age = float('nan')
            v20data_color = 'red'
        tlog.app_log.info('  v20data_color determined')

        ##---------------------------------------------------------------------
        ## Get Latest V5 Data
        ##---------------------------------------------------------------------
        v5status = client.vysos['V5.status']
#         v5entries = []
#         while (len(v5entries) < 1) and (nowut > dt(2015,1,1)):
#             v5entries = [entry for entry\
#                           in v5status.find( {"UT date" : nowut.strftime('%Y%m%dUT')} ).sort([('UT time', pymongo.ASCENDING)])]
#             if len(v5entries) > 0: v5data = v5entries[-1]
#             else: nowut = nowut - tdelta(1, 0)
#         nowut = dt.utcnow()

        v5data = v5status.find_one( {'current': True} )
        tlog.app_log.info('  v5data retrieved')

        try:
            try:
                v5clarity_time = v5data['boltwood timestamp']
            except:
                v5clarity_time = dt.strptime('{} {}'.format(\
                                  v5data['boltwood date'],\
                                  v5data['boltwood time'][:-3]),\
                                  '%Y-%m-%d %H:%M:%S')        
            v5clarity_age = (now - v5clarity_time).total_seconds()
            if v5clarity_age > 60: v5clarity_color = 'red'
            else: v5clarity_color = 'black'
        except:
            v5clarity_age = float('nan')
            v5clarity_color = 'red'
        tlog.app_log.info('  v5clarity_color determined')

        try:
            try:
                v5data_time = v5data['UT timestamp']
            except:
                v5data_time = dt.strptime('{} {}'.format(\
                               v5data['UT date'],\
                               v5data['UT time']),\
                               '%Y%m%dUT %H:%M:%S')
            v5data_age = (nowut - v5data_time).total_seconds()
            if v5data_age > 60: v5data_color = 'red'
            else: v5data_color = 'black'
        except:
            v5data_age = float('nan')
            v5data_color = 'red'
        tlog.app_log.info('  v5clarity_color determined')

        ##---------------------------------------------------------------------
        ## Format and Color Code Boltwood Data
        ##---------------------------------------------------------------------
        wind_units = {'M': 'mph', 'K': 'kph', 'm': 'm/s'}
        rain_status = {0: 'Dry', 1: 'Recent Rain', 2: 'Raining'}
        wet_status = {0: 'Dry', 1: 'Recent Wet', 2: 'Wet'}
        cloud_condition = {0: 'Unknown', 1: 'Clear', 2: 'Cloudy', 3: 'Very Cloudy'}
        wind_condition = {0: 'Unknown', 1: 'Calm', 2: 'Windy', 3: 'Very Windy'}
        rain_condition = {0: 'Unknown', 1: 'Dry', 2: 'Wet', 3: 'Rain'}
        day_condition = {0: 'Unknown', 1: 'Dark', 2: 'Light', 3: 'Very Light'}
        roof_close = {0: 'Safe', 1: 'Unsafe'}

        if 'boltwood wind units' in v20data.keys():
            v20data['boltwood wind units'] = wind_units[v20data['boltwood wind units']]
        if 'boltwood rain status' in v20data.keys():
            if v20data['boltwood rain status'] == 0: v20data['boltwood rain status color'] = 'green'
            elif v20data['boltwood rain status'] == 1: v20data['boltwood rain status color'] = 'red'
            elif v20data['boltwood rain status'] == 2: v20data['boltwood rain status color'] = 'red'
            else: v20data['boltwood rain color'] = ''
            v20data['boltwood rain status string'] = rain_status[v20data['boltwood rain status']]
        if 'boltwood wet status' in v20data.keys():
            if v20data['boltwood wet status'] == 0: v20data['boltwood wet status color'] = 'green'
            elif v20data['boltwood wet status'] == 1: v20data['boltwood wet status color'] = 'red'
            elif v20data['boltwood wet status'] == 2: v20data['boltwood wet status color'] = 'red'
            else: v20data['boltwood wet color'] = ''
            v20data['boltwood wet status string'] = wet_status[v20data['boltwood wet status']]
        if 'boltwood cloud condition' in v20data.keys():
            if v20data['boltwood cloud condition'] == 0: v20data['boltwood cloud color'] = 'orange'
            elif v20data['boltwood cloud condition'] == 1: v20data['boltwood cloud color'] = 'green'
            elif v20data['boltwood cloud condition'] == 2: v20data['boltwood cloud color'] = 'orange'
            elif v20data['boltwood cloud condition'] == 3: v20data['boltwood cloud color'] = 'red'
            else: v20data['boltwood cloud color'] = ''
            v20data['boltwood cloud condition string'] = cloud_condition[v20data['boltwood cloud condition']]
        if 'boltwood wind condition' in v20data.keys():
            if v20data['boltwood wind condition'] == 0: v20data['boltwood wind color'] = 'orange'
            elif v20data['boltwood wind condition'] == 1: v20data['boltwood wind color'] = 'green'
            elif v20data['boltwood wind condition'] == 2: v20data['boltwood wind color'] = 'orange'
            elif v20data['boltwood wind condition'] == 3: v20data['boltwood wind color'] = 'red'
            else: v20data['boltwood wind color'] = ''
            v20data['boltwood wind condition string'] = wind_condition[v20data['boltwood wind condition']]
        if 'boltwood rain condition' in v20data.keys():
            if v20data['boltwood rain condition'] == 0: v20data['boltwood rain color'] = 'orange'
            elif v20data['boltwood rain condition'] == 1: v20data['boltwood rain color'] = 'green'
            elif v20data['boltwood rain condition'] == 2: v20data['boltwood rain color'] = 'red'
            elif v20data['boltwood rain condition'] == 3: v20data['boltwood rain color'] = 'red'
            else: v20data['boltwood rain color'] = ''
            v20data['boltwood rain condition string'] = rain_condition[v20data['boltwood rain condition']]
        if 'boltwood day condition' in v20data.keys():
            if v20data['boltwood day condition'] == 0: v20data['boltwood day color'] = 'orange'
            elif v20data['boltwood day condition'] == 1: v20data['boltwood day color'] = 'green'
            elif v20data['boltwood day condition'] == 2: v20data['boltwood day color'] = 'orange'
            elif v20data['boltwood day condition'] == 3: v20data['boltwood day color'] = 'red'
            else: v20data['boltwood day color'] = ''
            v20data['boltwood day condition string'] = day_condition[v20data['boltwood day condition']]
        if 'boltwood roof close' in v20data.keys():
            if v20data['boltwood roof close'] == 0: v20data['boltwood roof close color'] = 'green'
            elif v20data['boltwood roof close'] == 1: v20data['boltwood roof close color'] = 'red'
            else: v20data['boltwood roof close color'] = ''
            v20data['boltwood roof close string'] = roof_close[v20data['boltwood roof close']]

        if 'boltwood wind units' in v5data.keys():
            v5data['boltwood wind units'] = wind_units[v5data['boltwood wind units']]
        if 'boltwood rain status' in v5data.keys():
            if v5data['boltwood rain status'] == 0: v5data['boltwood rain status color'] = 'green'
            elif v5data['boltwood rain status'] == 1: v5data['boltwood rain status color'] = 'red'
            elif v5data['boltwood rain status'] == 2: v5data['boltwood rain status color'] = 'red'
            else: v5data['boltwood rain color'] = ''
            v5data['boltwood rain status string'] = rain_status[v5data['boltwood rain status']]
        if 'boltwood wet status' in v5data.keys():
            if v5data['boltwood wet status'] == 0: v5data['boltwood wet status color'] = 'green'
            elif v5data['boltwood wet status'] == 1: v5data['boltwood wet status color'] = 'red'
            elif v5data['boltwood wet status'] == 2: v5data['boltwood wet status color'] = 'red'
            else: v5data['boltwood wet color'] = ''
            v5data['boltwood wet status string'] = wet_status[v5data['boltwood wet status']]
        if 'boltwood cloud condition' in v5data.keys():
            if v5data['boltwood cloud condition'] == 0: v5data['boltwood cloud color'] = 'orange'
            elif v5data['boltwood cloud condition'] == 1: v5data['boltwood cloud color'] = 'green'
            elif v5data['boltwood cloud condition'] == 2: v5data['boltwood cloud color'] = 'orange'
            elif v5data['boltwood cloud condition'] == 3: v5data['boltwood cloud color'] = 'red'
            else: v5data['boltwood cloud color'] = ''
            v5data['boltwood cloud condition string'] = cloud_condition[v5data['boltwood cloud condition']]
        if 'boltwood wind condition' in v5data.keys():
            if v5data['boltwood wind condition'] == 0: v5data['boltwood wind color'] = 'orange'
            elif v5data['boltwood wind condition'] == 1: v5data['boltwood wind color'] = 'green'
            elif v5data['boltwood wind condition'] == 2: v5data['boltwood wind color'] = 'orange'
            elif v5data['boltwood wind condition'] == 3: v5data['boltwood wind color'] = 'red'
            else: v5data['boltwood wind color'] = ''
            v5data['boltwood wind condition string'] = wind_condition[v5data['boltwood wind condition']]
        if 'boltwood rain condition' in v5data.keys():
            if v5data['boltwood rain condition'] == 0: v5data['boltwood rain color'] = 'orange'
            elif v5data['boltwood rain condition'] == 1: v5data['boltwood rain color'] = 'green'
            elif v5data['boltwood rain condition'] == 2: v5data['boltwood rain color'] = 'red'
            elif v5data['boltwood rain condition'] == 3: v5data['boltwood rain color'] = 'red'
            else: v5data['boltwood rain color'] = ''
            v5data['boltwood rain condition string'] = rain_condition[v5data['boltwood rain condition']]
        if 'boltwood day condition' in v5data.keys():
            if v5data['boltwood day condition'] == 0: v5data['boltwood day color'] = 'orange'
            elif v5data['boltwood day condition'] == 1: v5data['boltwood day color'] = 'green'
            elif v5data['boltwood day condition'] == 2: v5data['boltwood day color'] = 'orange'
            elif v5data['boltwood day condition'] == 3: v5data['boltwood day color'] = 'red'
            else: v5data['boltwood day color'] = ''
            v5data['boltwood day condition string'] = day_condition[v5data['boltwood day condition']]
        if 'boltwood roof close' in v5data.keys():
            if v5data['boltwood roof close'] == 0: v5data['boltwood roof close color'] = 'green'
            elif v5data['boltwood roof close'] == 1: v5data['boltwood roof close color'] = 'red'
            else: v5data['boltwood roof close color'] = ''
            v5data['boltwood roof close string'] = roof_close[v5data['boltwood roof close']]
        tlog.app_log.info('  colors determined')

        ##---------------------------------------------------------------------
        ## Format and Color Code ACP Data
        ##---------------------------------------------------------------------
        ACP_connected = {True: 'Connected', False: 'Disconnected'}

        if 'ACP connected' in v20data.keys():
            v20data['ACP connected string'] = ACP_connected[v20data['ACP connected']]
            if (v20data['ACP connected']):
                v20data['ACP connected color'] = 'green'
                if ('ACP park status' in v20data.keys()) and\
                   ('ACP slewing status' in v20data.keys()) and\
                   ('ACP tracking status' in v20data.keys()):
                    P = v20data['ACP park status']
                    S = v20data['ACP slewing status']
                    T = v20data['ACP tracking status']
                    if P:
                        v20data['ACP status string'] = 'Parked'
                        v20data['ACP status color'] = ''
                    elif not P and not S and not T:
                        v20data['ACP status string'] = 'Stationary'
                        v20data['ACP status color'] = ''
                    elif not P and S and not T:
                        v20data['ACP status string'] = 'Slewing'
                        v20data['ACP status color'] = 'orange'
                    elif not P and S and T:
                        v20data['ACP status string'] = 'Slewing'
                        v20data['ACP status color'] = 'orange'
                    elif not P and not S and T:
                        v20data['ACP status string'] = 'Tracking'
                        v20data['ACP status color'] = 'green'
                    else:
                        v20data['ACP status string'] = '{}{}{}'.format(P,S,T)
                        v20data['ACP status color'] = 'red'
                if ('ACP target RA' in v20data.keys()) and ('ACP target Dec' in v20data.keys()):
                    v20c = SkyCoord(ra=v20data['ACP target RA']*u.degree,\
                                    dec=v20data['ACP target Dec']*u.degree,\
                                    frame='icrs')
                    v20coord = '{} {}'.format(\
                                              v20c.ra.to_string(sep=':', precision=1),\
                                              v20c.dec.to_string(sep=':', precision=1),\
                                             )
                else:
                    v20c = None
                    v20coord = ''
            else:
                v20data['ACP connected color'] = ''
                v20coord = ''
        else:
            v20data['ACP connected color'] = ''
            v20coord = ''
        tlog.app_log.info('  V20 ACP Connected Color determined')

        if 'ACP connected' in v5data.keys():
            v5data['ACP connected string'] = ACP_connected[v5data['ACP connected']]
            if (v5data['ACP connected']):
                v5data['ACP connected color'] = 'green'
                if ('ACP park status' in v5data.keys()) and\
                   ('ACP slewing status' in v5data.keys()) and\
                   ('ACP tracking status' in v5data.keys()):
                    P = v5data['ACP park status']
                    S = v5data['ACP slewing status']
                    T = v5data['ACP tracking status']
                    if P:
                        v5data['ACP status string'] = 'Parked'
                        v5data['ACP status color'] = ''
                    elif not P and not S and not T:
                        v5data['ACP status string'] = 'Stationary'
                        v5data['ACP status color'] = ''
                    elif not P and S and not T:
                        v5data['ACP status string'] = 'Slewing'
                        v5data['ACP status color'] = 'orange'
                    elif not P and S and T:
                        v5data['ACP status string'] = 'Slewing'
                        v5data['ACP status color'] = 'orange'
                    elif not P and not S and T:
                        v5data['ACP status string'] = 'Tracking'
                        v5data['ACP status color'] = 'green'
                    else:
                        v5data['ACP status string'] = '{}{}{}'.format(P,S,T)
                        v5data['ACP status color'] = 'red'
                if ('ACP target RA' in v5data.keys()) and ('ACP target Dec' in v5data.keys()):
                    v5c = SkyCoord(ra=v5data['ACP target RA']*u.degree,\
                                   dec=v5data['ACP target Dec']*u.degree,\
                                   frame='icrs')
                    v5coord = '{} {}'.format(\
                                             v5c.ra.to_string(sep=':', precision=1),\
                                             v5c.dec.to_string(sep=':', precision=1),\
                                            )
                else:
                    v5c = None
                    v5coord = ''
            else:
                v5data['ACP connected color'] = ''
                v5coord = ''
        else:
            v5data['ACP connected color'] = ''
            v5coord = ''
        tlog.app_log.info('  V5 ACP Connected Color determined')

        ##---------------------------------------------------------------------
        ## Get disk use info
        ##---------------------------------------------------------------------
        paths = {'Drobo': os.path.join('/', 'Volumes', 'Drobo'),\
                 'Data': os.path.expanduser('~'),\
                 'USB Drive B': os.path.join('/', 'Volumes', 'WD500B'),\
                 'USB Drive C': os.path.join('/', 'Volumes', 'WD500_C'),\
                 'Vega': os.path.join('/', 'Volumes', 'Data_V5'),\
                 'Black': os.path.join('/', 'Volumes', 'Data_V20'),\
                }

        disks = {}
        for disk in paths.keys():
            if os.path.exists(paths[disk]):
                size_GB, avail_GB, pcnt_used = free_space(paths[disk])
                if disk == 'Drobo':
                    size_GB -= 12750
                    avail_GB -= 12750
                    pcnt_used = float(size_GB - avail_GB)/float(size_GB) * 100
                disks[disk] = [size_GB, avail_GB, pcnt_used]

        tlog.app_log.info('  Disk use data determined')

        ##---------------------------------------------------------------------
        ## Render
        ##---------------------------------------------------------------------
        if nowut.hour >= 4:
            link_date_string = nowut.strftime('%Y%m%dUT')
        else:
            link_date_string = (nowut - tdelta(1,0)).strftime('%Y%m%dUT')

        print(v20coord)
        print(v20data_color)

        tlog.app_log.info('  Rendering Status')
        self.render("status.html", title="VYSOS Status",\
                    now = now,\
                    nowut = nowut,\
                    link_date_string = link_date_string,\
                    v20clarity_age = v20clarity_age,\
                    v20clarity_color = v20clarity_color,\
                    v20data_time = v20data_time,\
                    v20data_age = v20data_age,\
                    v20data_color = v20data_color,\
                    v20data = v20data,\
                    v20coord = v20coord,\
                    v5clarity_age = v5clarity_age,\
                    v5clarity_color = v5clarity_color,\
                    v5data_time = v5data_time,\
                    v5data_age = v5data_age,\
                    v5data_color = v5data_color,\
                    v5data = v5data,\
                    v5coord = v5coord,\
                    moon = moon,\
                    sun = sun,\
                    disks = disks,\
                    )
        tlog.app_log.info('  Done')
## add arguments
p.add_argument('name', type=str,
               help="The name of the target compatible with JPL horizons")
args = p.parse_args()

if args.fromdate is None:
    fromdate = dt.utcnow()
else:
    try:
        fromdate = dt.strptime(args.fromdate, '%Y-%m-%dT%H:%M:%S')
    except:
        print('Could not parse from date')
        raise

if args.todate is None:
    todate = dt.utcnow() + tdelta(1, 0)
else:
    try:
        todate = dt.strptime(args.todate, '%Y-%m-%dT%H:%M:%S')
    except:
        print('Could not parse to date')
        raise

##-------------------------------------------------------------------------
## Create logger object
##-------------------------------------------------------------------------
log = logging.getLogger('MyLogger')
log.setLevel(logging.DEBUG)
## Set up console output
LogConsoleHandler = logging.StreamHandler()
if args.verbose is True:
Exemplo n.º 55
0
def main(solar_sites):
    """
    Status:
    TESTS LOOK OKAY
    Purpose:
     Synthesize 1-min time series of clearsky index that accounts for correlation
      between sites using the geographic location of the sites and the hourly 
      average clearsky index for each site 

    Inputs:
    solar_sites - a list  of SolarSite objects that will be used for the 
                  syntheseis of the clearsky index data

    Outpus:
    solar_sites - the same list of SolarSite objects now containing the additional 
                   1-min clearsky index data attached to each SolarSite object
    """
    #### Calculate a distance matrix between each of the sites 
    dist_mtx = distance_matrix(solar_sites)
    
    #### Preload the Spectral amplitude with different frequencies as a function of
    ####  the hourly clearsky index
    try:
        #### Load from stored file 
        psd = cPickle.load(open(ROOT_DIR % 'clearsky_index_psd.pkl', 'rb'))
    except IOError:
        psd = power_spectral_density()

    #### Calculate the correlation matrix based on the distance between the sites 
    freqs = psd['1.00']['freq']
    cohere = coherence_matrix(dist_mtx, freqs)

    #### Preload the within-hour distribution of clearsky index lookup table
    try:
        #### Load from stored file 
        cdf = cPickle.load(open(ROOT_DIR % 'clearsky_index_cdf.pkl', 'rb'))
    except IOError:
        cdf = clearsky_index_distribution(psd.items.values)

    #### For each hour synthesize the 1-min timeseries:
    ## Get the index and initialize the final timeseries 
    hour_index = solar_sites[0].clr_idx_hr.index
    year_start = hour_index[0] - tdelta(seconds = hour_index[0].minute * 60)
    year_end = hour_index[-1] - tdelta(seconds = hour_index[-1].minute * 60) + \
        tdelta(seconds = 59*60)
    year_rng = pd.date_range(year_start, year_end, freq = 'min')

    synth_hr_args = [solar_sites, dist_mtx.index, cohere, cdf, psd, freqs]

#***** Single core version ****** NOT CURRENTLY USED
#    TS_list = []
#    for dt in hour_index:
#        #### Synthesize the 1-min time series for each hour
#        TS = synthesize_hour(dt, synth_hr_args)
#        TS_list.append(TS)
#---------------------------------------------------

#****** Parallel version ********* ACTIVE
#    
    TS_list = Parallel(n_jobs= -2, verbose = 5)(
        delayed(synthesize_hour)(dt, synth_hr_args) for dt in hour_index)
#----------------------------------------

    #### Stich all of the hours together and ensure that there are no
    ####  hour-to-hour seams issues 
    
    print "Inserting all of the 1-min data from " +\
        "%s hours into the TS_year dataframe" % len(TS_list)

    for TS in TS_list:  
        ## Check to make sure there are not Nan values in the timeseries (indicates 
        ##  a potential error earlier in the code
        for id in TS.columns:
            if pd.isnull(TS[id]).sum() >0:
                print "Final TS has Nan!!!"
        try:
            TS_year = pd.concat([TS_year, TS])
        except NameError: # If TS_year doesn't exist, then initialize it first
            TS_year = TS

    #### Attach the 1-min clearsky timeseries to each solar site 
    for site in solar_sites:
        site.clr_idx_min = TS_year[site.id]

    return solar_sites 
Exemplo n.º 56
0
def main(startdate, enddate, logger):

    logger.info("Writing results to mongo db at 192.168.1.101")
    try:
        client = MongoClient("192.168.1.101", 27017)
    except:
        logger.error("Could not connect to mongo db")
        raise
    else:
        V5status = client.vysos["V5.status"]
        logger.debug("  Getting V5.status collection")
        V20status = client.vysos["V20.status"]
        logger.debug("  Getting V20.status collection")

    oneday = tdelta(1, 0)
    date = startdate
    while date <= enddate:
        date_string = date.strftime("%Y%m%dUT")
        logger.info("")
        logger.info("Checking for environmental logs from {}".format(date_string))
        ## VYSOS-5
        telescope = "V5"
        logfile = os.path.join("/", "Volumes", "Drobo", telescope, "Logs", date_string, "EnvironmentalLog.txt")
        if not os.path.exists(logfile):
            logger.warning("  No logfile found for {} on {}".format(telescope, date_string))
        else:
            logger.info("  Found logfile: {}".format(logfile))

            #             ColStarts = [ 0, 11, 22, 32, 42, 52, 62, 72, 82,  92, 102, 112]
            #             ColEnds   = [ 9, 20, 31, 41, 51, 61, 71, 81, 91, 101, 111, 121]
            #             ColNames  = ['Date', 'TimeString', 'TubeTemp', 'FocusPos',
            #                          'SkyTemp', 'OutsideTemp', 'WindSpeed', 'Humidity', 'DewPoint', 'Altitude', 'Azimuth', 'Condition']
            #             env_table = ascii.read(logfile, data_start=2, Reader=ascii.FixedWidth,
            #                          col_starts=ColStarts, col_ends=ColEnds, names=ColNames,
            #                          guess=False, comment=";", header_start=0,
            #                          converters={
            #                          'Date': [ascii.convert_numpy(numpy.str)],
            #                          'TimeString': [ascii.convert_numpy(numpy.str)],
            #                          'TubeTemp': [ascii.convert_numpy(numpy.float)],
            #                          'FocusPos': [ascii.convert_numpy(numpy.int)],
            #                          'SkyTemp': [ascii.convert_numpy(numpy.float)],
            #                          'OutsideTemp': [ascii.convert_numpy(numpy.float)],
            #                          'WindSpeed': [ascii.convert_numpy(numpy.float)],
            #                          'Humidity': [ascii.convert_numpy(numpy.int)],
            #                          'DewPoint': [ascii.convert_numpy(numpy.float)],
            #                          'Altitude': [ascii.convert_numpy(numpy.float)],
            #                          'Azimuth': [ascii.convert_numpy(numpy.float)],
            #                          'Condition': [ascii.convert_numpy(numpy.str)]
            #                          }
            #                          )
            with open(logfile, "r") as FO:
                env_table = FO.readlines()

            for line in env_table:
                if line[0] != "#":
                    try:
                        entry = line.split()
                        new_data = {}
                        ## Date and Time
                        dto_utc = dt.strptime("{} {}".format(entry[0], entry[1]), "%Y/%m/%d %H:%M:%SUT")
                        dto_hst = dto_utc - tdelta(0, 10 * 60 * 60)
                        new_data.update(
                            {
                                "UT date": dto_utc.strftime("%Y%m%dUT"),
                                "UT time": dto_utc.strftime("%H:%M:%S"),
                                "UT timestamp": dto_utc,
                            }
                        )
                        ## Define Boltwood Data
                        boltwood = {}
                        boltwood["boltwood date"] = dto_hst.strftime("%Y-%m-%d")  # local date (yyyy-mm-dd)
                        boltwood["boltwood time"] = dto_hst.strftime("%H:%M:%S.00")  # local time (hh:mm:ss.ss)
                        boltwood["boltwood timestamp"] = dto_hst
                        boltwood["boltwood temp units"] = "F"
                        boltwood["boltwood wind units"] = "K"
                        boltwood["boltwood sky temp"] = float(entry[4])
                        boltwood["boltwood ambient temp"] = float(entry[5])
                        boltwood["boltwood wind speed"] = float(entry[6])
                        boltwood["boltwood humidity"] = int(entry[7])
                        boltwood["boltwood dew point"] = float(entry[8])
                        boltwood["boltwood rain condition"] = int(entry[11][0])
                        boltwood["boltwood cloud condition"] = int(entry[11][1])
                        boltwood["boltwood wind condition"] = int(entry[11][2])
                        new_data.update(boltwood)
                    except:
                        print(line)
                        print(entry)
                        raise

                    ##-------------------------------------------------------------------------
                    ## Write Environmental Log
                    ##-------------------------------------------------------------------------
                    ## Check if this image is already in the collection
                    matches = [item for item in V5status.find({"UT timestamp": new_data["UT timestamp"]})]
                    if len(matches) > 0:
                        logger.debug(
                            "    Found {} previous entries for {} {}.  Deleting old entries.".format(
                                len(matches), new_data["UT date"], new_data["UT time"]
                            )
                        )
                        for match in matches:
                            logger.debug("    Removing entry for {} {}".format(match["UT date"], match["UT time"]))
                            V5status.remove({"_id": match["_id"]})
                            logger.debug('    Removed "_id": {}'.format(match["_id"]))

                    id = V5status.insert(new_data)
                    logger.info(
                        "    Inserted datum for {} on {} {}".format(telescope, new_data["UT date"], new_data["UT time"])
                    )
        make_nightly_plots.make_plots(date_string, "V5", logger)

        ## VYSOS-20
        telescope = "V20"
        logfile = os.path.join("/", "Volumes", "Drobo", telescope, "Logs", date_string, "EnvironmentalLog.txt")
        if not os.path.exists(logfile):
            logger.warning("  No logfile found for {} on {}".format(telescope, date_string))
        else:
            logger.info("  Found logfile: {}".format(logfile))

            #             ColStarts = [ 0, 11, 22, 32, 42, 52, 62, 72, 82,  92, 102, 112, 122, 132, 142, 152, 162]
            #             ColEnds   = [ 9, 20, 31, 41, 51, 61, 71, 81, 91, 101, 111, 121, 131, 141, 151, 161, 171]
            #             ColNames  = ['Date', 'TimeString', 'TubeTemp', 'PrimaryTemp', 'SecTemp', 'FanPower', 'FocusPos',
            #                          'SkyTemp', 'OutsideTemp', 'WindSpeed', 'Humidity', 'DewPoint', 'Altitude', 'Azimuth',
            #                          'Condition', 'DomeTemp', 'DomeFanState']
            #             env_table = ascii.read(logfile, data_start=2, Reader=ascii.FixedWidth,
            #                           col_starts=ColStarts, col_ends=ColEnds, names=ColNames,
            #                           guess=False, comment=";", header_start=0,
            #                           converters={
            #                           'Date': [ascii.convert_numpy('S10')],
            #                           'TimeString': [ascii.convert_numpy('S10')],
            #                           'TubeTemp': [ascii.convert_numpy('f4')],
            #                           'SecTemp': [ascii.convert_numpy('f4')],
            #                           'FanPower': [ascii.convert_numpy('f4')],
            #                           'FocusPos': [ascii.convert_numpy('i4')],
            #                           'SkyTemp': [ascii.convert_numpy('f4')],
            #                           'OutsideTemp': [ascii.convert_numpy('f4')],
            #                           'WindSpeed': [ascii.convert_numpy('f4')],
            #                           'Humidity': [ascii.convert_numpy('i4')],
            #                           'DewPoint': [ascii.convert_numpy('f4')],
            #                           'Altitude': [ascii.convert_numpy('f4')],
            #                           'Azimuth': [ascii.convert_numpy('f4')],
            #                           'Condition': [ascii.convert_numpy('S3')],
            #                           'DomeTemp': [ascii.convert_numpy('f4')],
            #                           'DomeFanState': [ascii.convert_numpy('i4')]
            #                           }
            #                           )

            with open(logfile, "r") as FO:
                env_table = FO.readlines()

            for line in env_table:
                if line[0] != "#":
                    try:
                        entry = line.split()
                        new_data = {}
                        ## Date and Time
                        dto_utc = dt.strptime("{} {}".format(entry[0], entry[1]), "%Y/%m/%d %H:%M:%SUT")
                        dto_hst = dto_utc - tdelta(0, 10 * 60 * 60)
                        new_data.update(
                            {
                                "UT date": dto_utc.strftime("%Y%m%dUT"),
                                "UT time": dto_utc.strftime("%H:%M:%S"),
                                "UT timestamp": dto_utc,
                            }
                        )
                        ## Define Boltwood Data
                        boltwood = {}
                        boltwood["boltwood date"] = dto_hst.strftime("%Y-%m-%d")  # local date (yyyy-mm-dd)
                        boltwood["boltwood time"] = dto_hst.strftime("%H:%M:%S.00")  # local time (hh:mm:ss.ss)
                        boltwood["boltwood timestamp"] = dto_hst
                        boltwood["boltwood temp units"] = "F"
                        boltwood["boltwood wind units"] = "K"
                        boltwood["boltwood sky temp"] = float(entry[7])
                        boltwood["boltwood ambient temp"] = float(entry[8])
                        boltwood["boltwood wind speed"] = float(entry[9])
                        boltwood["boltwood humidity"] = int(entry[10])
                        boltwood["boltwood dew point"] = float(entry[11])
                        boltwood["boltwood rain condition"] = int(entry[14][0])
                        boltwood["boltwood cloud condition"] = int(entry[14][1])
                        boltwood["boltwood wind condition"] = int(entry[14][2])
                        new_data.update(boltwood)
                        ## Define Focuser Data
                        focuser_info = {}
                        focuser_info["RCOS temperature units"] = "F"
                        focuser_info["RCOS temperature (truss)"] = float(entry[2])
                        focuser_info["RCOS temperature (primary)"] = float(entry[3])
                        focuser_info["RCOS temperature (secondary)"] = float(entry[4])
                        focuser_info["RCOS fan speed"] = int(entry[5])
                        focuser_info["RCOS focuser position"] = int(entry[6])
                        new_data.update(focuser_info)
                    except:
                        print(entry)
                        raise

                    ##-------------------------------------------------------------------------
                    ## Write Environmental Log
                    ##-------------------------------------------------------------------------
                    ## Check if this image is already in the collection
                    matches = [item for item in V20status.find({"UT timestamp": new_data["UT timestamp"]})]
                    if len(matches) > 0:
                        logger.debug(
                            "    Found {} previous entries for {} {}.  Deleting old entries.".format(
                                len(matches), new_data["UT date"], new_data["UT time"]
                            )
                        )
                        for match in matches:
                            logger.debug("    Removing entry for {} {}".format(match["UT date"], match["UT time"]))
                            V20status.remove({"_id": match["_id"]})
                            logger.debug('    Removed "_id": {}'.format(match["_id"]))

                    id = V20status.insert(new_data)
                    logger.info(
                        "    Inserted datum for {} on {} {}".format(telescope, new_data["UT date"], new_data["UT time"])
                    )

        make_nightly_plots.make_plots(date_string, "V20", logger)

        date += oneday
Exemplo n.º 57
0
c = SkyCoord.from_name('HR8799', frame='fk5')

hdu = fits.PrimaryHDU(data_cube)
metadata = {'SEQID': seq_id,
            'FIELD': target_name,
            'RA': c.ra.to(u.degree).value,
            'DEC': c.dec.to(u.degree).value,
            'EQUINOX': c.equinox.value,
            'OBSTIME': obstime.isoformat(),
            'XPIXORG': xpixorg,
            'YPIXORG': ypixorg,
            }

for t in range(nt):
    # slightly randomize time gap between images
    gap = tdelta(0, exptime + np.random.normal(5, 1))
    obstime = obstime + gap
    metadata['TIME{:04d}'.format(t)] = obstime.isoformat()
hdu.header.extend(metadata)
print(metadata)

hdu.writeto('PSC_0002.fits', clobber=True)

# Generate Fake Lightcurve
with open('PSC_0002.json', 'w') as FO:
    data = []
    for t in range(nt):
        time = hdu.header['TIME{:04d}'.format(t)]
        sig_r = 0.010
        sig_g = 0.006
        sig_b = 0.017
Exemplo n.º 58
0
def get_day(days=0, hours=0):
    today = dtime.now()
    newday = today+tdelta(days=days, hours=hours)
    return newday