Python astral.Astral类代码示例

	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 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 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 __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()

def seconds_till_daytime_ends(lat,lon,delta_minutes):
   if not is_it_daytime(lat,lon,delta_minutes):
       return 0
   now = datetime.now(UTC())
   astral = Astral()
   sunset = astral.sunset_utc(now,lat,lon) - timedelta(minutes=delta_minutes)
   answer = int((sunset-now).total_seconds())+1
   return answer

def getSolarInfo():
    a = Astral()
    a.solar_depression = 'civil'
    city = a['Seattle']
    timezone = city.timezone
    sun = city.sun(date=datetime.datetime.now())

    return sun

class plugin:
    '''
    A class to display the time of sunrise/sunset
    Uses the astral library to retrieve information...
    '''

    def __init__(self, config):
        '''
        Initializations for the startup of the weather forecast
        '''
        # Get plugin name (according to the folder, it is contained in)
        self.name = os.path.dirname(__file__).split('/')[-1]

        self.astral_at_location = Astral()[config.get('plugin_' + self.name, 'location')]

        # Choose language to display sunrise
        language = config.get('plugin_time_default', 'language')
        if language == 'german':
            self.taw = wcp_time_german.time_german()
        elif language == 'dutch':
            self.taw = wcp_time_dutch.time_dutch()
        elif language == 'swiss_german':
            self.taw = wcp_swiss_german.time_swiss_german()
        else:
            print('Could not detect language: ' + language + '.')
            print('Choosing default: german')
            self.taw = wcp_time_german.time_german()

        self.bg_color_index     = 0 # default background color: black
        self.word_color_index   = 2 # default word color: warm white
        self.minute_color_index = 2 # default minute color: warm white

    def run(self, wcd, wci):
        '''
        Displaying current time for sunrise/sunset
        '''
        # Get data of sunrise
        sun_data = self.astral_at_location.sun(date=datetime.datetime.now(), local=True)
        # Display data of sunrise
        wcd.animate(self.name, 'sunrise', invert=True)
        wcd.setColorToAll(wcc.colors[self.bg_color_index], includeMinutes=True)
        taw_indices = self.taw.get_time(sun_data['sunrise'], withPrefix=False)
        wcd.setColorBy1DCoordinates(wcd.strip, taw_indices, wcc.colors[self.word_color_index])
        wcd.show()
        time.sleep(3)
        # Display data of sunset
        wcd.animate(self.name, 'sunrise')
        wcd.setColorToAll(wcc.colors[self.bg_color_index], includeMinutes=True)
        taw_indices = self.taw.get_time(sun_data['sunset'], withPrefix=False)
        wcd.setColorBy1DCoordinates(wcd.strip, taw_indices, wcc.colors[self.word_color_index])
        wcd.show()
        time.sleep(3)
        # Display current moon phase
        moon_phase = int(self.astral_at_location.moon_phase(datetime.datetime.now()))
        for i in range(0, moon_phase):
            wcd.showIcon('sunrise', 'moon_'+str(i).zfill(2))
            time.sleep(0.1)
        time.sleep(3)

    def test_track_sunset(self):
        """Test track the sunset."""
        latitude = 32.87336
        longitude = 117.22743

        # Setup sun component
        self.hass.config.latitude = latitude
        self.hass.config.longitude = longitude
        setup_component(self.hass, sun.DOMAIN, {
            sun.DOMAIN: {sun.CONF_ELEVATION: 0}})

        # Get next sunrise/sunset
        astral = Astral()
        utc_now = datetime(2014, 5, 24, 12, 0, 0, tzinfo=dt_util.UTC)
        utc_today = utc_now.date()

        mod = -1
        while True:
            next_setting = (astral.sunset_utc(
                utc_today + timedelta(days=mod), latitude, longitude))
            if next_setting > utc_now:
                break
            mod += 1

        # Track sunset
        runs = []
        with patch('homeassistant.util.dt.utcnow', return_value=utc_now):
            unsub = track_sunset(self.hass, lambda: runs.append(1))

        offset_runs = []
        offset = timedelta(minutes=30)
        with patch('homeassistant.util.dt.utcnow', return_value=utc_now):
            unsub2 = track_sunset(
                self.hass, lambda: offset_runs.append(1), offset)

        # Run tests
        self._send_time_changed(next_setting - offset)
        self.hass.block_till_done()
        self.assertEqual(0, len(runs))
        self.assertEqual(0, len(offset_runs))

        self._send_time_changed(next_setting)
        self.hass.block_till_done()
        self.assertEqual(1, len(runs))
        self.assertEqual(0, len(offset_runs))

        self._send_time_changed(next_setting + offset)
        self.hass.block_till_done()
        self.assertEqual(1, len(runs))
        self.assertEqual(1, len(offset_runs))

        unsub()
        unsub2()

        self._send_time_changed(next_setting + offset)
        self.hass.block_till_done()
        self.assertEqual(1, len(runs))
        self.assertEqual(1, len(offset_runs))

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 seconds_till_daytime(lat,lon,delta_minutes):
   if is_it_daytime(lat,lon,delta_minutes):
       return 0
   now = datetime.now(UTC())
   astral = Astral()
   sunrise = astral.sunrise_utc(now,lat,lon) + timedelta(minutes=delta_minutes)
   if sunrise < now:
      sunrise = astral.sunrise_utc(now + timedelta(hours=23),lat,lon) + timedelta(minutes=delta_minutes)
   return int((sunrise-now).total_seconds())+1

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 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 testElevation():
    city_name = "Jubail"

    dd = Astral()
    city = dd[city_name]

    dt = datetime.datetime.now(tz=city.tz)
    print("Date & time: %s" % dt)
    print("Date & time (UTC): %s" % dt.astimezone(pytz.utc))
    print("Elevation: %.02f" % dd.solar_elevation(dt, city.latitude, city.longitude))

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 test_track_sunrise(self):
        """Test track the sunrise."""
        latitude = 32.87336
        longitude = 117.22743

        # Setup sun component
        self.hass.config.latitude = latitude
        self.hass.config.longitude = longitude
        setup_component(self.hass, sun.DOMAIN, {
            sun.DOMAIN: {sun.CONF_ELEVATION: 0}})

        # Get next sunrise/sunset
        astral = Astral()
        utc_now = dt_util.utcnow()

        mod = -1
        while True:
            next_rising = (astral.sunrise_utc(utc_now +
                           timedelta(days=mod), latitude, longitude))
            if next_rising > utc_now:
                break
            mod += 1

        # Track sunrise
        runs = []
        unsub = track_sunrise(self.hass, lambda: runs.append(1))

        offset_runs = []
        offset = timedelta(minutes=30)
        unsub2 = track_sunrise(self.hass, lambda: offset_runs.append(1),
                               offset)

        # run tests
        self._send_time_changed(next_rising - offset)
        self.hass.block_till_done()
        self.assertEqual(0, len(runs))
        self.assertEqual(0, len(offset_runs))

        self._send_time_changed(next_rising)
        self.hass.block_till_done()
        self.assertEqual(1, len(runs))
        self.assertEqual(0, len(offset_runs))

        self._send_time_changed(next_rising + offset)
        self.hass.block_till_done()
        self.assertEqual(2, len(runs))
        self.assertEqual(1, len(offset_runs))

        unsub()
        unsub2()

        self._send_time_changed(next_rising + offset)
        self.hass.block_till_done()
        self.assertEqual(2, len(runs))
        self.assertEqual(1, len(offset_runs))