def getCorrectBackground(self): if self.Weather == None: return "day-sunny" city_name = 'London' a = Astral() a.solar_depression = 'civil' city = a[city_name] now = datetime.datetime.utcnow().replace(tzinfo=utc) sun = city.sun(date=datetime.datetime.now(), local=True) if now < sun['dawn']: #night return self.getNightBackground() elif now < sun['sunrise']: #sunrise return self.getSunSetRiseBackground() elif now < sun['sunset']: #day return self.getDayBackground() elif now < sun['dusk']: #sunset return self.getSunSetRiseBackground() else: #night return self.getNightBackground()
def __init__(self): self.hardware = Hardware() a = Astral() a.solar_depression = 'civil' self.city = a['Kiev'] self.rpc_server = RPCServer(self.hardware) self.rpc_server.start()
async def async_update(self): try: date_offset = date.today() + relativedelta( **{self._date_units: self._date_value}) city_name = self._city a = Astral() a.solar_depression = 'civil' city = a[city_name] s2 = city.sun(date=date_offset, local=False) time_offset = relativedelta(**{self._time_units: self._time_value}) relative_sunrise = (s2["sunrise"] + time_offset) relative_sunset = (s2["sunset"] + time_offset) diff = relative_sunset - relative_sunrise diff_hours = diff.seconds / 3600 self.attrs[ATTR_CITY] = city.name self.attrs[ATTR_REGION] = city.region self.attrs[ATTR_TIMEZONE] = city.timezone self.attrs[ATTR_LAT] = city.latitude self.attrs[ATTR_LONG] = city.longitude self.attrs[ATTR_SUNRISE] = str( relative_sunrise.strftime('%H:%M:%S')) self.attrs[ATTR_SUNSET] = str(relative_sunset.strftime('%H:%M:%S')) self.attrs[ATTR_HOURS_IN_DAY] = diff_hours self._available = True except (ClientError, gidgethub.GitHubException): self._available = False _LOGGER.exception("Error calculating multisun data.")
def jobUpdateAstral(): a = Astral() a.solar_depression = myDepression city = a[myCity] sun = city.sun(date=datetime.date(datetime.datetime.today().year, datetime.datetime.today().month, datetime.datetime.today().day), local=True) duskh = str(sun['dusk'])[11:13] duskm = str(sun['dusk'])[14:16] dusk = duskh + ":" + duskm logging.debug("New %s dusk in %s is set to %s", myDepression, myCity, dusk) dawnh = str(sun['dawn'])[11:13] dawnm = str(sun['dawn'])[14:16] dawn = dawnh + ":" + dawnm logging.debug("New %s dawn in %s is set to %s", myDepression, myCity, dawn) for s in mySwitches: if s.Type == "Sun": s.Stop() s.timeOn = dusk s.timeOff = dawn logging.info(">>> Astral updated %s and %s", dusk, dawn) s.Start()
def is_over_sunset() -> bool: astral = Astral() astral.solar_depression = 'civil' sun = astral['Bucharest'].sun(date=datetime.datetime.now(), local=True) currentTime = datetime.datetime.now(timezone(general.timezone)).time() return currentTime > sun['sunset'].time()
def get_daylight_details(): """Get details of solar path/daylight hours at site for today (local)""" # Instantiating Astral object (for calculating position of sun and moon) a = Astral() a.solar_depression = 'civil' # Instantiating an Astral location (hard-coded here since dealing with one site only, but # easily scalable if site required login and site lat and long were tied to user profile) l = Location() l.latitude = 37.8195 l.longitude = -122.2523 l.timezone = 'US/Pacific' l.elevation = 125 sunrise = l.sunrise().strftime('%-I:%M%p') sunset = l.sunset().strftime('%-I:%M%p') day_length = str(l.sunset() - l.sunrise()) solar_noon = l.solar_noon().strftime('%-I:%M%p') solar_zenith = l.solar_elevation(l.solar_noon().replace(tzinfo=None)) solar_elevation = l.solar_elevation() daylight_data = { 'sunrise': sunrise, 'sunset': sunset, 'daylength': day_length, 'solar_noon': solar_noon, 'zenith': solar_zenith, 'elevation': solar_elevation } return jsonify(daylight_data)
def darkness_comes(): ''' return true if the sun has set in Columbus ''' if ALWAYS_DARK: return True city_name = 'Columbus' a = Astral() a.solar_depression = 'civil' city = a[city_name] timezone = city.timezone sun_today = city.sun(date=datetime.datetime.now(), local=True) sunrise_today = sun_today['sunrise'] sunset_today = sun_today['sunset'] sun_tomorrow = city.sun(date=datetime.datetime.today() + datetime.timedelta(days=1), local=True) sunrise_tomorrow = sun_tomorrow['sunrise'] sunset_tomorrow = sun_tomorrow['sunset'] current_time = datetime.datetime.now(pytz.timezone('America/New_York')) # dark means it's earlier than sunrise or later than sunset if (current_time < sunrise_today) or (current_time > sunset_today and current_time < sunrise_tomorrow): # sun is down! return True else: # sun is up! return False
def get_astral_data(for_datetime): ''' Returns the sunrise and sunset times for the given date. Uses the Astral package to compute sunrise/sunset for the configured city. Reference https://pythonhosted.org/astral/module.html :param for_datetime: :return: Returns a dict containing the keys sunrise and sunset. The values are datetime objects. ''' a = Astral() a.solar_depression = "civil" # We use a city just to get a city object. Then we override the lat/long. # The city object can produce sunrise/sunset in local time. if Configuration.City() != "": city = a[Configuration.City()] else: # Default if no city is configured city = a["New York"] if Configuration.Latitude() != "": city.latitude = float(Configuration.Latitude()) if Configuration.Longitude() != "": city.longitude = float(Configuration.Longitude()) return city.sun(date=for_datetime, local=True)
def ics(): astral = Astral() astral.solar_depression = "civil" astral.depression = 6.0 city = astral["Toronto"] cal = Calendar() cal.add("prodid", "-//Time of Day//time-of-day.herokuapp.com//") cal.add("version", "2.0") today = datetime.date.today() for x in range(-7, 8): date = today + datetime.timedelta(days=x) sun = city.sun(date=date, local=True) for summary, time in sun.items(): event = Event() event.add("summary", summary.capitalize()) event.add("dtstart", time) event.add("dtend", time) event.add("dtstamp", time) cal.add_component(event) resp = make_response(cal.to_ical()) resp.headers["Content-Disposition"] = "attachment; filename=time-of-day.ics" resp.headers["Content-Type"] = "text/calendar" return resp
def initialize(self): self.city_name = 'Sofia' a = Astral() a.solar_depression = 'civil' self.city = a[self.city_name] self.timezone = self.city.timezone self.sun_info = self.city.sun(date=date.today(), local=True)
def calc_sunlight() -> int: """ Calculate an appropriate brightness for the bulb depending on current sunlight. :return: White brightness """ a = Astral() a.solar_depression = 'civil' city = a[settings.LOCATION] sun = city.sun(date=datetime.now(), local=True) dt = datetime.now(sun['sunrise'].tzinfo) if dt.hour < 4 or dt.hour >= 22: return {'red': 255} elif dt < sun['sunrise']: return { 'white': 255 - (sun['sunrise'] - dt).total_seconds() / 3600 * 200 / 6 } elif dt > sun['sunset']: return { 'white': 255 - (dt - sun['sunset']).total_seconds() / 3600 * 200 / 6 } else: return {'white': 255}
def calculateSupply(nowTime, sampleTime, maxtime, numberOfHours, solarPower): # sample time is in minutes # returns an array of estimated energy units for each time sample # starting at nowTime maxTime = maxtime # return [0 for i in range(0, maxTime)] ############################# astral = Astral() astral.solar_depression = 'civil' city = astral['Salt Lake City'] # array of sky clear length maxTime, 1.0 is totally clear, 0 is cloudy clearSky = getSkyClear(nowTime, numberOfHours, sampleTime) # print "clear" # print clearSky sunStrength = getSunStrength(city, nowTime, numberOfHours, sampleTime) # print "sun Strength" print(len(sunStrength)) onePower = [ sunEstimate(sunStrength[i], clearSky[i]) * solarPower for i in range(0, maxTime) ] # print "one Power" # print onePower # supply = [calculateOneTimeEnergy(onePower[i], sampleTime, energySample) for i in range(0, maxTime)] # print supply return onePower
def getSolarInfo(): a = Astral() a.solar_depression = 'civil' city = a['Seattle'] timezone = city.timezone sun = city.sun(date=datetime.datetime.now()) return sun
def get_sundown(target_date): a = Astral() a.solar_depression = 'civil' locale = a[city] sun = locale.sun(date=datetime.date(target_date.year, target_date.month, target_date.day), local=True) return sun['sunset']
def graph_values(diff_array): graph_data = [] graph_dates = [] sum_value = 0 index = 0 current_hour = plot_dates[0].hour sun_indexes = [] city_name = 'Stockholm' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(plot_dates[0], local=True) graph_dates.append(plot_dates[0].strftime('%Y-%m-%d %H:%M:%S')) if (plot_dates[index].hour >= sun['sunrise'].hour and plot_dates[index].hour <= sun['sunset'].hour): sun_indexes.append(1) else: sun_indexes.append(0) for data in diff_array: if (plot_dates[index].hour > current_hour): graph_data.append(sum_value) sum_value = 0 sum_value = sum_value + int(data) current_hour = current_hour + 1 if (plot_dates[index].hour >= sun['sunrise'].hour and plot_dates[index].hour <= sun['sunset'].hour): sun_indexes.append(1) else: sun_indexes.append(0) graph_dates.append(plot_dates[index].strftime('%Y-%m-%d %H:%M:%S')) elif (plot_dates[index].hour < current_hour): graph_data.append(sum_value) sum_value = 0 sum_value = sum_value + int(data) current_hour = plot_dates[index].hour sun = city.sun(plot_dates[index], local=True) if (plot_dates[index].hour >= sun['sunrise'].hour and plot_dates[index].hour <= sun['sunset'].hour): sun_indexes.append(1) else: sun_indexes.append(0) graph_dates.append(plot_dates[index].strftime('%Y-%m-%d %H:%M:%S')) else: sum_value = sum_value + int(data) index = index + 1 graph_data.append(sum_value) return graph_dates, graph_data, sun_indexes
def get_sunrise_sunset(): city = 'San Francisco' a = Astral() a.solar_depression = 'civil' city = a[city] sun = city.sun(date=datetime.now(), local=True) if now() >= sun['sunset']: sun = city.sun(date=datetime.now()+timedelta(days=1), local=True) return sun['sunrise'], sun['sunset']
def draw_astronomical(city_name, geo_data): datetime_day_start = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0) a = Astral() a.solar_depression = 'civil' city = Location() city.latitude = geo_data["latitude"] city.longitude = geo_data["longitude"] city.timezone = geo_data["timezone"] answer = "" moon_line = "" for time_interval in range(72): current_date = (datetime_day_start + datetime.timedelta(hours=1 * time_interval)).replace( tzinfo=pytz.timezone(geo_data["timezone"])) sun = city.sun(date=current_date, local=False) dawn = sun['dawn'] # .replace(tzinfo=None) dusk = sun['dusk'] # .replace(tzinfo=None) sunrise = sun['sunrise'] # .replace(tzinfo=None) sunset = sun['sunset'] # .replace(tzinfo=None) if current_date < dawn: char = " " elif current_date > dusk: char = " " elif dawn < current_date and current_date < sunrise: char = u"─" elif sunset < current_date and current_date < dusk: char = u"─" elif sunrise < current_date and current_date < sunset: char = u"━" answer += char # moon if time_interval % 3 == 0: moon_phase = city.moon_phase( date=datetime_day_start + datetime.timedelta(hours=time_interval)) moon_phase_emoji = constants.MOON_PHASES[ int(math.floor(moon_phase * 1.0 / 28.0 * 8 + 0.5)) % len(constants.MOON_PHASES)] if time_interval in [0, 24, 48, 69]: moon_line += moon_phase_emoji + " " else: moon_line += " " answer = moon_line + "\n" + answer + "\n" answer += "\n" return answer
def sunrise_time(): from astral import Astral astr_object = Astral() astr_object.solar_depression = "civil" try: return astr_object[CITY].sun(local=True)["sunrise"] except Exception as error: ErrorWriter.write_error(error) return None
def get_sun(date="today", depression="astronomical", cityname="Boston"): astral = Astral() astral.solar_depression = depression city = astral[cityname] calendar = parsedatetime.Calendar() dateinfo = calendar.parse(date) date_ts = time.mktime(dateinfo[0]) date_dt = datetime.fromtimestamp(date_ts) return city.sun(date=date_dt, local=True)
def sunset(): city_name = 'Minneapolis' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=datetime.datetime.now(), local=True) return 'Sunset for {}: {}'.format(city_name, sun['sunset'])
def api_v1(): astral = Astral() astral.solar_depression = "civil" astral.depression = 6.0 city = astral["Toronto"] response = { "is_day": False, "is_night": False, "is_civil_twlight": False, "is_nautical_twlight": False, "is_astronomical_twilight": False, "is_blue_hour": False, "is_golden_hour": False, "solar_zenith_angle": city.solar_zenith(), "solar_elevation_angle": city.solar_elevation(), "solar_azimuth_angle": city.solar_azimuth(), "times_of_day": city.sun(), } current_datetime = datetime.datetime.now(city.tz) if city.sunrise() < current_datetime < city.sunset(): response["is_day"] = True else: response["is_night"] = True if -6 <= city.solar_zenith() <= 0: response["is_civil_twlight"] = True response["is_day"] = False response["is_night"] = False elif -12 <= city.solar_zenith() <= -6: response["is_nautical_twlight"] = True response["is_day"] = False response["is_night"] = False elif -18 <= city.solar_zenith() <= -12: response["is_astronomical_twilight"] = True response["is_day"] = False response["is_night"] = False if -6 <= city.solar_zenith() <= -4: response["is_blue_hour"] = True elif -4 <= city.solar_zenith() <= 6: response["is_golden_hour"] = True if 0 <= city.moon_phase() < 7: response["moon_phase"] = "new-moon" elif 7 <= city.moon_phase() < 14: response["moon_phase"] = "first-quarter" elif 14 <= city.moon_phase() < 21: response["moon_phase"] = "full-moon" elif 21 <= city.moon_phase(): response["moon_phase"] = "last-quarter" return jsonify(response)
def sun(request): """ Return sunrise, sunset etc. times. """ a = Astral() a.solar_depression = 'civil' l = Location() # l.name = 'Lapinlahden sairaala' # l.region = 'Helsinki' lat = request.GET.get('lat') lon = request.GET.get('lon') if lat is None or lon is None: l.latitude = 60.167761 l.longitude = 24.9118141 l.loc_source = 'default' else: l.latitude = float(lat) l.longitude = float(lon) l.loc_source = 'request' l.timezone = 'UTC' l.elevation = 0 timeformat = request.GET.get('timeformat', 'epoch') date_str = request.GET.get('date') format_str = request.GET.get('format', 'json') date = datetime.datetime.now().date() if date_str is not None: date = parse(date_str).date() pass sundata = { 'now': datetime.datetime.now(tz=pytz.UTC), # .astimezone(pytz.UTC), 'date': date.strftime('%Y-%m-%d'), 'lat': l.latitude, 'lon': l.longitude, 'loc_source': l.loc_source, } try: sun = l.sun(date=date, local=False) except AstralError as e: return HttpResponse(json.dumps({'error': str(e)}), content_type='application/json') for k in ['dawn', 'sunrise', 'noon', 'sunset', 'dusk']: sundata[k] = sun[k] if timeformat == 'iso': for k in sundata.keys(): if isinstance(sundata[k], datetime.datetime): sundata[k] = sundata[k].isoformat() else: # timeformat == 'epoch': for k in sundata.keys(): if isinstance(sundata[k], datetime.datetime): sundata[k] = int(sundata[k].timestamp()) res_str = json.dumps(sundata, indent=2) return HttpResponse(res_str, content_type='application/json')
def its_after_sunset(city_name): a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=date.today(), local=True) sunset_today = (sun['sunset']).replace(tzinfo=None) if sunset_today < datetime.today(): return True else: return False
def SetSunTimes(): cityName = "London" a = Astral() a.solar_depression = "civil" city = a[cityName] sun = city.sun(date=datetime.now(), local=True) variables.Set("dawn", str(sun['dawn'].strftime("%H:%M"))) variables.Set("sunrise", str(sun['sunrise'].strftime("%H:%M"))) variables.Set("sunset", str(sun['sunset'].strftime("%H:%M"))) variables.Set("dusk", str(sun['dusk'].strftime("%H:%M")))
def get_sun(): a = Astral() a.solar_depression = 'civil' city = a['Helsinki'] sun = city.sun(date=datetime.now(), local=True) sunset = sun['dusk'] sun = city.sun(date=datetime.now() + timedelta(days=1), local=True) sunrise = sun['dawn'] return sunrise, sunset
def sun_api(): data = {} city_name = 'Denver' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=dt.datetime.today(), local=True) data = {k: sun[k].hour * 60 + sun[k].minute for k in sun} data['moon_phase'] = city.moon_phase() return data
def its_between_dawn_sunset(city_name): a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=date.today(), local=True) dawn_today = (sun['dawn']).replace(tzinfo=None) sunset_today = (sun['sunset']).replace(tzinfo=None) if (dawn_today < datetime.today()) and (sunset_today > datetime.today()): return True else: return False
def check_if_dark(): from astral import Astral city_name = 'Kiev' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=datetime.datetime.now(), local=True) T = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=2))) if (sun['sunrise'] < T < sun['sunset']): return False return True
def its_light_in(city_name): a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=date.today(), local=True) dawn_today = (sun['dawn']).replace(tzinfo=None) if dawn_today < datetime.today(): return True else: return False
def __init__(self): city_name = config.get('ASTRA_CITY') a = Astral() a.solar_depression = 'civil' self.__city = a[city_name] self.__today = None self.__sun = None self.__mode = None self.__timezone = pytz.timezone(self.__city.timezone) self.is_day()
def auto(self, action: str = 'on', sun_state: str = 'sunset', offset: int = 0): a = Astral() a.solar_depression = 'civil' city = a[settings.LOCATION] sun = city.sun(date=datetime.now(), local=True) if datetime.now(sun[sun_state].tzinfo) >= sun[sun_state] + timedelta( seconds=offset): {'on': self.on, 'off': self.off}[action]()
def initAstral(self): a = Astral() a.solar_depression = 'civil' l = Location() l.name = 'Dolbeau-Mistassini' l.region = 'Canada' l.latitude = 48.9016 l.longitude = -72.2156 l.timezone = 'America/Montreal' l.elevation = 139 self.location = l
def sunyears(start_year, end_year): city_name = 'London' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun_times = {} print('Information for %s/%s\n' % (city_name, city.region)) timezone = city.timezone print('Timezone: %s' % timezone) print(' Latitude: %.02f; Longitude: %.02f\n' % (city.latitude, city.longitude)) delta = datetime.timedelta(days=1) for year in range(start_year, end_year + 1): # Loop through all days in year start_date = datetime.date(year, 1, 1) end_date = datetime.date(year, 12, 31) d = start_date while d <= end_date: sun = city.sun(d, local=True) # print('Dawn: %s' % str(sun['dawn'])) # print('Sunrise: %s' % str(sun['sunrise'])) # print('Noon: %s' % str(sun['noon'])) # print('Sunset: %s' % str(sun['sunset'])) # print('Dusk: %s' % str(sun['dusk'])) # pprint(sun) sun_times[json_serial(d)] = sun # print(json.dumps(sun_times, default=json_serial, # indent=4, sort_keys=True)) d += delta # print(json.dumps(sun_times, default=json_serial)) outfilename = "suntimes-{}-{}".format(start_year, end_year) outfilename = os.path.join("data", outfilename) mkdir("data") with open(outfilename + ".json", "w") as outfile: json.dump(sun_times, outfile, default=json_serial, indent=4, separators=(',', ': '), sort_keys=True) with open(outfilename + ".min.json", "w") as outfile: json.dump(sun_times, outfile, default=json_serial)
def setup_location(): global city city_name = 'Bucharest' a = Astral() a.solar_depression = 'civil' city = a[city_name] print('Solar data for %s/%s\n' % (city_name, city.region)) timezone = city.timezone print('Timezone: %s' % timezone)
def SunUpDown(location): a = Astral() a.solar_depression = 'civil' timezone = location.timezone Now = strftime("%H:%M", localtime()) dt = datetime.datetime.fromtimestamp(time.mktime(localtime())) tz = pytz.timezone("Europe/Berlin") dtn = tz.localize(dt) dtnT = dtn + datetime.timedelta(days=1) sun = location.sun(dtn, local=True) sunT = location.sun(dtnT, local=True) if (sun['sunrise'].hour < 10): Sunrise = '0' + str(sun['sunrise'].hour) + ':' else: Sunrise = str(sun['sunrise'].hour) + ':' if (sun['sunrise'].minute < 10): Sunrise = Sunrise + '0' + str(sun['sunrise'].minute) else: Sunrise = Sunrise + str(sun['sunrise'].minute) if (sunT['sunrise'].hour < 10): SunriseT = '0' + str(sunT['sunrise'].hour) + ':' else: SunriseT = str(sunT['sunrise'].hour) + ':' if (sunT['sunrise'].minute < 10): SunriseT = SunriseT + '0' + str(sunT['sunrise'].minute) else: SunriseT = SunriseT + str(sunT['sunrise'].minute) if (sun['sunset'].hour < 10): Sunset = '0' + str(sun['sunset'].hour) + ':' else: Sunset = str(sun['sunset'].hour) + ':' if (sun['sunset'].minute < 10): Sunset = Sunset + '0' + str(sun['sunset'].minute) else: Sunset = Sunset + str(sun['sunset'].minute) if (sunT['sunset'].hour < 10): SunsetT = '0' + str(sunT['sunset'].hour) + ':' else: SunsetT = str(sunT['sunset'].hour) + ':' if (sunT['sunset'].minute < 10): SunsetT = SunsetT + '0' + str(sunT['sunset'].minute) else: SunsetT = SunsetT + str(sunT['sunset'].minute) ''' print sun['sunrise'], sun['sunset'] print print sunT['sunrise'], sunT['sunset'] print '-------------' ''' return Sunrise, Sunset, SunriseT, SunsetT, sun['sunrise'], sun['sunset'], ( (dtn > sun['sunrise']) and (dtn < sun['sunset']))
def test_Astral(): location_name = 'Jubail' dd = Astral() dd.solar_depression = 'civil' location = dd[location_name] assert location.timezone == 'Asia/Riyadh' sun = location.sun() sunrise = location.sunrise(local=True) assert sunrise == sun['sunrise']
def __init__(self, timeInterval, keepRunning): self.log = logging.getLogger('status_archiver') self.logfile = path +'status_' + datetime.datetime.now().strftime('%m-%d-%y') + '.log' city_name = 'San Francisco' a = Astral() a.solar_depression = 'astronomical' city = a[city_name] timezone = city.timezone sun = city.sun(date=datetime.date(2009, 4, 22), local=True) self.start = sun['dusk'] self.stop = sun['dawn']
def main(): a = Astral() a.solar_depression = 'civil' city = a['Birmingham'] timezone = city.timezone sun = city.sun(date=datetime.date.today(), local=True) if is_light_outside(sun['dawn'], sun['dusk']): logger.info("Its light outside, switching off...") switch_off() else: logger.info("Its dark outside, switching on...") switch_on()
def get_light_state(self): astral = Astral() astral.solar_depression = "civil" astral_city = astral["Perth"] now = datetime.datetime.now(pytz.timezone('Australia/Perth')) astral_city_sun = astral_city.sun(date=now, local=True) if (astral_city_sun['sunrise'] - datetime.timedelta(hours=1)) < now < astral_city_sun['sunset']: return "daylight" elif 1 <= now.hour <= 5: return "witching" else: return "evening"
def getSunTimes(): city_name = TIMING_CITY a = Astral() a.solar_depression = 'civil' city = a[city_name] timezone = city.timezone sun = city.sun(date=datetime.datetime.now(), local=True) sunriseSeconds = ((sun['sunrise']).hour * 60 * 60) + ( (sun['sunrise']).minute * 60) sunsetSeconds = ((sun['sunset']).hour * 60 * 60) + ( (sun['sunset']).minute * 60) return sunriseSeconds, sunsetSeconds
def plot_nightshade(df, ax, **kwargs): a = Astral() a.solar_depression = 'civil' city = a['wellington'] ymin, ymax = ax.get_ylim() for day in pd.date_range(df.index[0].date(), df.index[-1].date()): sun1 = city.sun(date=day - dt.timedelta(days=1)) sun2 = city.sun(date=day, local=True) sunset = sun1['sunset'].replace(tzinfo=None) sunrise = sun2['sunrise'].replace(tzinfo=None) night = pd.DataFrame(index=[sunset, sunrise], data=dict(shade=[ymax, ymax])) night.shade.plot(kind='area', ax=ax, color='0.9', alpha=0.5, **kwargs)
def sunyears(start_year, end_year): city_name = 'London' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun_times = {} print('Information for %s/%s\n' % (city_name, city.region)) timezone = city.timezone print('Timezone: %s' % timezone) print(' Latitude: %.02f; Longitude: %.02f\n' % (city.latitude, city.longitude)) delta = datetime.timedelta(days=1) for year in range(start_year, end_year+1): # Loop through all days in year start_date = datetime.date(year, 1, 1) end_date = datetime.date(year, 12, 31) d = start_date while d <= end_date: sun = city.sun(d, local=True) # print('Dawn: %s' % str(sun['dawn'])) # print('Sunrise: %s' % str(sun['sunrise'])) # print('Noon: %s' % str(sun['noon'])) # print('Sunset: %s' % str(sun['sunset'])) # print('Dusk: %s' % str(sun['dusk'])) # pprint(sun) sun_times[json_serial(d)] = sun # print(json.dumps(sun_times, default=json_serial, # indent=4, sort_keys=True)) d += delta # print(json.dumps(sun_times, default=json_serial)) outfilename = "suntimes-{}-{}".format(start_year, end_year) outfilename = os.path.join("data", outfilename) mkdir("data") with open(outfilename + ".json", "w") as outfile: json.dump(sun_times, outfile, default=json_serial, indent=4, separators=(',', ': '), sort_keys=True) with open(outfilename + ".min.json", "w") as outfile: json.dump(sun_times, outfile, default=json_serial)
def getRainLevel(self): if self.Weather == None: return "norain" city_name = 'London' a = Astral() a.solar_depression = 'civil' city = a[city_name] now = datetime.datetime.utcnow().replace(tzinfo=utc) sun = city.sun(date=datetime.datetime.now(), local=True) if now < sun['dawn']: #night weatherNum = self.Weather.getWeatherTypeNum(0, 1) elif now < sun['sunrise']: #sunrise weatherNum = self.Weather.getWeatherTypeNum() elif now < sun['sunset']: #day weatherNum = self.Weather.getWeatherTypeNum() elif now < sun['dusk']: #sunset weatherNum = self.Weather.getWeatherTypeNum(0, 1) else: #night weatherNum = self.Weather.getWeatherTypeNum(0, 1) if 0 <= int(weatherNum) <= 8: return "norain" elif 9 <= int(weatherNum) <= 10: return "lightrain" elif int(weatherNum) == 11: return "drizzel" elif int(weatherNum) == 12: return "lightrain" elif 13 <= int(weatherNum) <= 15: return "heavyrain" elif 16 <= int(weatherNum) <= 27: return "norain" elif 28 <= int(weatherNum) <= 29: return "heavyrain" else: return "norain"
def func(self): """Display information about server or target""" account = self.account city_name = 'Phoenix' if not self.args else self.args a = Astral() a.solar_depression = 'civil' city = a[city_name] if not city: return timezone = city.timezone sun = city.sun(date=datetime.date.today(), local=True) account.msg('Information for %s/%s\n' % (city_name, city.region)) account.msg('Timezone: %s' % timezone) account.msg('Latitude: %.02f; Longitude: %.02f' % (city.latitude, city.longitude)) account.msg('Dawn: %s' % str(sun['dawn'])) account.msg('Sunrise: %s' % str(sun['sunrise'])) account.msg('Noon: %s' % str(sun['noon'])) account.msg('Sunset: %s' % str(sun['sunset'])) account.msg('Dusk: %s' % str(sun['dusk']))
def special_case(table,column,data,index,repeats): print 'special_case funk\n' """This function treats the rain and sun categories different from the others, because they can have repeating zeros. The RAd_Flux can only have a certain number of zeores thought, whereas the rain columns can have unlimited zeros. """ special_case = False if (column == 'RAIN_IN_TOTAL_Tot' and data[column][index] == 0) or (column == 'PRC_Tot' and data[column][index] <= .02): special_case = True if column == 'RAD_FLUX': repeat_times = [pd.to_datetime(t) for t in list(data['TmStamp'][index - (repeats - 1):index + 1])] city_name = 'Chicago' a = Astral() a.solar_depression = 'civil' city = a[city_name] sun = city.sun(date=repeat_times[-1], local=True) # get rid of timezone awareness to be able to compare the repeating # datetimes which are timezone unaware by reinstantiating them as new datetime objects dawn = datetime(sun['dawn'].year,sun['dawn'].month,sun['dawn'].day ,sun['dawn'].hour,round_minutes(sun['dawn'].minute)) dusk = sun['dusk'] - timedelta(days=1) dusk = datetime(dusk.year,dusk.month,dusk.day,dusk.hour,round_minutes(dusk.minute)) night_overlap_allowance = 8 #allowed to be repeating 2 hrs before or after dawn/dusk # Check to see if all/majority of repeating times fall within the nighttime # If so, then the repeats are ignored if repeat_times[0] >= dusk and repeat_times[-1] <= dawn: special_case = True if repeat_times[0] < dusk and repeat_times[-1] > dusk and repeat_times[-1] <= dawn: len_prior_to_dusk = len(repeat_times[:repeat_times.index(dusk)]) if len_prior_to_dusk < night_overlap_allowance: special_case = True if repeat_times[0] >= dusk and repeat_times[0] < dawn and repeat_times[-1] > dawn: len_prior_to_dawn = len(repeat_times[repeat_times.index(dawn) + 1:]) if len_prior_to_dawn < night_overlap_allowance: special_case = True if special_case: return True else: return False
def UpdateFile(sfile,scity): import datetime from astral import Astral a = Astral() a.solar_depression = 'civil' city = a[scity] sun = city.sun(date=datetime.date.today(), local=True) ok=1 try: datafile = open(sfile,'w') except: ok=0 if ok == 1: datafile.write(strftime('%H%M%S',datetime.datetime.timetuple(sun['dawn']))+'\n') datafile.write(strftime('%H%M%S',datetime.datetime.timetuple(sun['sunrise']))+'\n') datafile.write(strftime('%H%M%S',datetime.datetime.timetuple(sun['noon']))+'\n') datafile.write(strftime('%H%M%S',datetime.datetime.timetuple(sun['sunset']))+'\n') datafile.write(strftime('%H%M%S',datetime.datetime.timetuple(sun['dusk']))+'\n') datafile.close()
def testAstral(): city_name = "Jubail" dd = Astral() dd.solar_depression = "civil" city = dd[city_name] assert city.timezone == "Asia/Riyadh" print("Information for %s/%s\n" % (city_name, city.country)) timezone = city.timezone print("Timezone: %s" % timezone) loc_tz = pytz.timezone(timezone) print("Latitude: %.02f; Longitude: %.02f\n" % (city.latitude, city.longitude)) sun = city.sun() sunrise = city.sunrise(local=True) assert sunrise == sun["sunrise"] rahukaalam = city.rahukaalam()
SLEEP_WHEN_DARK = True IMAGE_RESOLUTION = (1600, 1200) #IMAGE_RESOLUTION = (800, 600) MOTION_RESOLUTION = (800, 600) SAVE_MOTION_IMAGES = True CROP_IMAGES = True # Crop to lower half of the image ############################################################ # Setup logging.basicConfig(level=getattr(logging, LOGLEVEL.upper()), filename=os.path.join('images', 'log.txt')) a = Astral() a.solar_depression = 3 location = a['Berlin'] # Cologne: location.latitude = 50.9534001 location.longitude = 6.9548886 location.elevation = 56 motion_mask = matplotlib.image.imread('motion_mask.png')[..., 0] if CROP_IMAGES: motion_mask[:motion_mask.shape[0]//2][...] = 0
#!/usr/bin/python # Schedule the door to close at the end of civil twilight, using the astral library. import os, sys from astral import Astral city_name = 'Seattle' astral = Astral() astral.solar_depression = 'civil' city = astral[city_name] sun = city.sun(local=True) cmd = """echo '%s %s' | at %s""" % (sys.executable, os.path.abspath(os.path.join(os.path.dirname(__file__), 'door/close.py')), sun['dusk'].strftime("%H:%M")) print cmd os.system(cmd)
sun = city.sun(date=t, local=True) if ((t>sun['sunrise']) & (t<sun['sunset'] + timedelta(minutes = 0))): return "day" else: return "night" #======================================================================== city_name = 'Szombathely' a = Astral(GoogleGeocoder) a.solar_depression = 'civil' # civil 6, nautical 12, astronomical 18 city = a[city_name] os.system("ls " + path + "> list.txt") f = open('list.txt','r') for line in f: line = line.rstrip('\n') if line[0]=="2": if (night(line) == "night"): os.system("mv " + path + "/" + line + " " + path + "/night/" + line) print ("%s night %s:%s" %(line, line[8:10], line[10:12])) else: print ("%s day %s:%s" %(line, line[8:10], line[10:12]))
print( "I apologize for my creators limited repository of available cities. He programmed with the WunderGround Api for many hours only to realize that one cant review the history of astronomy... sigh" ) print("\n") city_name = raw_input("Aaaaaaanyways what city would you like to search: ") year = raw_input("Okay good! Now what year: ") month = raw_input("Month: ") day = raw_input("Day: ") a = Astral() a.solar_depression = "civil" city = a[city_name] sun = city.sun(date=datetime.date(int(year), int(month), int(day)), local=True) t1 = str(sun["sunset"]) t1 = t1[11:19] t2 = str(sun["sunrise"]) t2 = t2[11:19] FMT = "%H:%M:%S" start_dt = datetime.datetime.strptime(t2, "%H:%M:%S") end_dt = datetime.datetime.strptime(t1, "%H:%M:%S") diff = end_dt - start_dt colon = str(diff).find(":")
def build_sun(): a = Astral() a.solar_depression = "astronomical" city = a["Stockholm"] return city.sun(date=date.today(), local=True)
#!/usr/bin/env python from __future__ import print_function import time from datetime import datetime from heliotron import Bridge, presets from astral import Astral ## Set up our timezone by feeding in the nearest major city, and then a ## more precise latitude/longitude (optional), to get the most accurate ## sunrise/sunset times as is possible astral = Astral() astral.solar_depression = 'civil' # 6 degrees below horizon city = astral.geocoder['Dallas'] city.latitude = 32.9614 city.longitude = -96.8259 sun = city.sun(date=datetime.now(), local=True) print(city) print('Dawn: %s' % str(sun['dawn'])) print('Sunrise: %s' % str(sun['sunrise'])) print('Sunset: %s' % str(sun['sunset'])) print('Dusk: %s' % str(sun['dusk'])) bridge = Bridge(ip='10.0.0.42', app_name='testscript') lights = bridge.get_lights() ## Set the lights to a jarring, eye-gouging 6500K (over 3 seconds) print('Blinding you...') for light in lights: print('- from %s' % light.name) light.set_kelvin(6500, secs=3)
def main(): syslog.openlog(sys.argv[0]) # Change location to nearest city. location = 'San Diego' # Get the local sunset/sunrise times a = Astral() a.solar_depression = 'civil' city = a[location] timezone = city.timezone sun = city.sun(date=datetime.datetime.now(), local=True) if debug: print 'Information for {}/{}\n'.format(location, city.region) print 'Timezone: {}'.format(timezone) print 'Latitude: {:.02f}; Longitude: {:.02f}\n'.format(city.latitude, city.longitude) print('Dawn: {}'.format(sun['dawn'])) print('Sunrise: {}'.format(sun['sunrise'])) print('Noon: {}'.format(sun['noon'])) print('Sunset: {}'.format(sun['sunset'])) print('Dusk: {}'.format(sun['dusk'])) # Find the bulbs on the LAN scanner = BulbScanner() scanner.scan(timeout=4) # Specific ID/MAC of the bulbs to set porch_info = scanner.getBulbInfoByID('ACCF235FFFEE') livingroom_info = scanner.getBulbInfoByID('ACCF235FFFAA') if porch_info: bulb = WifiLedBulb(porch_info['ipaddr']) bulb.refreshState() timers = bulb.getTimers() # Set the porch bulb to turn on at dusk using timer idx 0 syslog.syslog(syslog.LOG_ALERT, "Setting porch light to turn on at {}:{:02d}".format(sun['dusk'].hour, sun['dusk'].minute)) dusk_timer = LedTimer() dusk_timer.setActive(True) dusk_timer.setRepeatMask(LedTimer.Everyday) dusk_timer.setModeWarmWhite(35) dusk_timer.setTime(sun['dusk'].hour, sun['dusk'].minute) timers[0] = dusk_timer # Set the porch bulb to turn off at dawn using timer idx 1 syslog.syslog(syslog.LOG_ALERT, "Setting porch light to turn off at {}:{:02d}".format(sun['dawn'].hour, sun['dawn'].minute)) dawn_timer = LedTimer() dawn_timer.setActive(True) dawn_timer.setRepeatMask(LedTimer.Everyday) dawn_timer.setModeTurnOff() dawn_timer.setTime(sun['dawn'].hour, sun['dawn'].minute) timers[1] = dawn_timer bulb.sendTimers(timers) else: print "Can't find porch bulb" if livingroom_info: bulb = WifiLedBulb(livingroom_info['ipaddr']) bulb.refreshState() timers = bulb.getTimers() # Set the living room bulb to turn on at sunset using timer idx 0 syslog.syslog(syslog.LOG_ALERT, "Setting LR light to turn on at {}:{:02d}".format(sun['sunset'].hour, sun['sunset'].minute)) sunset_timer = LedTimer() sunset_timer.setActive(True) sunset_timer.setRepeatMask(LedTimer.Everyday) sunset_timer.setModeWarmWhite(50) sunset_timer.setTime(sun['sunset'].hour, sun['sunset'].minute) timers[0] = sunset_timer # Set the living room bulb to turn off at a fixed time off_timer = LedTimer() off_timer.setActive(True) off_timer.setRepeatMask(LedTimer.Everyday) off_timer.setModeTurnOff() off_timer.setTime(23,30) timers[1] = off_timer bulb.sendTimers(timers) else: print "Can't find living room bulb"
weather_timebaseDataset = 3600 #in seconds per interval #Simulation: #number of days to simulate and skipping of initial days. Simulation starts at Sunday January 1. numDays = 365 # number of days startDay = 0 # Initial day #Select the geographic location. Refer to the Astral plugin to see available locations (or give a lon+lat) city_name = 'Amsterdam' a = Astral() a.solar_depression = 'civil' city = a[city_name] #Select the devices in the neighbourhood #Devices #Scale overall consumption: consumptionFactor = 1.0 #consumption was a bit too high #Penetration of emerging technology in percentages #all values must be between 0-100 penetrationEV = 10 penetrationPHEV = 15 penetrationPV = 100
import datetime from astral import Astral if __name__ == '__main__': astral = Astral() city_name = "New York" astral.solar_depression = "civil" city = astral[city_name] sun_data = city.sun(date=datetime.date.today(), local=True) print('Sunset: %s' % str(sun_data['sunset'])) print('Dusk: %s' % str(sun_data['dusk']))
def brightness(city, at=None) -> str: """ :param city: str e.g. "Amsterdam" :param at: datetime :return: str one of the values "night, dawn, day, dusk" depending on the time """ if at is None: at = datetime.datetime.now() astral = Astral() astral.solar_depression = 'nautical' location = astral[city] sun = location.sun(date=at) at = pytz.timezone(location.timezone).localize(at) dawn = sun['dawn'] sunrise = sun['sunrise'] sunset = sun['sunset'] dusk = sun['dusk'] if at >= dawn and at < sunrise: return DAWN if at >= sunrise and at < sunset: return DAY if at >= sunset and at < dusk: return DUSK return NIGHT