def get_current_weather_data(lat, long):
"""
Given a location, get the weather data for the next 48 hrs.
:param lat: latitude
:param long: longitude
:return: list of hourly weather data for the given lat long
"""
darksky = DarkSky(DARKSKY)
try:
# get the data
forecast = darksky.get_forecast(
lat, long,
exclude=[weather.HOURLY, weather.MINUTELY,
weather.DAILY, weather.ALERTS, weather.FLAGS])
# add lat & long to the hourly weather data for composite key in db
data = forecast.currently
data.latitude = lat
data.longitude = long
data = data.__dict__
data.pop("time")
return data
except Exception as e:
print(e)
return None
def index():
geolocator = Nominatim(user_agent="MJGEo")
location = geolocator.geocode("Patna")
mloc = location
API_KEY = 'e2fea81b36c2588f1315c4ad2b721989'
darksky = DarkSky(API_KEY)
latitude = location.latitude
longitude = location.longitude
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.HINDI, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
icon = forecast.currently.icon
temperature = forecast.currently.temperature
print(temperature)
print(forecast.timezone)
forecast.latitude # 42.3601
forecast.longitude # -71.0589
forecast.timezone # timezone for coordinates. For exmaple: `America/New_York`
forecast.currently # CurrentlyForecast. Can be finded at darksky/forecast.py
forecast.minutely # MinutelyForecast. Can be finded at darksky/forecast.py
forecast.hourly # HourlyForecast. Can be finded at darksky/forecast.py
forecast.daily # DailyForecast. Can be finded at darksky/forecast.py
forecast.alerts # [Alert]. Can be finded at darksky/forecast.py
params = {'sloc': mloc}
return render_template("index.html",
name=mloc,
icon=icon,
temperature=temperature)
def get_hourly_weather_data(lat, long):
"""
Given a location, get the weather data for the next 48 hrs.
:param lat: latitude
:param long: longitude
:return: list of hourly weather data for the given lat long
"""
darksky = DarkSky(DARKSKY)
try:
# get the data
forecast = darksky.get_forecast(
lat, long,
exclude=[weather.CURRENTLY, weather.MINUTELY,
weather.DAILY, weather.ALERTS, weather.FLAGS])
# add lat & long to the hourly weather data for composite key in db
hourly_weather_data = []
for data in forecast['hourly']['data']:
data['latitude'] = lat
data['longitude'] = long
hourly_weather_data.append(data)
# Lets save the weather data while were at it
# for data in hourly_weather_data:
# db.weather_container.create_item(data)
return hourly_weather_data
except Exception as e:
print(e)
return None
def get_weather():
darksky = DarkSky(DARKSKY_API_KEY)
forecast = darksky.get_forecast(latitude, longitude)
todays_forecast = forecast.daily.data[0]
summary = todays_forecast.summary
temp_high = str(round(todays_forecast.temperature_high))
temp_low = str(round(todays_forecast.temperature_low))
return summary, temp_high, temp_low
def weather_data(lat, long, api_key):
darksky = DarkSky(api_key)
logger.info("Powered by Dark Sky")
forecast = darksky.get_forecast(lat,
long,
extend=False,
lang=languages.ENGLISH,
values_units=units.AUTO,
exclude=[weather.ALERTS, weather.MINUTELY])
return forecast
def dashboard(request):
client_ip = get_client_ip(request)
try:
user = User.objects.get(client_ip=client_ip[0])
except:
user = User()
#Grabs the IP from api.ipify.org which can be found in GeoIP2's API
remote_ip_cache = cache.get('remote_ip') # or user.last_ip
remote_ip = requests.get(url='https://api.ipify.org')
#Instead of storing in the database, we can just use the user's cache to store their content
if (remote_ip_cache == None):
cache.set('remote_ip', remote_ip)
#If the ip that we get from api.ipify.org is different than the cache/data model
#We can assume that they have relocated and we will try and update their location based
#off the GeoIP API
if (remote_ip_cache != remote_ip):
cache.set('remote_ip', remote_ip)
remote_ip_cache = remote_ip
user.last_ip = remote_ip_cache.text
g = GeoIP2()
try:
lat_lon = g.lat_lon(remote_ip_cache.text)
user.last_latitude = lat_lon[0]
user.last_longitude = lat_lon[1]
except:
raise Http404("Can not find Location.")
#We could make some logic to only allow these users to get requests from Dark Sky API
# every so often.
user.last_request = timezone.now()
user.save()
geoCity = g.city(remote_ip.text)
#Get Forecast from Dark Sky API with API_KEY
DWD_API_KEY = '9e3ac71786112191eaed1cd8abbe4614'
darksky = DarkSky(DWD_API_KEY)
forecast = darksky.get_forecast(
lat_lon[0],
lat_lon[1],
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
context = {'forecast': forecast, 'geoCity': geoCity}
return render(request, 'weatherApp/dashboard.html', context)
def weatherinfo(lat,long_):
api ='af654ddc453104adcc9b4d0818a7604d' # this is mine, its is possible to get your own if you ready have an darksky acc...or..
dsky = DarkSky(api) # its not possible coz...darksky stopped creating new APIs since it is aquired by apple
forecast = dsky.get_forecast(
lat,long_,
extend=False,
lang=languages.ENGLISH,
values_units= units.SI,
exclude=[weather.MINUTELY,weather.HOURLY,weather.ALERTS,weather.FLAGS]
)
return forecast
def get_DS_forecasts(latitude, longitude):
darksky = DarkSky(API_KEY)
forecast = darksky.get_forecast(latitude,
longitude,
exclude=[weather.MINUTELY, weather.FLAGS])
# weather now, +[3/6/9/12] hour forecasts
everyThreeHours = {}
everyThreeHours[str(0)] = forecast.currently
for i in range(1, 5):
idx = 3 * i
everyThreeHours[str(i)] = forecast.hourly.data[idx]
return (everyThreeHours, forecast.alerts)
def main(api_key, lat, long):
# log in home dir
logging.basicConfig(
filename=PurePath(Path.home()).joinpath('logs/cloud.log'),
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
pi_led = RGBLED(red=17, green=27, blue=24, pin_factory=PiGPIOFactory())
darksky = DarkSky(api_key)
forecast = darksky.get_forecast(
lat, long, exclude=['minutely', 'hourly', 'daily', 'alerts',
'flags']).currently.icon
logging.info('Icon: {}'.format(forecast))
weather_indicator(pi_led, WEATHER_COLOR_MAP.get(forecast, 'unknown_icon'))
def setValues():
location = str(city.get())
if location[-3:] == 'usa':
usa = 1
else:
usa = 0
# Geocoding the city using GoogleMaps API
geocode_result = gmaps.geocode(location)
lat = geocode_result[0]['geometry']['location']['lat']
lng = geocode_result[0]['geometry']['location']['lng']
# set up darksky API to retreave weather data
darksky = DarkSky(skyAPI)
forecast = darksky.get_forecast(
lat,
lng,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
# set the variables for display
wind.set(str(round(forecast.currently.wind_speed, 2)) + 'mph')
updated.set(str(forecast.currently.time)[:-6])
weathers.set(forecast.currently.summary)
if usa == 0:
tempC = round(forecast.currently.temperature)
tempF = round(forecast.currently.temperature * 1.8 + 32)
else:
tempF = round(forecast.currently.temperature)
tempC = round((forecast.currently.temperature - 32) / 1.8)
temp.set(str(int(tempC)) + '℃ ' + str(int(tempF)) + '℉ ')
relHum.set(str(int(forecast.currently.humidity * 100)) + '%')
visibility.set(str(round(forecast.currently.visibility, 2)) + 'miles')
if str(forecast.currently.precip_type) == 'None':
prec.set(str(forecast.currently.precip_type))
else:
prec.set(
str(int(forecast.currently.precip_probability)) + "% " +
str(forecast.currently.precip_type))
uv.set(str(int(forecast.currently.uv_index)))
if usa == 0:
dewC = round(forecast.currently.dew_point)
dewF = round(forecast.currently.dew_point * 1.8 + 32)
else:
dewF = round(forecast.currently.dew_point)
dewC = round((forecast.currently.dew_point - 32) / 1.8)
dew.set(str(int(dewC)) + '℃ ' + str(int(dewF)) + '℉ ')
def get_temperature(location={"lat": 31.630000, "long": -8.008889}):
# Synchronous way
darksky = DarkSky(API_KEY)
latitude = location['lat']
longitude = location['long']
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
return forecast.currently.temperature
def extract_data(self, message):
darksky = DarkSky("68a391b503f11aa6fa13d405bfefdaba")
latitude = message['latitude']
longitude = message['longitude']
forecast = darksky.get_forecast(
latitude, longitude,
extend=False,
lang=languages.ENGLISH,
values_units=units.AUTO,
exclude=[weather.MINUTELY, weather.ALERTS],
timezone='UTC'
)
current = forecast.currently
mssg = {'summary':current.summary,
'windSpeed':current.wind_speed,
'humidity':current.humidity,
'temperature':current.temperature}
return mssg
class WeatherFetcher:
def __init__(self):
self.data: Forecast = None
self._lock = threading.Lock()
self.darksky = DarkSky(dark_sky_key)
def do(self):
forecast = self.darksky.get_forecast(dark_sky_lat, dark_sky_lon)
self.update(forecast)
print(forecast.currently.temperature)
def update(self, data: Forecast):
with self._lock:
self.data = data
def read(self):
with self._lock:
return self.data
def get_weather(latlong=latlong):
from darksky.api import DarkSky, DarkSkyAsync
from darksky.types import languages, units, weather
API_KEY = get_API_from_file()
# Synchronous way
darksky = DarkSky(API_KEY)
#print (latlong)
latitude, longitude = latlong #[:]
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
#values_units= units.AUTO, # default auto
exclude=[weather.MINUTELY], # weather.ALERTS] - default []
)
return forecast
def get_forecast(self, coordinate):
API_KEY = self.config.get_config('darksky', 'api', '9bd0b8315895a1c550505b281fc082ff')
# Synchronous way
darksky = DarkSky(API_KEY)
#latitude = 42.3601
#longitude = -71.0589
latitude, longitude = coordinate
forecast = darksky.get_forecast(
latitude, longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
values_units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS], # default `[]`,
timezone='Asia/Jakarta' # default None - will be set by DarkSky API automatically
)
print(forecast)
return forecast
def update_weather(self):
# Get weather
print("Updating weather:")
darksky = DarkSky(self.darksky_secret)
try:
self.forecast = darksky.get_forecast(43.312691,
-1.993332,
lang='es')
print(" >> Summary: ", self.forecast.currently.summary)
print(" >> Icon: ", self.forecast.currently.icon)
print(" >> Temperature: ", self.forecast.currently.temperature)
print(" >> Humidity: ", self.forecast.currently.humidity)
print(" >> Wind Speed: ", self.forecast.currently.wind_speed)
print(" >> Pressure: ", self.forecast.currently.pressure)
print(' >> Current summary: ' + self.forecast.currently.summary)
#print(' >> Minutely summary: ' + self.forecast.minutely.summary)
print(' >> Hourly summary: ' + self.forecast.hourly.summary)
print("Get icon index:")
weather_icons = {
"clear-day": "01",
"clear-night": "02",
"partly-cloudy-day": "03",
"partly-cloudy-night": "04",
"cloudy": "05",
"fog": "06",
"wind": "07",
"sleet": "08",
"rain": "09",
"snow": "10",
}
weather_icon_index = weather_icons.get(
self.forecast.currently.icon)
print(" >> Icon index: ", weather_icon_index)
command = 'W' + weather_icon_index + '\r'
print("Weather command: ", command)
self.comport.write(bytes(command, 'UTF-8'))
except:
print("Exception occured during weather update")
class darksky(object):
def __init__(self):
self.conn = sqlite3.connect('project.db')
c = self.conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS city_hourly (city_name text, hourly text)''')
c.execute('''CREATE TABLE IF NOT EXISTS city_daily (city_name text, daily text)''')
self.conn.commit()
#darksky secret key
secret_key = 'c59726c51f4df85958f9b9843e2c55c8'
self.darksky = DarkSky(secret_key)
def newpoint(self):
return random.uniform(-180,180), random.uniform(-90, 90)
def cities(self):
points = (self.newpoint() for x in range(10))
for point in points:
longitude = point[0]
latitude = point[1]
forecast = self.darksky.get_forecast(
latitude, longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS], # default `[]`,
timezone='UTC' # default None - will be set by DarkSky API automatically
)
current_city_forecast = forecast.hourly.data[0].humidity
current_city_forecasts = forecast.daily.data[0].humidity
c = self.conn.cursor()
c.execute ('SELECT * FROM city_hourly WHERE city_name = ? AND hourly = ?', (str(point[0]) + "," + str(point[1]),current_city_forecast,))
if c.fetchone() is None:
c.execute('INSERT INTO city_hourly VALUES (?,?)', (str(point[0]) + "," + str(point[1]),current_city_forecast,))
self.conn.commit()
c.execute ('SELECT * FROM city_daily WHERE city_name = ? AND daily = ?', (str(point[0]) + "," + str(point[1]),current_city_forecasts,))
if c.fetchone() is None:
c.execute('INSERT INTO city_daily VALUES (?,?)', (str(point[0]) + "," + str(point[1]),current_city_forecasts,))
self.conn.commit()
def getweather(self):
api_key = os.environ['DARKSKY_API_KEY']
darksky = DarkSky(api_key)
coordinates = self.getcoords()
geodata = dict()
geodata['lat'] = coordinates['geometry']['location']['lat']
geodata['lng'] = coordinates['geometry']['location']['lng']
latitude = geodata['lat']
longitude = geodata['lng']
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
values_units=units.AUTO, # default `auto`
exclude=[], # default `[]`,
timezone=
None # default None - will be set by DarkSky API automatically
)
return forecast
def result():
if request.method == 'POST':
result = request.form
print(result['mlocation'])
geolocator = Nominatim(user_agent="MJGEo")
location = geolocator.geocode(result['mlocation'])
mloc = location
API_KEY = 'e2fea81b36c2588f1315c4ad2b721989'
darksky = DarkSky(API_KEY)
latitude = location.latitude
longitude = location.longitude
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
summary = forecast.hourly.summary
temperature = forecast.hourly.data[0].temperature
icon = forecast.daily.data[0].icon
visibility = forecast.daily.data[0].visibility
print(temperature)
print(forecast.timezone)
forecast.latitude # 42.3601
forecast.longitude # -71.0589
forecast.timezone # timezone for coordinates. For exmaple: `America/New_York`
forecast.currently # CurrentlyForecast. Can be finded at darksky/forecast.py
forecast.minutely # MinutelyForecast. Can be finded at darksky/forecast.py
forecast.hourly # HourlyForecast. Can be finded at darksky/forecast.py
forecast.daily # DailyForecast. Can be finded at darksky/forecast.py
forecast.alerts # [Alert]. Can be finded at darksky/forecast.py
params = [mloc, summary, temperature, icon, visibility]
return render_template("index.html", params=params)
def extract_data(self, message):
try:
responseDark = requests.get(
"https://api.darksky.net/forecast/68a391b503f11aa6fa13d405bfefdaba/10,-10"
)
darksky = DarkSky("68a391b503f11aa6fa13d405bfefdaba")
latitude = message['latitude']
longitude = message['longitude']
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False,
lang=languages.ENGLISH,
values_units=units.AUTO,
exclude=[weather.MINUTELY, weather.ALERTS],
timezone='UTC')
current = forecast.currently
mssg = {
'summary': current.summary,
'windSpeed': current.wind_speed,
'humidity': current.humidity,
'temperature': current.temperature
}
return mssg
except Exception as e:
print(e)
mssg = {
'summary': 'overcast',
'windSpeed': 12,
'humidity': 78,
'temperature': 42
}
print(mssg)
return mssg
class WeatherSummary(Screen):
"""Screen to show weather summary for a selected location."""
location_label = StringProperty("")
def __init__(self, api_key, location, **kwargs):
super(WeatherSummary, self).__init__(**kwargs)
self._location = location
# self._key = api_key
self.location_label = self.name
self._darksky = DarkSky(api_key)
self._forecast = None
self._hourly = None
self.bx_forecast = self.ids.bx_forecast
self.bx_hourly = self.ids.bx_hourly
self.nextupdate = 0
self.timer = None
def on_enter(self):
# Check if the next update is due
if (time.time() > self.nextupdate):
dt = 0.5
else:
dt = self.nextupdate - time.time()
self.timer = Clock.schedule_once(self.getData, dt)
def on_leave(self):
Clock.unschedule(self.timer)
def getData(self, *args):
# Get the forecast
self._forecast = self._darksky.get_forecast(
float(self._location[0]),
float(self._location[1]),
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS], # default `[]`,
# timezone='UTC' # default None - will be set by DarkSky API automatically
)
# Clear the screen of existing overlays
self.bx_forecast.clear_widgets()
self.bx_hourly.clear_widgets()
# If we've got daily info then we can display it.
if self._forecast.daily:
for day in self._forecast.daily.data[:4]:
frc = WeatherForecastDay(daily_forecast_item=day)
self.bx_forecast.add_widget(frc)
# If not, let the user know.
else:
error_label = Label(text="Error getting weather data.")
self.bx_forecast.add_widget(error_label)
# If we've got hourly weather data then show it
if self._forecast.hourly:
# We need a scroll view as there's a lot of data...
w = len(self._forecast.hourly.data) * 130
bx = BoxLayout(orientation="horizontal",
size=(w, 180),
size_hint=(None, None),
spacing=5)
sv = ScrollView(size_hint=(1, 1))
sv.add_widget(bx)
for hour in self._forecast.hourly.data:
frc = WeatherForecastHourly(hourly_forecast_item=hour)
bx.add_widget(frc)
self.bx_hourly.add_widget(sv)
# If there's no data, let the user know
else:
error_label = Label(text="Error getting weather data.")
self.bx_forecast.add_widget(error_label)
# We're done, so schedule the next update
if self._forecast.hourly and self._forecast.daily:
dt = 60 * 60
else:
dt = 5 * 60
self.nextupdate = time.time() + dt
self.timer = Clock.schedule_once(self.getData, dt)
class DarkSkyApiHelper(object):
def __init__(self, latitude=None, longitude=None, sampleRange=None):
jsonObj = self.__get_config()
apiKey = self.__get_api_secret(jsonObj)
self.longitude = longitude or self.__get_longitude(jsonObj)
self.latitude = latitude or self.__get_latitude(jsonObj)
self.sampleRange = sampleRange or self.__get_sample_forecast_range(
jsonObj)
self.client = DarkSky(apiKey)
def __str__(self):
return dumps(str(self.__dict__))
def __get_config(self):
jsonFile = open(CONFIGURATION_PATH, "r")
jsonObj = load(jsonFile)
jsonFile.close()
return jsonObj
def __get_api_secret(self, jsonObj):
apiKey = jsonObj["api_key"]
return apiKey
def __get_latitude(self, jsonObj):
lat = jsonObj["latitude"]
return lat
def __get_longitude(self, jsonObj):
lon = jsonObj["longitude"]
return lon
def __get_sample_forecast_range(self, jsonObj):
sampleRange = jsonObj["sample_forecast_range_hours"]
return sampleRange
def get_weather_forecast(self):
forecast = self.client.get_forecast(self.latitude, self.longitude)
return forecast
def get_pct_chance_of_rain(self):
forecast = self.get_weather_forecast()
now = datetime.now()
hour = now.hour
date = now.date()
hourlyData = forecast.hourly.data
hourlyPctRain = [
x.precip_probability for x in hourlyData
if (hour + self.sampleRange) > x.time.hour >= hour
and x.time.date() == date
]
pRain = mean(hourlyPctRain)
return pRain
with open("knowledge.JSON") as file:
robot_brain = json.load(file)
# get current time by timezone
tz_Hanoi = pytz.timezone('Asia/Ho_Chi_Minh') # timezone
datetime_Hanoi = datetime.now(tz_Hanoi) # current time
# darksky - daily weather
API_KEY = 'e2fea81b36c2588f1315c4ad2b721989' # This is OneMonth's api key (OneMonth.com)
darksky = DarkSky(API_KEY)
forecast = darksky.get_forecast( # get forecast for Hanoi
21.0294498, # latitude
105.8544441, # longitude
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
# units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
# 2.Define fundamental function
def getRequest(ask): # record user's voice
with sr.Microphone() as mic:
print(ask)
audio = speech.listen(mic)
try:
return speech.recognize_google(audio)
except: # google can't recognize the content of the audio
return ""
from darksky.api import DarkSky
from darksky.types import languages, units, weather
API_KEY = 'e2fea81b36c2588f1315c4ad2b721989'
darksky = DarkSky(API_KEY)
latitude = 42.3601
longitude = -71.0589
forecast = darksky.get_forecast(
latitude,
longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS] # default `[]`
)
print(forecast.currently.temperature)
forecast.latitude # 42.3601
forecast.longitude # -71.0589
forecast.timezone # timezone for coordinates. For exmaple: `America/New_York`
forecast.currently # CurrentlyForecast. Can be finded at darksky/forecast.py
forecast.minutely # MinutelyForecast. Can be finded at darksky/forecast.py
forecast.hourly # HourlyForecast. Can be finded at darksky/forecast.py
forecast.daily # DailyForecast. Can be finded at darksky/forecast.py
forecast.alerts # [Alert]. Can be finded at darksky/forecast.py
def do_update():
API_KEY = open("darksky-secret").readline().rstrip()
darksky = DarkSky(API_KEY)
lat, lon = 42.417821, -71.177747
forecast = darksky.get_forecast(lat,
lon,
exclude=[weather.MINUTELY, weather.ALERTS])
print("got forecast from darksky")
now = forecast.currently
today = forecast.daily.data[0]
hourly = forecast.hourly.data
temp_now = two_dig(now.apparent_temperature)
if UNTIL_MIDNIGHT:
rest_of_day = [x for x in hourly if x.time.day == datetime.now().day]
temp_hi = two_dig(max([x.apparent_temperature for x in rest_of_day]))
temp_low = two_dig(min([x.apparent_temperature for x in rest_of_day]))
today_icon = worst([x.icon for x in rest_of_day])
else:
temp_hi = two_dig(today.apparent_temperature_high)
temp_low = two_dig(today.apparent_temperature_low)
today_icon = today.icon
sleep(5)
paper_cmd("wake")
paper_cmd("clear")
paper_bignum(temp_now[0], 20, 20)
paper_bignum(temp_now[1], 160, 20)
paper_smallnum(temp_hi[0], 310, 10)
paper_smallnum(temp_hi[1], 390, 10)
paper_smallnum(temp_low[0], 310, 175)
paper_smallnum(temp_low[1], 390, 175)
if now.icon == today_icon or FORECAST_ONLY:
paper_image(icon(3, today_icon), 500, 160)
else:
paper_image(icon(3, now.icon), 500, 30)
paper_image(icon(3, today_icon), 500, 290)
paper_image("UV.BMP", 20, 470)
paper_smallnum(uv_one_dig(today.uv_index), 80, 310)
paper_fontsize(32)
paper_text(today.summary, 20, 570)
nowt = datetime.now()
paper_text(nowt.strftime("Last update %H:%M"), 20, 1)
paper_text(
(nowt + timedelta(seconds=seconds_between_updates)
).strftime("Next update %H:%M"),
550,
1,
)
# day of week and date
paper_fontsize(64)
paper_text(nowt.strftime("%a"), 310, 370)
paper_text(nowt.strftime("%b %-d"), 280, 440)
paper_rect(260, 360, 455, 520)
paper_cmd("update")
paper_cmd("stop")
paper_deepsleep(seconds_between_updates)
print("done")
from darksky.api import DarkSky, DarkSkyAsync
from darksky.types import languages, units, weather
API_KEY = '0123456789abcdef9876543210fedcba'
# Synchronous way
darksky = DarkSky(API_KEY)
latitude = 42.3601
longitude = -71.0589
forecast = darksky.get_forecast(
latitude, longitude,
extend=False, # default `False`
lang=languages.ENGLISH, # default `ENGLISH`
values_units=units.AUTO, # default `auto`
exclude=[weather.MINUTELY, weather.ALERTS], # default `[]`,
timezone='UTC' # default None - will be set by DarkSky API automatically
)
# Synchronous way Time Machine
from datetime import datetime as dt
darksky = DarkSky(API_KEY)
t = dt(2018, 5, 6, 12)
latitude = 42.3601
longitude = -71.0589
forecast = darksky.get_time_machine_forecast(
latitude, longitude,
def get_forecast_sync() -> Forecast:
darksky = DarkSky("api_key")
return darksky.get_forecast(DATA["latitude"], DATA["longitude"])
# weather_thing.py
from darksky.api import DarkSky
import csv
import time
import os.path
import weather_plotter as plt
API_KEY = '117eeede0b36be4e9adee42396747ac7'
darksky = DarkSky(API_KEY)
latitude = 47.209660
longitude = -122.425690
fcst = darksky.get_forecast(latitude, longitude)
line = {
'now_temp': fcst.currently.apparent_temperature,
'now_icon': fcst.currently.icon,
'fcst_temp': fcst.daily.data[0].temperature_high,
'fcst_icon': fcst.daily.data[0].icon,
'year': time.strftime('%Y'),
'month': time.strftime('%m'),
'day': time.strftime('%d'),
'hour': time.strftime('%H'),
'minute': time.strftime('%M'),
'second': time.strftime('%S'),
'now_humi': fcst.currently.humidity
}
file_name = 'data_weather_thing.csv'
def get_forecast_sync() -> Forecast:
darksky = DarkSky('api_key')
return darksky.get_forecast(DATA['latitude'], DATA['longitude'])
Tashkent_city = Cities(4, 'Tashkent', 41.299496, 69.240074)
Sydney_city = Cities(5, 'Sydney', -33.868820, 151.209290)
# Inserts all cities into the "cities" table
cities = [NewYork_city, London_city, Moscow_city, Tashkent_city, Sydney_city]
for i in range(len(cities)):
insert_city(cities[i])
# Saves weather information into weather table for a specified cities, if data differs >=1 min
starttime = time.time()
while get_info_from_API:
for i in range(len(cities)):
city_weather = darksky.get_forecast(cities[i].lat,
cities[i].lon,
extend=False,
lang=languages.ENGLISH,
units=units.AUTO,
exclude=[],
timezone=None)
#city_weather_copy = copy.deepcopy(city_weather)
c.execute(
"""SELECT * FROM weather WHERE city_id=:city_id ORDER BY time DESC LIMIT 1""",
{'city_id': i + 1})
selected_data = c.fetchall()
current_weather = Weather_info.get_weather_info_tuple(city_weather)
if selected_data == []:
insert_weather(city_weather, i + 1)
print(
"Current weather information of {} was saved first time into weather table ..."
.format(city_weather.timezone))
