def get_timezone_offset(self) -> Optional[str]:
zipcode = self.get_rich_zipcode()
if zipcode is None:
return None
tf = TimezoneFinder()
longitude = zipcode['Longitude']
latitude = zipcode['Latitude']
timezone_name = tf.timezone_at(lng=longitude, lat=latitude)
if timezone_name is None:
return None
return datetime.datetime.now(pytz.timezone(timezone_name)).strftime('%z')
def getTimeZone( location ):
from timezonefinder import TimezoneFinder
tf = TimezoneFinder( )
if isinstance( location, str ):
location = getLocation( location )
elif not isinstance( location, RPNLocation ):
raise ValueError( 'location name or location object expected' )
timezone_name = tf.timezone_at( lat = location.getLat( ), lng = location.getLong( ) )
if timezone_name is None:
timezone_name = tf.closest_timezone_at( lat = location.getLat( ),
lng = location.getLong( ) )
return timezone_name
def process_request(self, request):
user_time_zone = request.session.get('user_time_zone', None)
user_time_zone = None
try:
if user_time_zone is None:
ip = get_real_ip(request)
if ip is None:
tf = TimezoneFinder()
print
point = (request.user.userdata.address.longditude,request.user.userdata.address.latitude)
user_time_zone = tf.timezone_at(*point)
request.session['user_time_zone'] = user_time_zone
else :
freegeoip_response = requests.get('http://freegeoip.net/json/{0}'.format())
freegeoip_response_json = freegeoip_response.json()
user_time_zone = freegeoip_response_json['time_zone']
if user_time_zone:
request.session['user_time_zone'] = user_time_zone
timezone.activate(pytz.timezone(user_time_zone))
except:
pass
return None
def filterhits(camera, data):
# timezones
tf = TimezoneFinder()
zone = tf.timezone_at(lng=camera.lon, lat=camera.lat)
timestamps = []
for record in data:
timestamps.append(record['submission']['image']['timestamp'])
instance = {}
for timestamp in set(timestamps):
instance[timestamp] = {'vehicles': set(), 'bikes': set(), 'people': set()}
for record in data:
if record['submission']['image']['timestamp'] == timestamp:
worker = record['submission']['workerId']
bbox = Bbox(record['x1'], record['y1'], record['x2'], record['y2'], worker)
# some have w = 0 or h = 0
if bbox.w * bbox.h > 0:
instance[timestamp][record['type']].add(bbox)
with open('camera_{}_points.csv'.format(camera.id), 'w') as f:
f.write('year,month,day,hour,minute,type,count,x,y,url,url2,y,m,d,h,mi,camw,camh\n')
for timestamp in sorted(instance.keys()):
date, time = timestamp.split('T')
y, m, d = date.split('-')
h, mi, s = time.split(':')
ts = timestamp.replace(':', '').replace('T', '_').replace('-', '')
dt = datetime.datetime(year=int(y), month=int(m), day=int(d), hour=int(h), minute=int(mi), second=int(s), tzinfo=utc)
lt = local_time(dt, zone)
url = 'http://amos.cse.wustl.edu/mturk/reviewOutlines/{}/{}'.format(camera.id, ts)
url2 = 'http://amos.cse.wustl.edu/image/{}/{}.jpg'.format(camera.id, ts)
for htype in instance[timestamp].keys():
records = resolve_duplicates(list(instance[timestamp][htype]))
for xx, yy in records:
f.write('{yl},{ml},{dl},{hl},{mil},{tp},{cnt},{xx},{yy},{url},{url2},{y},{m},{d},{h},{mi},{camw},{camh}\n'
.format(yl=lt.year, ml=lt.month, dl=lt.day, hl=lt.hour, mil=lt.minute, y=y, m=m,
d=d, h=h, mi=mi, tp=htype, cnt=len(records), xx=xx, yy=yy, url=url, url2=url2,
camw=camera.w, camh=camera.h))
import requests
import json
import timezonefinder
# req = requests.get('http://api.geonames.org/timezoneJSON?lat=47.01&lng=10.2&username=demo')
# req = req.json()
# print(req)
from timezonefinder import TimezoneFinder
TimezoneFinder.using_numba() # this is a static method returning True or False
tf = TimezoneFinder()
# tf = TimezoneFinder(in_memory=True) # to use the faster "in-memory" mode
# tf = TimezoneFinder(bin_file_location='path/to/files') # to use data files from another location
longitude, latitude = 13.358, 52.5061
print(tf.timezone_at(lng=55.028395, lat=61.646646)) # returns 'Europe/Berlin'
print(tf.certain_timezone_at(lng=longitude,
lat=latitude)) # returns 'Europe/Berlin'
def on_chat_message(self, msg):
content_type, chat_type, chat_id = telepot.glance(msg)
print('Chat:', content_type, chat_type, chat_id)
if content_type != 'text':
return self.sendMessage(chat_id, self.data['confused_msg'], reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
text = msg['text'].lower()
user = self.db.users.find_one({'chat_id':chat_id})
if not chat_id in self.current_users:
self.setUser (chat_id, msg['from'])
if user:
self.current_users[chat_id].mapUser(user)
self.current_users[chat_id].reset = False
elif not user and self.current_users[chat_id].reset and text not in self.data['start']:
return self.restart(chat_id)
if text in self.data['start'] or msg['message_id'] == 0:
self.current_users[chat_id].reset = True
self.current_users[chat_id].language_setting_msg = self.language_setting(chat_id)
elif text in self.data['settings']:
if not self.current_users[chat_id].reset:
markup = ReplyKeyboardMarkup(keyboard=self.keyboard_two_col(self.data['setting_keyboard'][self.current_users[chat_id].language]),
resize_keyboard=True, one_time_keyboard=True)
text_msg = self.data['setting_msg'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg, reply_markup=markup)
else:
return self.restart(chat_id)
elif text in self.data['get_exercise']:
self.sendExercise(list(self.db.users.find({'chat_id': chat_id})))
elif text in self.data['get_question']:
self.questionGathering(list(self.db.users.find({'chat_id': chat_id})))
elif text in self.data['statistics']:
text_msg = {}
en_start = "You started to use the service on {:%d, %b %Y}\n".format(user['_id'].generation_time)
fi_start = "Aloit käyttää palvelua {:%d, %b %Y}\n".format(user['_id'].generation_time)
en_recieved_exercises = "You have recieved {0} exercises.\nYou have done {1} exercises.\nAmong the done exercises, you have trained your:\ncore: {2} times\nlegs: {3} times\narms: {4} times\nhands: {5} times.\nAnd there were:\n{6} stretching exercises\n{7} balance exercises\n{8} strength exercises".format(self.db[str(chat_id)].count(),
user['done'], user['core'], user['legs'], user['arms'], user['hands'],
user['stretching'], user['balance'], user['strength'])
fi_recieved_exercises = "Olet saanut {0} harjoitusta.\nOlet tehnyt {1} harjoitusta.\nTekemäsi harjoitukset ovat treenanneet:\nkeskikroppaa: {2} krt\njalkoja: {3} krt\nkäsivarsia: {4} krt\nkäsiä: {5} krt.\nHarjoitustyypit:\n{6} kpl venyttely\n{7} kpl tasapaino\n{8} kpl voima".format(self.db[str(chat_id)].count(),
user['done'], user['core'], user['legs'], user['arms'], user['hands'],
user['stretching'], user['balance'], user['strength'])
en_goal = "\nYour current goal is: " + user['goals'][0]['en']
fi_goal = "\nTämänhetkinen tavoitteesi on: " + user['goals'][0]['fi']
text_msg['en'] = en_start + en_recieved_exercises + en_goal
text_msg['fi'] = fi_start + fi_recieved_exercises + fi_goal
self.sendMessage(chat_id, text_msg[self.current_users[chat_id].language], reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
elif text in self.data['new_goal'] or msg['text'] == self.data['checkup_keyboard'][self.current_users[chat_id].language][1]:
self.current_users[chat_id].goal_setting_msg = self.goal_setting(chat_id, self.current_users[chat_id].lowerbody_score, self.current_users[chat_id].upperbody_score)
elif text in self.data['new_time'] or msg['text'] == self.data['checkup_keyboard'][self.current_users[chat_id].language][2]:
self.current_users[chat_id].times_setting_msg = self.times_setting(chat_id)
elif text in self.data['new_condition'] or msg['text'] == self.data['checkup_keyboard'][self.current_users[chat_id].language][3]:
self.current_users[chat_id].lowerbody_setting_msg = self.lowerbody_setting(chat_id)
elif text in self.data['new_language']:
self.current_users[chat_id].language_setting_msg = self.language_setting(chat_id)
elif text in self.data['new_location']:
self.current_users[chat_id].location_setting_msg = self.location_setting(chat_id)
elif msg['text'] == self.data['checkup_keyboard'][self.current_users[chat_id].language][0]:
text_msg = self.data['checkup_continue_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg, reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
elif msg['message_id'] - self.current_users[chat_id].language_setting_msg < 5 and text in ['english','finnish']:
self.current_users[chat_id].language = text[:2]
self.current_users[chat_id].language_setting_msg = -1000
if self.current_users[chat_id].reset:
self.current_users[chat_id].location_setting_msg = self.location_setting(chat_id)
else:
text_msg = self.data['language_response'][text[:2]]
self.sendMessage(chat_id, text_msg, reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.updateUserDB(chat_id)
elif msg['message_id'] - 1 == self.current_users[chat_id].location_setting_msg:
g = geocoder.google(text)
if len(g.latlng) == 0:
text_msg = self.data['location_fail_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg)
self.current_users[chat_id].location_setting_msg = self.location_setting(chat_id)
return
tf = TimezoneFinder()
self.current_users[chat_id].location = [g.latlng[1], g.latlng[0]]
point = (g.latlng[1], g.latlng[0])
self.current_users[chat_id].timezone = tf.timezone_at(*point)
if self.current_users[chat_id].reset:
self.current_users[chat_id].lowerbody_setting_msg = self.lowerbody_setting(chat_id)
else:
markup = ReplyKeyboardMarkup(keyboard=[
[self.data['time_keyboard'][self.current_users[chat_id].language]],
],resize_keyboard=True,one_time_keyboard=True)
text_msg = self.data['location_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg, reply_markup=markup)
self.updateUserDB(chat_id)
elif msg['message_id'] - self.current_users[chat_id].lowerbody_setting_msg < 5 and msg['text'] in self.data['lowerbody_keyboard'][self.current_users[chat_id].language]:
self.current_users[chat_id].lowerbody_score = self.data['lowerbody_keyboard'][self.current_users[chat_id].language].index(msg['text'])
self.current_users[chat_id].lowerbody_setting_msg = -1000
self.current_users[chat_id].upperbody_setting_msg = self.upperbody_setting(chat_id)
elif msg['message_id'] - self.current_users[chat_id].upperbody_setting_msg < 5 and msg['text'] in self.data['upperbody_keyboard'][self.current_users[chat_id].language]:
self.current_users[chat_id].upperbody_score = self.data['upperbody_keyboard'][self.current_users[chat_id].language].index(msg['text'])
self.current_users[chat_id].upperbody_setting_msg = -1000
if self.current_users[chat_id].reset:
self.current_users[chat_id].times_setting_msg = self.times_setting(chat_id)
else:
text_msg = self.data['condition_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg,reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.updateUserDB(chat_id)
elif msg['message_id'] - self.current_users[chat_id].times_setting_msg < 5 and text.isdigit():
self.current_users[chat_id].times = int(text)
self.current_users[chat_id].times_setting_msg = -1000
self.current_users[chat_id].time_setting_msg = self.time_setting(chat_id)
self.current_users[chat_id].timeslots = []
elif msg['message_id'] - self.current_users[chat_id].time_setting_msg < 10:
try:
naive = datetime.strptime ("2016-4-27 " + msg['text'], "%Y-%m-%d %H:%M")
except ValueError:
text_msg = self.data['time_fail_response'][self.current_users[chat_id].language]
return self.sendMessage(chat_id, text_msg)
local = pytz.timezone (self.current_users[chat_id].timezone)
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone (pytz.utc)
self.current_users[chat_id].timeslots.append(utc_dt.strftime("%H"))
if len(self.current_users[chat_id].timeslots) == self.current_users[chat_id].times:
self.current_users[chat_id].time_setting_msg = - 1000
if self.current_users[chat_id].reset:
self.current_users[chat_id].goal_setting_msg = self.goal_setting(chat_id, self.current_users[chat_id].lowerbody_score, self.current_users[chat_id].upperbody_score)
else:
text_msg = self.data['time_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg, reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.updateUserDB(chat_id)
elif msg['message_id'] - 1 == self.current_users[chat_id].goal_setting_msg:
goal = self.db.goals.find_one({self.current_users[chat_id].language: msg['text']})
if not goal:
text_msg = self.data['goal_fail_response'][self.current_users[chat_id].language]
self.sendMessage(chat_id, text_msg)
self.current_users[chat_id].goal_setting_msg = self.goal_setting(chat_id, self.current_users[chat_id].lowerbody_score, self.current_users[chat_id].upperbody_score)
return
goal['timestamp'] = datetime.now()
self.current_users[chat_id].timestamp = datetime.now()
self.current_users[chat_id].goals.insert(0,goal)
if self.current_users[chat_id].reset:
text_msg = self.data['setup_done_response'][self.current_users[chat_id].language]
else:
text_msg = self.data['goal_response'][self.current_users[chat_id].language] + text
self.sendMessage(chat_id, text_msg,reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.updateUserDB(chat_id)
elif msg['text'] in self.data['exercise_keyboard'][self.current_users[chat_id].language]:
exercise = list(self.db[str(chat_id)].find().limit(1).sort([('_id',-1)]))[0]
answered_timestamp = datetime.now()
if msg['text'] == self.data['exercise_keyboard'][self.current_users[chat_id].language][0]:
done = 1
self.db.users.find_one_and_update({'chat_id': chat_id},{ '$inc': {
'strength' : exercise['strength'],
'stretching' : exercise['stretching'],
'balance' : exercise['balance'],
'core' : exercise['core'],
'hands' : exercise['hands'],
'arms' : exercise['arms'],
'legs' : exercise['legs'],
'done' : 1} })
self.sendMessage(chat_id, self.doing_exercise_response(self.current_users[chat_id].language),reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.sendMessage(chat_id, self.data['exercise_done_response'][self.current_users[chat_id].language])
else:
done = 0
self.sendMessage(chat_id, self.skip_exercise_response(self.current_users[chat_id].language),reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
self.db[str(chat_id)].update_one({'_id': exercise['_id']}, {'$set':{'answered_timestamp': answered_timestamp, 'done': done}})
del self.current_users[chat_id]
elif msg['text'] in self.data['question_keyboard'][self.current_users[chat_id].language]:
if chat_id in self.users_to_send_msg:
answer = {}
answer['chat_id'] = chat_id
answer['question_content'] = self.users_to_send_msg[chat_id]['question_msg']['text']
answer['answer'] = msg['text']
answer['question_id'] = self.users_to_send_msg[chat_id]['question']['_id']
answer['timestamp'] = datetime.now()
self.db.answers.insert_one(answer)
del self.users_to_send_msg[chat_id]
self.sendMessage(chat_id, self.data['question_resonse'][self.current_users[chat_id].language] + u'\U0001f44d', reply_markup=self.defaultMarkup[self.current_users[chat_id].language])
del self.current_users[chat_id]
else:
response_msg = self.random_response(text)
self.sendMessage(chat_id, response_msg)
def do_the_things(lat, lon, chagdays=2, offset=0):
tf = TimezoneFinder()
tzname = tf.timezone_at(lng=lon, lat=lat)
try:
tz = pytz.timezone(tzname)
except pytz.exceptions.UnknownTimeZoneError:
tz = pytz.timezone('UTC')
now = datetime.datetime.now(tz=tz)
if offset is not None:
now += datetime.timedelta(minutes=offset)
noon = tz.localize(
datetime.datetime(year=now.year,
month=now.month,
day=now.day,
hour=12,
minute=30))
today = now.date()
tomorrow = today + datetime.timedelta(days=1)
# Get Hebrew calendar dates
hebtoday = hebrew.from_gregorian(today.year, today.month, today.day)
hebtomorrow = hebrew.from_gregorian(tomorrow.year, tomorrow.month,
tomorrow.day)
hebmonthtoday = hebrew_monthname(hebtoday)
hebmonthtomorrow = hebrew_monthname(hebtomorrow)
omertoday = omer_day(hebtoday)
omertonight = omer_day(hebtomorrow)
# Set up ephem info to determine sunset and nightfall
herenow = ephem.Observer()
herenow.lat, herenow.lon = lat * ephem.pi / 180, lon * ephem.pi / 180
herenow.date = ephem.Date(now.astimezone(pytz.utc))
herenoon = ephem.Observer()
herenoon.lat, herenoon.lon = lat * ephem.pi / 180, lon * ephem.pi / 180
herenoon.date = ephem.Date(noon.astimezone(pytz.utc))
sun = ephem.Sun()
# Determine "set" and "dark" for today (may be in the past)
try:
todayrise_eph = herenoon.previous_rising(sun)
todayrise = pytz.utc.localize(todayrise_eph.datetime()).astimezone(tz)
todayrise_txt = todayrise.isoformat(timespec='seconds')
tonightset_eph = herenoon.next_setting(sun)
tonightset = pytz.utc.localize(
tonightset_eph.datetime()).astimezone(tz)
tonightset_txt = tonightset.isoformat(timespec='seconds')
except ephem.NeverUpError:
todayrise_txt = 'downallday'
tonightset_txt = 'downallday'
except ephem.AlwaysUpError:
todayrise_txt = 'upallday'
tonightset_txt = 'upallday'
oldhorizon = herenoon.horizon
oldpressure = herenoon.pressure
herenoon.pressure = 0
# All horizon math is from top of sun disk
# We need to take into account sun's radius, averaging .266 degrees
herenoon.horizon = "-8.233" # middle of sun 8.5 deg
try:
tonightdark_eph = herenoon.next_setting(sun)
tonightdark = pytz.utc.localize(
tonightdark_eph.datetime()).astimezone(tz)
tonightdark_txt = tonightdark.isoformat(timespec='seconds')
except ephem.NeverUpError:
tonightdark_txt = 'alwaysdark'
except ephem.AlwaysUpError:
tonightdark_txt = 'none'
herenoon.horizon = oldhorizon
herenoon.pressure = oldpressure
# Status of sun, handle no-rise/no-set cases first
if todayrise_txt == "upallday":
sunnow = "up"
elif (todayrise_txt == 'downallday'
and (tonightdark == 'alwaysdark' or tonightdark < now)):
sunnow = "down"
elif todayrise_txt == 'downallday':
sunnow = "twilight"
# normal cases
elif todayrise > now:
sunnow = "notyetup"
elif tonightset > now:
sunnow = "up"
elif (tonightdark_txt == 'none' or tonightdark > now):
sunnow = "twilight"
else:
sunnow = "down"
# Is it Shabbat or a holiday?
shabbat_or_holiday_today = (today.isoweekday() == 6)
if (jewish_holiday(date=hebtoday, chagdays=chagdays)):
shabbat_or_holiday_today = True
shabbat_or_holiday_tonight = (today.isoweekday() == 5)
if (jewish_holiday(date=hebtomorrow, chagdays=chagdays)):
shabbat_or_holiday_tonight = True
# Combine hebdate logic and shabbat/holiday logic with sun up/down logic
if (sunnow == "notyetup" or sunnow == "up"):
shabbat_or_holiday_now = shabbat_or_holiday_today
hebrew_date_now = "{} {}, {}".format(hebtoday[2], hebmonthtoday,
hebtoday[0])
omernow = omertoday
elif (sunnow == "down"):
shabbat_or_holiday_now = shabbat_or_holiday_tonight
hebrew_date_now = "{} {}, {}".format(hebtomorrow[2], hebmonthtomorrow,
hebtomorrow[0])
omernow = omertonight
elif (sunnow == "twilight"):
shabbat_or_holiday_now = (shabbat_or_holiday_today
or shabbat_or_holiday_tonight)
hebrew_date_now = "indeterminate"
if omertoday > 0 and omertonight > 0:
omernow = omertoday + 0.5
else:
omernow = 0
else:
raise ValueError("How is the sun not up or down or twilight?")
# time for output
to_return = {}
to_return["results"] = {
"now":
now.astimezone(tz).isoformat(timespec='seconds'),
"sunrise":
todayrise_txt,
"sunset":
tonightset_txt,
"jewish_twilight_end":
tonightdark_txt,
"sun_now":
sunnow,
"hebrew_date_today":
"{} {}, {}".format(hebtoday[2], hebmonthtoday, hebtoday[0]),
"hebrew_date_tonight":
"{} {}, {}".format(hebtomorrow[2], hebmonthtomorrow, hebtomorrow[0]),
"hebrew_date_now":
hebrew_date_now,
"shabbat_or_yom_tov_today":
shabbat_or_holiday_today,
"shabbat_or_yom_tov_tonight":
shabbat_or_holiday_tonight,
"shabbat_or_yom_tov_now":
shabbat_or_holiday_now,
}
if omertoday > 0:
to_return["results"]["omer_today"] = omertoday
if omertonight > 0:
to_return["results"]["omer_tonight"] = omertonight
if omernow > 0:
to_return["results"]["omer_now"] = omernow
return json.dumps(to_return)
lat = float(argv[1])
lon = float(argv[2])
except Exception as e:
print(e)
exit()
try:
from timezonefinder import TimezoneFinder
except Exception as e:
print(e)
exit()
tz = TimezoneFinder()
try:
tz_str = tz.timezone_at(lng=lon, lat=lat)
if tz_str == None:
#tz_str = tz.certain_timezone_at(lng=lon, lat=lat)
tz_str = tz.closest_timezone_at(lng=lon, lat=lat)
print(tz_str)
if tz_str != None:
cmd = [
"sudo",
"timedatectl",
"set-timezone",
tz_str,
]
print(cmd)
def gettimezone(latitude, longitude):
tf = TimezoneFinder()
return tf.timezone_at(lat=latitude, lng=longitude)
from timezonefinder import TimezoneFinder tf = TimezoneFinder() lat = 32.23114 lon = -110.94548 print(tf.timezone_at(lng=lon, lat=lat))
def timezone(self):
tf = TimezoneFinder()
return tf.timezone_at(lng=self.longitude, lat=self.latitude)
def interpolate_time(fflightLog):
gpsEventDict = collections.OrderedDict(
) # stores position,altitude,video status, interpolation indicator with time as key
gpsEventList = []
rowCount = 0
timestamp = 0
seedTime = 0
newTime = 0
prevTime = 0
nextTime = 0
lastTime = 0
timeDelta = 0
takingVideo = '0'
prevLat = 0.0
nextLat = 0.0
prevLong = 0.0
nextLong = 0.0
prevAlt = 0.0
nextAlt = 0.0
latitude = 0.0
longitude = 0.0
altitude = 0.0
with open(fflightLog, 'rU') as log:
header = next(log) # Skip the header row
previous = next(
log) # Save the initial data row for comparison with next row
rowCount += 1
rowFields = previous.split(',')
latitude = float(rowFields[0])
longitude = float(rowFields[1])
utmPosition = utm.from_latlon(latitude, longitude)
utmPositionX = utmPosition[0]
utmPositionY = utmPosition[1]
utmLatZone = utmPosition[2]
utmLongZone = utmPosition[3]
altitude = float(
rowFields[2]) * 0.3048 # Convert altitude in feet to meters
lYear = rowFields[11][0:4]
lMonth = rowFields[11][5:7]
lDay = rowFields[11][8:10]
lhours = rowFields[11][11:13]
lminutes = rowFields[11][14:16]
lsecs = rowFields[11][17:19]
lmsecs = rowFields[11][20:]
lDate = lYear + '/' + lMonth + '/' + lDay
lTime = lhours + ':' + lminutes + ':' + lsecs + '.' + lmsecs
takingVideo = rowFields[37]
timestamp = int(rowFields[43])
interpolated = False # The row is read directly from the file and is therefore not interpolated
tf = TimezoneFinder()
tzone = tf.timezone_at(lng=longitude, lat=latitude)
prevTime = timestamp
prevLat = latitude
prevLong = longitude
prevAlt = altitude
# Store the log data for first row if video was enabled
if takingVideo == '1':
# Convert the timestamp to UTC time
dateTimeStr = datetime.datetime.utcfromtimestamp(
timestamp / 1000.0).strftime('%Y/%m/%d %H:%M:%S.%f')
DateStr = dateTimeStr.split(' ')[0]
TimeStr = dateTimeStr.split(' ')[1]
# Store the first row of the log
gpsEventList = [
DateStr, TimeStr, latitude, longitude, altitude, takingVideo,
interpolated, timestamp, UtmPositionX, UtmPositionY,
UtmLatZone, UtmLongZone
]
gpsEventDict[timestamp] = gpsEventList
for row in log: # Now start processing the rest of the log
rowCount += 1
rowFields = row.split(',')
latitude = float(rowFields[0])
longitude = float(rowFields[1])
utmPosition = utm.from_latlon(latitude, longitude)
utmPositionX = utmPosition[0]
utmPositionY = utmPosition[1]
utmLatZone = utmPosition[2]
utmLongZone = utmPosition[3]
altitude = float(rowFields[2]) * 0.3048
lYear = rowFields[11][0:4]
lMonth = rowFields[11][5:7]
lDay = rowFields[11][8:10]
lhours = rowFields[11][11:13]
lminutes = rowFields[11][14:16]
lsecs = rowFields[11][17:19]
lmsecs = rowFields[11][20:]
lDate = lYear + '/' + lMonth + '/' + lDay
lTime = lhours + ':' + lminutes + ':' + lsecs + '.' + lmsecs
takingVideo = rowFields[37]
timestamp = int(rowFields[43])
interpolated = False
#print utmPositionX,utmPositionY,altitude
if takingVideo == '1':
# Always store the data from the row read from the log
# Convert the timestamp to UTC time
dateTimeStr = datetime.datetime.utcfromtimestamp(
timestamp / 1000.0).strftime('%Y/%m/%d %H:%M:%S.%f')
DateStr = dateTimeStr.split(' ')[0]
TimeStr = dateTimeStr.split(' ')[1]
# Store the log data
gpsEventList = [
DateStr, TimeStr, latitude, longitude, altitude,
takingVideo, interpolated, timestamp, utmPositionX,
utmPositionY, utmLatZone, utmLongZone
]
gpsEventDict[timestamp] = gpsEventList
# Start interpolation
timeDelta = timestamp - prevTime
latDelta = latitude - prevLat
longDelta = longitude - prevLong
altDelta = altitude - prevAlt
if seedTime == 0:
seedTime = round((timestamp + 5) / 1000.0, 2) * 1000
newTime = seedTime
# Normal sampling interval is 100ms. The interpolated sampling interval is 10 ms.
# If the difference between the two times of interest is > 20 ms perform interpolation
lastTime = prevTime
if abs(timeDelta) > 10:
interpolated = True
newLat = prevLat
newLong = prevLong
newAlt = prevAlt
while newTime < timestamp:
timeFraction = (newTime - lastTime) / timeDelta
if latDelta > 0.0:
newLat += abs(latDelta) * timeFraction
elif latDelta < 0.0:
newLat -= abs(latDelta) * timeFraction
if longDelta > 0.0:
newLong += abs(longDelta) * timeFraction
elif longDelta < 0.0:
newLong -= abs(longDelta) * timeFraction
if altDelta > 0.0:
newAlt += abs(altDelta) * timeFraction
elif altDelta < 0.0:
newAlt -= abs(altDelta) * timeFraction
newTimeStr = datetime.datetime.utcfromtimestamp(
newTime / 1000.0).strftime('%Y/%m/%d %H:%M:%S.%f')
newDateStr = newTimeStr.split(' ')[0]
newTimeStr = newTimeStr.split(' ')[1]
newUtmPosition = utm.from_latlon(newLat, newLong)
newUtmPositionX = newUtmPosition[0]
newUtmPositionY = newUtmPosition[1]
newUtmLatZone = newUtmPosition[2]
newUtmLongZone = newUtmPosition[3]
gpsEventList = [
newDateStr, newTimeStr, newLat, newLong, newAlt,
takingVideo, interpolated, newTime,
newUtmPositionX, newUtmPositionY, newUtmLatZone,
newUtmLongZone
]
gpsEventDict[newTime] = gpsEventList
lastTime = newTime
newTime += 10
#print '*',newUtmPositionX, newUtmPositionY, newAlt
#time.sleep(0.1)
else:
newTime += 0
prevTime = timestamp
prevLat = latitude
prevLong = longitude
prevAlt = altitude
return gpsEventDict, tzone
def render_html(scene, geocoder, start, icons):
trackpoints = scene.trackpoints
if not trackpoints:
print('EMPTY')
return 'NOTHING'
lat0 = trackpoints[0].latitude_degrees
lon0 = trackpoints[0].longitude_degrees
geocodes = geocoder.search(lat0, lon0)
geocode = geocodes[0]
from timezonefinder import TimezoneFinder
tf = TimezoneFinder()
name = tf.timezone_at(lng=lon0, lat=lat0)
tz = pytz.timezone(name)
utc = pytz.utc
print(tz)
for p in trackpoints:
if p.time is not None:
p.time = utc.localize(p.time).astimezone(tz)
route = [[p.latitude_degrees, p.longitude_degrees] for p in trackpoints]
#mileposts = []
mileposts = list(insert_mileposts(trackpoints))
icons.extend(
{
'lat': p.latitude_degrees,
'lon': p.longitude_degrees,
'label': '{:.0f} mi<br>{:%-I:%M} {}'.format(
p.distance_meters * MILES_PER_METER,
p.time,
p.time.strftime('%p').lower(),
) if p.time else '{:.0f}'.format(
p.distance_meters * MILES_PER_METER,
),
}
for p in mileposts
)
def compute_splits(trackpoints, mileposts):
previous = trackpoints[0]
for m in mileposts + [trackpoints[-1]]:
meters = m.distance_meters - previous.distance_meters
duration = m.time - previous.time if m.time else None
yield Split(
start = previous.time,
end = m.time,
duration = duration,
meters = meters,
mph = mph(meters, duration),
elevation_meters = m.elevation_meters,
elevation_gain_meters = (
m.elevation_gain_meters - previous.elevation_gain_meters
if previous else nan
),
elevation_loss_meters = (
m.elevation_loss_meters - previous.elevation_loss_meters
if previous else nan
),
)
previous = m
splits = list(compute_splits(trackpoints, mileposts))
if trackpoints[0].time is None:
duration = None
else:
duration = trackpoints[-1].time - trackpoints[0].time
meters = trackpoints[-1].distance_meters
miles = meters * MILES_PER_METER
#mph = miles / duration.total_seconds() * 60 * 60
# TODO: read only once instead of N times
template_path = 'test.template.html'
with open(template_path) as f:
template_html = f.read()
def to_url(cache_file_path):
if not cache_file_path:
return None
return (cache_file_path
.split('/')[-1]
.replace('.xml', '.html'))
template = SimpleTemplate(template_html)
content = template.render(
duration=duration,
escale=FEET_PER_METER,
icons=json.dumps(icons),
route=json.dumps(route),
miles=miles,
mph=mph(meters, duration),
nan=nan,
next_url=to_url(scene.next),
previous_url=to_url(scene.previous),
splits=splits,
start=start or trackpoints[0].time,
)
#print(splits)
return content
with open(output_path, 'w') as f:
f.write(content)
print(geocode)
return Summary(
geocode=geocode,
start=trackpoints[0].time,
miles=miles,
url=output_path.name,
)
lambda t: t.strftime('%Y-%m-%d %H:%M'))
tf = TimezoneFinder()
dt_UTC = [] #create an empty list for the UTC times
dt_zone = [] #create an empty list for the zones, just to check
for i in range(df.shape[0]):
raw_dat = df.iloc[i].tolist()
#Get store positions of the lat and lon columns in the dataframe
lat_pos = df.columns.get_loc("Latitude_(decimal_degrees)")
lon_pos = df.columns.get_loc("Longitude_(decimal_degrees)")
#pass lat and lon positions
latitude, longitude = raw_dat[lat_pos], raw_dat[lon_pos]
zone = tf.timezone_at(lng=longitude, lat=latitude)
dt_zone.append(zone)
print("converting to UTC for timezone: " + zone)
local = pytz.timezone(zone) #set local time zone string
dt_pos = df.columns.get_loc("Local_Date_Time")
naive = datetime.datetime.strptime(raw_dat[dt_pos], "%Y-%m-%d %H:%M")
local_dt = local.localize(naive, is_dst=None)
utc_dt = local_dt.astimezone(pytz.utc)
dt_UTC.append(utc_dt.strftime("%Y-%m-%d %H:%M:%S"))
#make a columns for converted time and time zone
df["UTC"] = dt_UTC
df['zone'] = dt_zone
#Split the time into db friendly columns
df['UTC_Date_sampled_(YYYY-MM-DD)'] = df['UTC'].apply(lambda x: x).str.split(
def prepareCityForecast(self, res, data):
if res != {}:
tf = TimezoneFinder()
#print(res)
if res.get("list") and res["list"] != None:
#print("there is a list of forecasts")
forecasts = []
for i in range(0, len(res["list"])):
forecast = {
"temp":
res["list"][i]["main"]["temp"],
"feels_like":
res["list"][i]["main"]["feels_like"],
"min_temp":
res["list"][i]["main"]["temp_min"],
"max_temp":
res["list"][i]["main"]["temp_max"],
"pressure":
res["list"][i]["main"]["pressure"],
"humidity":
res["list"][i]["main"]["humidity"],
"main":
res["list"][i]["weather"][0]["main"],
"description":
res["list"][i]["weather"][0]["description"],
"icon":
res["list"][i]["weather"][0]["icon"],
"dt":
res["list"][i]["dt"],
"date_text":
datetime.datetime.fromtimestamp(
res["list"][i]["dt"],
tz=timezone(
tf.timezone_at(lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"])
)).strftime("%m-%d-%Y %I:%M:%S %p %Z"),
"date_time":
datetime.datetime.fromtimestamp(
res["list"][i]["dt"],
tz=timezone(
tf.timezone_at(
lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"]))),
"dt_txt":
res["list"][i]["dt_txt"]
}
forecasts.append(forecast)
data.update({"forecasts": forecasts})
if res.get("city") and res["city"] != None:
data.update({
"latitude":
res["city"]["coord"]["lat"],
"longitude":
res["city"]["coord"]["lon"],
"local_timezone":
timezone(
tf.timezone_at(lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"])),
"country":
res["city"]["country"],
"sunrise":
datetime.datetime.fromtimestamp(
res["city"]["sunrise"],
tz=timezone(
tf.timezone_at(lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"]))),
"sunset":
datetime.datetime.fromtimestamp(
res["city"]["sunset"],
tz=timezone(
tf.timezone_at(lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"]))),
"timestamp":
datetime.datetime.now(tz=timezone(
tf.timezone_at(lng=res["city"]["coord"]["lon"],
lat=res["city"]["coord"]["lat"])
)), #.strftime("%A %B %d, %Y %I:%M:%S %p %Z"),
"name":
res["city"]["name"]
})
import pytz
from datetime import datetime, timezone, timedelta
from timezonefinder import TimezoneFinder
tf = TimezoneFinder()
lat, lon = -33.3804, -70.58017 # America/Santiago
tzName = tf.timezone_at(lng=lon, lat=lat)
print('tzName:', tzName)
remoteTz = pytz.timezone(tzName)
localTz = datetime.now().astimezone().tzinfo
nowHere = datetime.now(tz=localTz)
nowThere = datetime.now(tz=remoteTz)
print('now here: ', nowHere)
print('now there:', nowThere)
print('KOHEU.')
#Reference :
# : https://pypi.python.org/pypi/timezonefinder Python library to look up timezone from lat / long offline
# : https://pypi.python.org/pypi/pytz World timezone definitions
import pytz
from geopy.geocoders import Nominatim
from timezonefinder import TimezoneFinder
import datetime
try:
geolocator = Nominatim()
place = input('Enter city name : ')
loc = geolocator.geocode(place)
tf = TimezoneFinder()
timezone = tf.timezone_at(lat=loc.latitude, lng=loc.longitude)
time = datetime.datetime.now(pytz.timezone(timezone))
print("Location :", loc.address, str(time).split('.')[0])
except Exception as e:
print(str(e))
from timezonefinder import TimezoneFinder
TimezoneFinder.using_numba() # this is a static method returning True or False
tf = TimezoneFinder()
# or
tf = TimezoneFinder(in_memory=True)
longitude, latitude = 13.358, 52.5061
tf.timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Berlin'
tf.certain_timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Berlin'
longitude = 12.773955
latitude = 55.578595
tf.closest_timezone_at(lng=longitude,
lat=latitude) # returns 'Europe/Copenhagen'
longitude = 42.1052479
latitude = -16.622686
tf.closest_timezone_at(lng=longitude,
lat=latitude,
delta_degree=2,
exact_computation=True,
return_distances=True,
force_evaluation=True)
tf.get_geometry(tz_name='Africa/Addis_Ababa', coords_as_pairs=True)
tf.get_geometry(tz_id=400, use_id=True)
# To maximize the chances of getting a result in a Django view it might look like:
def today_or_tomorrow_sunset(lat, lon):
"""determines if you should use todays or tomorrows sunset and gives the coordinates"""
# **** Must give the api the 'local' sunset date in order to return the
# day variable of 'today' or 'tomorrow'. ****
current_date = datetime.date.today()
current_date_str = current_date.strftime('%Y-%m-%d')
#getting current utc for object comparison
current_utc = datetime.datetime.utcnow()
# import pdb; pdb.set_trace()
#This doesn't always work...???
#using tzwhere to get the timezone for given coordinates
#ATTEMPTING TO USE DIFFERENT LIBRARY FOR TZ FINDER
# tz = tzwhere.tzwhere()
# try:
# tz_str = tz.tzNameAt(lat, lon)
# except:
# raise NoTimeZoneAvailable('No Time Zone Available')
# **************************** #
# OH MAH GURD SO MUCH FASTER :)
tf = TimezoneFinder()
tz_str = tf.timezone_at(lng=lon, lat=lat)
#using pytz to make object to calculate utc offset
timezone = pytz.timezone(tz_str)
tz_offset = timezone.utcoffset(current_utc)
#datetime/date object according to the coordinates entered!
current_local_time = current_utc + tz_offset
current_local_date = current_local_time.date()
#Find sunset time local to given airport
sunset_time_today = return_sunset_time(lat, lon, current_local_date)
#Creating datetime objects with strptime:
#'2017-11-09T01:03:37+00:00' is the format for the sunet time.
sunset_time_today_obj = datetime.datetime.strptime(
sunset_time_today, '%Y-%m-%dT%H:%M:%S+00:00')
#If Sunset has already passed, we want to give you tomorrow's time.
#sunset_time greater means the sunset has NOT happened already, so use today.
if sunset_time_today_obj > current_utc:
sunset_time_obj = sunset_time_today_obj
day = 'today'
else:
#Getting tomorrow's date:
tomorrow = current_date + datetime.timedelta(days=1)
#Getting sunset time using tomorrow's date
sunset_time_tomorrow = return_sunset_time(lat, lon, tomorrow)
#Setting the sunset time = tomorrow's sunset time
sunset_time_obj = datetime.datetime.strptime(
sunset_time_tomorrow, '%Y-%m-%dT%H:%M:%S+00:00')
day = 'tomorrow'
sunset_time_str = sunset_time_obj.strftime('%Y-%m-%d %H:%M:%S UTC')
#To make it prettier, get rid of microseconds.
current_local_time = current_local_time.replace(microsecond=0)
current_local_time = current_local_time.time()
sunset_time_obj = sunset_time_obj.replace(microsecond=0)
local_sunset_time = sunset_time_today_obj + tz_offset
local_sunset_time = local_sunset_time.time()
return {
'time': sunset_time_obj,
'day': day,
'sunset_str': sunset_time_str,
'local_time': current_local_time,
'local_tz': timezone,
'local_sunset_time': local_sunset_time
}
def results():
try:
location_input = request.form.get('location')
except:
location_input = "Arcata, CA"
try:
size_input = float(request.form.get('size'))
except:
size_input = 3.5
# creating location characteristics
city, state = location_input.split(',')
city = city.strip()
state = state.strip()
tf = TimezoneFinder()
# convert location to latitude and longitude
geolocator = Nominatim(user_agent="powerpredictor")
geopy.geocoders.options.default_timeout = 60
location = geolocator.geocode(location_input)
latitude = location.latitude
longitude = location.longitude
tzone = tf.timezone_at(lng=longitude, lat=latitude)
altitude = location.altitude
# get NSRDB data for 2017
nsrdb_data = nsrdb.get_nsrdb_data(latitude, longitude, config.nrel_api_key)
# get weather forecast
ds_data = ds.get_forecast(latitude, longitude, config.ds_key)
# get pvlib irradiances
start_time = ds_data['datetime'].min()
end_time = ds_data['datetime'].max()
pvlib_data = pv.get_pvlib_data(latitude, longitude, tzone, altitude, city,
start_time, end_time)
# merging forecast and nsrdb data
ds_data['month'] = ds_data['datetime'].dt.month
ds_data['day'] = ds_data['datetime'].dt.day
ds_data['hour'] = ds_data['datetime'].dt.hour
data = pd.merge(ds_data,
nsrdb_data,
on=['month', 'day', 'hour'],
how='left')
# merging data with pvlib data
pvlib_data['datetime'] = pvlib_data.index
pvlib_data['datetime'] = pvlib_data['datetime'].dt.tz_localize(None)
data = pd.merge(data,
pvlib_data[[
'datetime', 'GHI_pvlib', 'DNI_pvlib', 'DHI_pvlib',
'GHI_clearsky'
]],
on='datetime')
# getting predicted GHI
results = pred.predict_ghi(data)
# barchart with power available
results['date'] = results['datetime'].dt.date
results_by_date = results.groupby('date')
# calculating energy as integral of power curve
solar_energy = results_by_date.apply(
lambda x: abs(trapz(x['hour'], x['GHI_pred'])))
max_power = results_by_date.apply(lambda x: max(x['GHI_pred']))
power_values = results_by_date.apply(lambda x: x[x['GHI_pred'] > 0])
power_values.index = pd.to_datetime(power_values['datetime'])
power_by_date = power_values.groupby('date')
avg_power = power_by_date['GHI_pred'].mean()
sys_energy = solar_energy * size_input * 0.77
energy = pd.DataFrame({
'solar_energy': solar_energy,
'max_power': max_power,
'avg_power': avg_power,
'sys_energy': sys_energy
})
energy.index = pd.to_datetime(energy.index)
energy['day_name'] = energy.index.day_name()
energy['short_day'] = energy.index.strftime("%a").astype(str)
# getting rid of erroneous values
energy = energy.drop(energy.index[-1])
energy = energy.drop(energy.index[0])
# getting the plot
plotscript, plotdiv = pm.make_plot(energy)
# average power per day
power_average = (energy['sys_energy'].mean() / 1000).round(2)
return render_template('results.html',
MESSAGE_MID=power_average,
size_input=size_input,
plotscript=plotscript,
plotdiv=plotdiv,
latitude=latitude,
longitude=longitude)
'urdb_label': urdb_label,
'net_metering_limit_kw': net_metering_limit
},
'Storage': {
'total_rebate_us_dollars_per_kwh': kwh_rebate
},
}
}
},
'climate_zone': climate_zone,
'weatherfile': weatherfile,
'latitude': latitude,
'longitude': longitude,
'num_simulations': num_simulations,
'timesteps_per_hour': timesteps_per_hour,
'timezone': timezone_finder.timezone_at(lat=latitude,
lng=longitude)
}
# UUID tags the run based on the dictionary contents so don't overwrite
uuid = getID(flatten_dict(template))
urdb_beginning = urdb_label[:5]
tag = \
f"{location}-{tariff_name}-{urdb_beginning}-net-metering-" \
f"{row['net metering']}-sched-{schedules_type}-{num_simulations}-" \
f"sims-rebate-{kwh_rebate}-{uuid}".replace(' ', '-').lower()
template['tag'] = tag
fname = 'template-' + tag + '.json'
with open(os.path.join(TEMPLATE_DIRECTORY, fname), 'w+') as output:
print(f"writing {fname}...")
json.dump(template, output, indent=2)
def tz_at_coords(lat, lng):
tf = TimezoneFinder()
return tf.timezone_at(lng=lng, lat=lat)
def gps2timezone(lat, lon):
tf = TimezoneFinder()
tz = tf.timezone_at(lng=lon, lat=lat)
return tz
def module_task(self, params):
self.logger.info('Starting Module for edinet baseline...')
"""CHECK INCONSISTENCIES IN params"""
try:
result_companyId = params['result_companyId']
ts_to = params['ts_to']
ts_from = params[
'ts_from'] if 'ts_from' in params else date_n_month(
ts_to, -24)
energyTypeList = params['type'] if 'type' in params else []
save_data_debug = True if 'debug' in params and params[
'debug'] else False
except KeyError as e:
raise Exception(
'Not enough parameters provided to module: {}'.format(e))
#####################################################################################################################################################################################
""" LOAD DATA FROM MONGO MODELLING UNITS """
######################################################################################################################################################################################
self.logger.info('Extracting modelling_units from mongo')
# setting variables for readability
modelling_units_collection = self.config['mongodb'][
'modelling_units_collection']
weather_stations_collection = self.config['mongodb'][
'weather_stations_collection']
lon_lat_tz_dict = {}
tf = TimezoneFinder(in_memory=True)
self.logger.debug('Querying for weather station info in MongoDB')
cursor = self.mongo[weather_stations_collection].find({})
for station in cursor:
lon_lat_tz_dict[station['stationId']] = {
"lat":
station['latitude'],
"lon":
station['longitude'],
"tz":
tf.timezone_at(lat=station['latitude'],
lng=station['longitude'])
}
cursor.close()
tf = None
device_key = {}
stations = {}
solar_station = {}
self.logger.debug('Querying for modelling unit info in MongoDB')
cursor = self.mongo[modelling_units_collection].find({})
for item in cursor:
if len(item['devices']) > 0 and item[
'stationId'] != "Unknown": # to avoid empty list of devices
for dev in item['devices']:
stations[dev['deviceId']] = item[
'stationId'] if 'stationId' in item else None
solar_station[dev['deviceId']] = item[
'solar_station'] if 'solar_station' in item else None
key_str = "{modelling}~{devices}~{lat}~{lon}~{tz}".format(
modelling=item['modellingUnitId'],
devices=item['devices'],
lat=lon_lat_tz_dict[item['stationId']]['lat'],
lon=lon_lat_tz_dict[item['stationId']]['lon'],
tz=lon_lat_tz_dict[item['stationId']]['tz'])
if dev['deviceId'] in device_key.keys():
device_key[dev['deviceId']].append(key_str)
else:
device_key[dev['deviceId']] = [key_str]
cursor.close()
self.logger.info('A mongo query process has loaded {} devices'.format(
len(device_key.keys())))
######################################################################################################################################################################################
""" CREATE INPUT DATA FROM HIVE TABLES """
######################################################################################################################################################################################
# create a table to link devices with stations
self.logger.debug('creating weather hive table')
weather_stations_df = pd.DataFrame(data={
"deviceId": list(stations.keys()),
"stationId": list(stations.values())
},
columns=["deviceId", "stationId"])
f_station = NamedTemporaryFile(delete=False, suffix='.csv')
weather_stations_df.to_csv(f_station.name, header=None, index=None)
call([
"hadoop", "fs", "-mkdir", "-p", f_station.name,
self.config['paths']['stations']
])
call([
"hadoop", "fs", "-copyFromLocal", f_station.name,
self.config['paths']['stations']
])
weather_stations = create_hive_module_input_table(
self.hive,
'edinet_weather_stations_table',
self.config['paths']['stations'], [('deviceId', 'string'),
('stationId', 'string')],
self.task_UUID,
sep=",")
self.context.add_clean_hive_tables(weather_stations)
# create a table to link devices with solar_stations
self.logger.debug('creating solar hive table')
solar_stations_df = pd.DataFrame(data={
"deviceId":
list(solar_station.keys()),
"stationId":
list(solar_station.values())
},
columns=["deviceId", "stationId"])
f_solar_station = NamedTemporaryFile(delete=False, suffix='.csv')
solar_stations_df.to_csv(f_solar_station.name, header=None, index=None)
call([
"hadoop", "fs", "-mkdir", "-p", f_solar_station.name,
self.config['paths']['solar_stations']
])
call([
"hadoop", "fs", "-copyFromLocal", f_solar_station.name,
self.config['paths']['solar_stations']
])
solar_stations = create_hive_module_input_table(
self.hive,
'edinet_solar_stations_table',
self.config['paths']['solar_stations'], [('deviceId', 'string'),
('stationId', 'string')],
self.task_UUID,
sep=",")
self.context.add_clean_hive_tables(solar_stations)
# create a table with the devices values
self.logger.debug('creating input table')
final_table_fields = [
[x[0], x[1]] for x in self.config['hive']['final_table_fields']
]
location = self.config['paths']['measures']
input_table = create_hive_module_input_table(
self.hive, self.config['hive']['job_table_name'], location,
final_table_fields, self.task_UUID)
#add input table to be deleted after execution
self.context.add_clean_hive_tables(input_table)
self.logger.debug('creating hive query')
qbr = RawQueryBuilder(self.hive)
total_select_joint = ", ".join([
"{}.{}".format(x[2], x[0])
for x in self.config['hive']['final_table_fields']
])
sentence = """
INSERT OVERWRITE TABLE {input_table}
SELECT {total_select_joint} FROM
(SELECT ai.deviceid as deviceId, ai.ts as ts, ai.value as value, ai.energyType as energyType FROM edinet_hourly_consumption ai
WHERE
ai.ts >= UNIX_TIMESTAMP("{ts_from}","yyyy-MM-dd HH:mm:ss") AND
ai.ts <= UNIX_TIMESTAMP("{ts_to}","yyyy-MM-dd HH:mm:ss") AND
ai.deviceid IN ({devices})) a
JOIN {weather_stations} b on a.deviceId==b.deviceId
JOIN {solar_stations} b1 on a.deviceId==b1.deviceId
JOIN edinet_meteo c on b.stationId==c.stationId and SUBSTR(FROM_UNIXTIME(a.ts), 1, 13) == SUBSTR(FROM_UNIXTIME(c.ts), 1, 13)
JOIN edinet_meteo d on b1.stationId==d.stationId and SUBSTR(FROM_UNIXTIME(a.ts), 1, 13) == SUBSTR(FROM_UNIXTIME(d.ts), 1, 13)
""".format(input_table=input_table,
total_select_joint=total_select_joint,
ts_from=ts_from,
ts_to=ts_to,
weather_stations=weather_stations,
solar_stations=solar_stations,
devices=", ".join("\"{}\"".format(x)
for x in list(device_key.keys())))
self.logger.debug(sentence)
qbr.execute_query(sentence)
#####################################################################################################################################################################################
""" LOAD from MONGO to HBASE """
######################################################################################################################################################################################
self.logger.info('Getting')
try:
# Launch MapReduce job
## Buffered measures to HBase
self.logger.debug('Baseline Calculation')
self.launcher_hadoop_job(location, device_key, result_companyId,
save_data_debug)
except Exception as e:
raise Exception('MRJob ALIGN process job has failed: {}'.format(e))
self.logger.info('Module EDINET_baseline execution finished...')
def find_optimum_insolation_yearly(longitude, latitude, continuous,
surface_albedo):
tf = TimezoneFinder()
fig2, ax2 = plt.subplots(3, sharex=True, figsize=(10, 12))
legend_labels = []
sun = ephem.Sun()
place = ephem.Observer()
place.lon, place.lat = str(longitude), str(latitude)
sun_insol = []
time_series = []
solar_time_series = []
daily_irradiation = []
sun_insol_atmosphere_perDay = []
beta_logger = []
sd_logger = []
minimum_yearly_logger = []
beta_logger_atm = []
sd_logger_atm = []
minimum_yearly_logger_atm = []
year = 2013
time_zone = tf.timezone_at(lng=longitude, lat=latitude)
utc_offset = pendulum.from_timestamp(0, time_zone).offset_hours
beta_range = range(25, int(latitude + 10))
for b in beta_range:
if continuous:
time = pendulum.datetime(year, 1, 1, 0, 0, 0, tz=time_zone)
place.date = time.in_tz(
'UTC'
) #place.date.datetime() - datetime.timedelta(hours=utc_offset)
for i in range(1, 365):
time_hours, st, daily_irradiation_value, null, null, daily_irradiation_atmosphere = daily_insolation(
time, place, utc_offset, sun, b, surface_albedo)
daily_irradiation.append(daily_irradiation_value)
sun_insol_atmosphere_perDay.append(
daily_irradiation_atmosphere)
time = time.add(days=1)
place.date = time.in_tz('UTC')
progressBar(i, 365, bar_length=20)
# place.date += 1
total_yearly_irradiation = numpy.mean(daily_irradiation)
yearly_deviation = numpy.std(daily_irradiation)
minimum_yearly = numpy.amin(daily_irradiation)
smoothed_atm = signal.savgol_filter(sun_insol_atmosphere_perDay,
101, 3)
total_yearly_irradiation_atm = numpy.mean(smoothed_atm)
yearly_deviation_atm = numpy.std(smoothed_atm)
minimum_yearly_atm = numpy.amin(smoothed_atm)
daily_irradiation = []
sun_insol_atmosphere_perDay = []
print(b, ' degrees: ', total_yearly_irradiation, " sd = ",
yearly_deviation, "min = ", minimum_yearly)
print(b, ' degrees: ', total_yearly_irradiation_atm, " sd = ",
yearly_deviation_atm, "min = ", minimum_yearly_atm)
print("")
beta_logger.append(total_yearly_irradiation)
sd_logger.append(yearly_deviation)
minimum_yearly_logger.append(minimum_yearly)
beta_logger_atm.append(total_yearly_irradiation_atm)
sd_logger_atm.append(yearly_deviation_atm)
minimum_yearly_logger_atm.append(minimum_yearly_atm)
progressBar(b, len(beta_range), bar_length=20)
ax2[0].plot(beta_range, beta_logger, 'r')
ax2[0].plot(beta_range, beta_logger_atm, 'r--')
ax2[0].set_ylabel("Irradiation per year [kJ/m^2/yr]")
ax2[1].plot(beta_range, sd_logger, 'g')
ax2[1].plot(beta_range, sd_logger_atm, 'g--')
ax2[1].set_ylabel("Standard Deviation [kJ/m^2/yr]")
ax2[2].plot(beta_range, minimum_yearly_logger, 'b')
ax2[2].plot(beta_range, minimum_yearly_logger_atm, 'b--')
ax2[2].set_ylabel("Min. irradiation per year [kJ/m^2/yr]")
ax2[2].set_xlabel("Beta angle [deg]")
plt.show()
def parse(xml):
parsed_start_datetime = None
total_distance = {'value': 0.}
tf = TimezoneFinder()
def __filter(n):
cur_p = parsed_points[n]
last_p = parsed_points[n - 1]
cheap_distance = 0
duration = 0.
if parsed_start_datetime is not None and cur_p['time'] is not None:
duration = (parse_time(cur_p['time']) -
parsed_start_datetime).total_seconds()
cur_p['duration'] = duration
# p['smoothed_elevation'] = smoothed_elevations[n]
speed = smoothed_speeds[n] * 3600. / 1000.
cur_p['speed'] = speed if duration < 60 else 0.
if n < 1:
cur_p['total_distance'] = 0.
else:
cheap_distance = cheap_ruler_distance([last_p, cur_p])
total_distance['value'] += cheap_distance / 1000.
cur_p['total_distance'] = total_distance['value']
cur_p['distance'] = cheap_distance
cur_p['slope'] = 100 * (
smoothed_elevations[n - 1] - smoothed_elevations[n]
) / cheap_distance if cheap_distance > 0 else 0.
return cur_p
# Remove namespace to ease nodes selection
gpx_xml = re.sub(' xmlns="[^"]+"', '', xml, count=1)
# find namespace for http://www.garmin.com/xmlschemas/TrackPointExtension/v1
my_namespaces = dict([
node
for _, node in ET.iterparse(StringIO(gpx_xml), events=['start-ns'])
])
try:
track_point_extension_ns_prefix = list(my_namespaces.keys())[list(
my_namespaces.values()).index(
'http://www.garmin.com/xmlschemas/TrackPointExtension/v1')]
except ValueError:
track_point_extension_ns_prefix = None
root = ET.fromstring(gpx_xml)
if root.tag != 'gpx' and root.attrib['version'] != '1.1':
print('Not a GPX 1.1')
name = root.find('metadata/name') or root.find('trk/name')
name = name.text if name is not None else None
description = root.find('metadata/desc') or root.find('trk/desc')
description = description.text if description is not None else ''
parsed_tracks = []
tracks = root.findall('trk')
for track in tracks:
parsed_points = []
segments = track.findall('trkseg')
for segment in segments:
points = segment.findall('trkpt')
for point in points:
elevation = point.find('ele')
time = point.find('time')
temperature = None
heart_rate = None
cadence = None
if track_point_extension_ns_prefix is not None:
extensions = point.find(
'extensions/{}:TrackPointExtension'.format(
track_point_extension_ns_prefix), my_namespaces)
if extensions is not None:
temperature = extensions.find(
'{}:atemp'.format(track_point_extension_ns_prefix),
my_namespaces)
heart_rate = extensions.find(
'{}:hr'.format(track_point_extension_ns_prefix),
my_namespaces)
cadence = extensions.find(
'{}:cad'.format(track_point_extension_ns_prefix),
my_namespaces)
current_point = {
'latitude':
float(point.attrib['lat']),
'longitude':
float(point.attrib['lon']),
'elevation':
float(elevation.text) if elevation is not None else 0.,
'time':
time.text if time is not None else None,
'temperature':
float(temperature.text) if temperature is not None else 0.,
'heart_rate':
float(heart_rate.text) if heart_rate is not None else 0.,
'cadence':
float(cadence.text) if cadence is not None else 0.,
}
parsed_points.append(current_point)
track_name = track.find('name')
track_description = track.find('desc')
smoothed_speeds = get_smoothed_speed(parsed_points)
smoothed_elevations = get_smoothed_data(parsed_points, 'elevation')
uphill, downhill = get_uphill_downhill(smoothed_elevations)
start_datetime = parsed_points[0]['time']
end_datetime = parsed_points[-1]['time']
timezone = tf.timezone_at(lng=parsed_points[0]['longitude'],
lat=parsed_points[0]['latitude'])
total_time = None
average_speed = None
total_distance['value'] = 0.
parsed_points = list(map(__filter, range(len(parsed_points))))
moving_time, moving_distance = get_moving_data(parsed_points)
average_moving_speed = (moving_distance / moving_time
) * 3600. / 1000. if moving_time > 0 else 0.
distance = parsed_points[-1]['total_distance']
if start_datetime and end_datetime:
parsed_start_datetime = parse_time(start_datetime)
parsed_end_datetime = parse_time(end_datetime)
total_time = math.fabs(
(parsed_end_datetime - parsed_start_datetime).total_seconds())
average_speed = (distance / total_time) * 3600. / 1000.
parsed_tracks.append({
'name':
track_name.text if track_name else None,
'description':
track_description.text if track_description else None,
'start_datetime':
start_datetime,
'end_datetime':
end_datetime,
'timezone':
timezone,
'location':
get_location(parsed_points[0]),
'distance':
distance,
'moving_distance':
moving_distance / 1000.,
'uphill':
uphill,
'downhill':
downhill,
'min_altitude':
min(smoothed_elevations),
'max_altitude':
max(smoothed_elevations),
'max_speed':
max(smoothed_speeds) * 3600. / 1000.,
'total_time':
total_time,
'moving_time':
moving_time,
'average_speed':
average_speed,
'average_moving_speed':
average_moving_speed,
'points':
parsed_points,
})
return name, description, parsed_tracks
import pytz
import datetime
import argparse
from timezonefinder import TimezoneFinder
from pygeocoder import Geocoder
location = str(input("Enter location:"))
if location != "":
# Obtain longitude, latitude via Geocoder
result = Geocoder.geocode(location)
coordinate = result[0].coordinates
location = ", ".join([result[0].city, result[0].country])
# Fetch Timezone by longitude, latitude via timezonefinder
tf = TimezoneFinder()
timezone = tf.timezone_at(lat=coordinate[0], lng=coordinate[1])
time = datetime.datetime.now(pytz.timezone(timezone))
print("%s %s" % (location, str(time).split('.')[0]))
class Parameters(CleepModule):
"""
Parameters application.
Allow to configure Cleep parameters:
* system time(current time, sunset, sunrise) according to position
* system locale
Useful doc:
* debian timezone: https://wiki.debian.org/TimeZoneChanges
* python datetime handling: https://hackernoon.com/avoid-a-bad-date-and-have-a-good-time-423792186f30
"""
MODULE_AUTHOR = "Cleep"
MODULE_VERSION = "2.1.1"
MODULE_CATEGORY = "APPLICATION"
MODULE_DEPS = []
MODULE_DESCRIPTION = "Configure generic parameters of your device"
MODULE_LONGDESCRIPTION = (
"Application that helps you to configure generic parameters of your device"
)
MODULE_TAGS = ["configuration", "date", "time", "locale", "lang"]
MODULE_COUNTRY = None
MODULE_URLINFO = "https://github.com/tangb/cleepmod-parameters"
MODULE_URLHELP = None
MODULE_URLBUGS = "https://github.com/tangb/cleepmod-parameters/issues"
MODULE_URLSITE = None
MODULE_CONFIG_FILE = "parameters.conf"
# default position to raspberry pi foundation
DEFAULT_CONFIG = {
"position": {
"latitude": 52.2040,
"longitude": 0.1208
},
"country": {
"country": "United Kingdom",
"alpha2": "GB"
},
"timezone": "Europe/London",
"timestamp": 0,
}
SYSTEM_ZONEINFO_DIR = "/usr/share/zoneinfo/"
SYSTEM_LOCALTIME = "/etc/localtime"
SYSTEM_TIMEZONE = "/etc/timezone"
NTP_SYNC_INTERVAL = 60
def __init__(self, bootstrap, debug_enabled):
"""
Constructor
Args:
bootstrap (dict): bootstrap objects
debug_enabled (bool): flag to set debug level to logger
"""
# init
CleepModule.__init__(self, bootstrap, debug_enabled)
# members
self.hostname = Hostname(self.cleep_filesystem)
self.sun = Sun()
self.sunset = None
self.sunrise = None
self.suns = {
"sunset": 0,
"sunset_iso": "",
"sunrise": 0,
"sunrise_iso": ""
}
self.timezonefinder = TimezoneFinder()
self.timezone_name = None
self.timezone = None
self.time_task = None
self.sync_time_task = None
self.__clock_uuid = None
# code from https://stackoverflow.com/a/106223
self.__hostname_pattern = (
r"^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*"
r"([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$")
# events
self.time_now_event = self._get_event("parameters.time.now")
self.time_sunrise_event = self._get_event("parameters.time.sunrise")
self.time_sunset_event = self._get_event("parameters.time.sunset")
self.hostname_update_event = self._get_event(
"parameters.hostname.update")
self.country_update_event = self._get_event(
"parameters.country.update")
def _configure(self):
"""
Configure module
"""
# add clock device if not already added
if self._get_device_count() < 1:
self.logger.debug("Add default devices")
clock = {"type": "clock", "name": "Clock"}
self._add_device(clock)
# prepare country
country = self._get_config_field("country")
if not country:
self.set_country()
# prepare timezone
timezone_name = self._get_config_field("timezone")
self.timezone = timezone(timezone_name or get_localzone().zone)
# compute sun times
self.set_sun()
# store device uuids for events
devices = self.get_module_devices()
for uuid in devices:
if devices[uuid]["type"] == "clock":
self.__clock_uuid = uuid
def _on_start(self):
"""
Module starts
"""
# restore last saved timestamp if system time seems very old (NTP error)
saved_timestamp = self._get_config_field("timestamp")
if (int(time.time()) - saved_timestamp) < 0:
# it seems NTP sync failed, launch timer to regularly try to sync device time
self.logger.info(
"Device time seems to be invalid (%s), launch synchronization time task",
datetime.datetime.utcnow().isoformat(),
)
self.sync_time_task = Task(Parameters.NTP_SYNC_INTERVAL,
self._sync_time_task, self.logger)
self.sync_time_task.start()
# launch time task (synced to current seconds)
seconds = 60 - (int(time.time()) % 60)
self.time_task = Task(60.0, self._time_task, self.logger)
timer = Timer(0 if seconds == 60 else seconds, self.time_task.start)
timer.start()
def _on_stop(self):
"""
Module stops
"""
if self.time_task:
self.time_task.stop()
def get_module_config(self):
"""
Get full module configuration
Returns:
dict: module configuration
"""
config = {}
config["hostname"] = self.get_hostname()
config["position"] = self.get_position()
config["sun"] = self.get_sun()
config["country"] = self.get_country()
config["timezone"] = self.get_timezone()
return config
def get_module_devices(self):
"""
Return clock as parameters device
Returns:
dict: module devices
"""
devices = super().get_module_devices()
for uuid in devices:
if devices[uuid]["type"] == "clock":
data = self.__format_time()
data.update({
"sunrise": self.suns["sunrise"],
"sunset": self.suns["sunset"]
})
devices[uuid].update(data)
return devices
def __format_time(self):
"""
Return time with different splitted infos
Returns:
dict: time data::
{
timestamp (int): current timestamp
iso (string): current datetime in iso 8601 format
year (int)
month (int)
day (int)
hour (int)
minute (int)
weekday (int): 0=monday, 1=tuesday... 6=sunday
weekday_literal (string): english literal weekday value (monday, tuesday, ...)
}
"""
# current time
utc_now = utc.localize(datetime.datetime.utcnow())
local_now = utc_now.astimezone(self.timezone)
weekday = local_now.weekday()
if weekday == 0:
weekday_literal = "monday"
elif weekday == 1:
weekday_literal = "tuesday"
elif weekday == 2:
weekday_literal = "wednesday"
elif weekday == 3:
weekday_literal = "thursday"
elif weekday == 4:
weekday_literal = "friday"
elif weekday == 5:
weekday_literal = "saturday"
elif weekday == 6:
weekday_literal = "sunday"
return {
"timestamp": datetime.datetime.timestamp(utc_now),
"iso": local_now.isoformat(),
"year": local_now.year,
"month": local_now.month,
"day": local_now.day,
"hour": local_now.hour,
"minute": local_now.minute,
"weekday": weekday,
"weekday_literal": weekday_literal,
}
def _sync_time_task(self):
"""
Sync time task. It is used to try to sync device time using NTP server.
Note:
This task is launched only if device time is insane.
"""
if Parameters.sync_time():
self.logger.info("Time synchronized with NTP server (%s)" %
datetime.datetime.utcnow().isoformat())
self.sync_time_task.stop()
self.sync_time_task = None
def _time_task(self):
"""
Time task used to refresh time
"""
now_formatted = self.__format_time()
self.logger.trace("now_formatted: %s" % now_formatted)
# send now event
now_event_params = copy.deepcopy(now_formatted)
now_event_params.update({
"sunrise": self.suns["sunrise"],
"sunset": self.suns["sunset"]
})
self.time_now_event.send(params=now_event_params,
device_id=self.__clock_uuid)
# send sunrise event
if self.sunrise:
if (now_formatted["hour"] == self.sunrise.hour
and now_formatted["minute"] == self.sunrise.minute):
self.time_sunrise_event.send(device_id=self.__clock_uuid)
# send sunset event
if self.sunset:
if (now_formatted["hour"] == self.sunset.hour
and now_formatted["minute"] == self.sunset.minute):
self.time_sunset_event.send(device_id=self.__clock_uuid)
# update sun times after midnight
if now_formatted["hour"] == 0 and now_formatted["minute"] == 5:
self.set_sun()
# save last timestamp in config to restore it after a reboot and NTP sync failed (no internet)
if not self.sync_time_task:
self._set_config_field("timestamp", now_formatted["timestamp"])
def set_hostname(self, hostname):
"""
Set raspi hostname
Args:
hostname (string): hostname
Returns:
bool: True if hostname saved successfully, False otherwise
Raises:
InvalidParameter: if hostname has invalid format
"""
# check hostname
if re.match(self.__hostname_pattern, hostname) is None:
raise InvalidParameter("Hostname is not valid")
# update hostname
res = self.hostname.set_hostname(hostname)
# send event to update hostname on all devices
if res:
self.hostname_update_event.send(params={"hostname": hostname})
return res
def get_hostname(self):
"""
Return raspi hostname
Returns:
string: raspberry pi hostname
"""
return self.hostname.get_hostname()
def set_position(self, latitude, longitude):
"""
Set device position
Args:
latitude (float): latitude
longitude (float): longitude
Raises:
CommandError: if error occured during position saving
"""
if latitude is None:
raise MissingParameter('Parameter "latitude" is missing')
if not isinstance(latitude, float):
raise InvalidParameter('Parameter "latitude" is invalid')
if longitude is None:
raise MissingParameter('Parameter "longitude" is missing')
if not isinstance(longitude, float):
raise InvalidParameter('Parameter "longitude" is invalid')
# save new position
position = {"latitude": latitude, "longitude": longitude}
if not self._set_config_field("position", position):
raise CommandError("Unable to save position")
# reset python time to take into account last modifications before
# computing new times
time.tzset()
# and update related stuff
self.set_timezone()
self.set_country()
self.set_sun()
# send now event
self._time_task()
def get_position(self):
"""
Return device position
Returns:
dict: position coordinates::
{
latitude (float),
longitude (float)
}
"""
return self._get_config_field("position")
def get_sun(self):
"""
Compute sun times
Returns:
dict: sunset/sunrise timestamps::
{
sunrise (int),
sunset (int)
}
"""
return self.suns
def set_sun(self):
""" "
Compute sun times (sunrise and sunset) according to configured position
"""
# get position
position = self._get_config_field("position")
# compute sun times
self.sunset = None
self.sunrise = None
if position["latitude"] != 0 and position["longitude"] != 0:
self.sun.set_position(position["latitude"], position["longitude"])
self.sunset = self.sun.sunset().astimezone(self.timezone)
self.sunrise = self.sun.sunrise().astimezone(self.timezone)
self.logger.debug("Found sunrise:%s sunset:%s" %
(self.sunrise, self.sunset))
# save times
self.suns["sunrise"] = int(self.sunrise.strftime("%s"))
self.suns["sunrise_iso"] = self.sunrise.isoformat()
self.suns["sunset"] = int(self.sunset.strftime("%s"))
self.suns["sunset_iso"] = self.sunset.isoformat()
def set_country(self):
"""
Compute country (and associated alpha) from current internal position
Warning:
This function can take some time to find country info on slow device like raspi 1st generation (~15secs)
"""
# get position
position = self._get_config_field("position")
if not position["latitude"] and not position["longitude"]:
self.logger.debug(
"Unable to set country from unspecified position (%s)" %
position)
return
# get country from position
country = {"country": None, "alpha2": None}
try:
# search country
coordinates = ((position["latitude"], position["longitude"]), )
# need a tuple
geo = reverse_geocode.search(coordinates)
self.logger.debug("Found country infos from position %s: %s" %
(position, geo))
if (geo and len(geo) > 0 and "country_code" in geo[0]
and "country" in geo[0]):
country["alpha2"] = geo[0]["country_code"]
country["country"] = geo[0]["country"]
# save new country
if not self._set_config_field("country", country):
raise CommandError("Unable to save country")
# send event
self.country_update_event.send(params=country)
except CommandError:
raise
except Exception:
self.logger.exception("Unable to find country for position %s:" %
position)
def get_country(self):
"""
Get country from position
Returns:
dict: return country infos::
{
country (string): country label
alpha2 (string): country code
}
"""
return self._get_config_field("country")
def set_timezone(self):
"""
Set timezone according to coordinates
Returns:
bool: True if function succeed, False otherwise
Raises:
CommandError: if unable to save timezone
"""
# get position
position = self._get_config_field("position")
if not position["latitude"] and not position["longitude"]:
self.logger.warning(
"Unable to set timezone from unspecified position (%s)" %
position)
return False
# compute timezone
current_timezone = None
try:
# try to find timezone at position
current_timezone = self.timezonefinder.timezone_at(
lat=position["latitude"], lng=position["longitude"])
if current_timezone is None:
# extend search to closest position
# TODO increase delta_degree to extend research, careful it use more CPU !
current_timezone = self.timezonefinder.closest_timezone_at(
lat=position["latitude"], lng=position["longitude"])
except ValueError:
# the coordinates were out of bounds
self.logger.exception("Coordinates out of bounds")
except Exception:
self.logger.exception(
"Error occured searching timezone at position")
if not current_timezone:
self.logger.warning(
"Unable to set device timezone because it was not found")
return False
# save timezone value
self.logger.debug("Save new timezone: %s" % current_timezone)
if not self._set_config_field("timezone", current_timezone):
raise CommandError("Unable to save timezone")
# configure system timezone
zoneinfo = os.path.join(self.SYSTEM_ZONEINFO_DIR, current_timezone)
self.logger.debug("Checking zoneinfo file: %s" % zoneinfo)
if not os.path.exists(zoneinfo):
raise CommandError('No system file found for "%s" timezone' %
current_timezone)
self.logger.debug('zoneinfo file "%s" exists' % zoneinfo)
self.cleep_filesystem.rm(self.SYSTEM_LOCALTIME)
self.logger.debug('Writing timezone "%s" in "%s"' %
(current_timezone, self.SYSTEM_TIMEZONE))
if not self.cleep_filesystem.write_data(self.SYSTEM_TIMEZONE,
"%s" % current_timezone):
self.logger.error(
'Unable to write timezone data on "%s". System timezone is not configured!'
% self.SYSTEM_TIMEZONE)
return False
# launch timezone update in background
self.logger.debug("Updating system timezone")
command = Console()
res = command.command(
"/usr/sbin/dpkg-reconfigure -f noninteractive tzdata",
timeout=15.0)
self.logger.debug("Timezone update command result: %s" % res)
if res["returncode"] != 0:
self.logger.error("Error reconfiguring system timezone: %s" %
res["stderr"])
return False
# TODO configure all wpa_supplicant.conf country code
# propagate changes to cleep
self.timezone = timezone(current_timezone)
self._time_task()
return True
def get_timezone(self):
"""
Return timezone
Returns:
string: current timezone name
"""
return self._get_config_field("timezone")
@staticmethod
def sync_time():
"""
Synchronize device time using NTP server
Note:
This command may lasts some seconds
Returns:
bool: True if NTP sync succeed, False otherwise
"""
console = Console()
resp = console.command("/usr/sbin/ntpdate-debian", timeout=60.0)
return resp["returncode"] == 0
def get_non_working_days(self, year=None):
"""
Return non working days of current year
Args:
year (int): get non working day for specified year. If not specified use current year
Returns:
list: list of non working days of the year. List can be empty if error occured::
[
{
datetime (string): non working day (date in iso format YYYY-MM-DD)
label (string): english name of non working day
},
...
]
"""
self._check_parameters([{
"name": "year",
"type": int,
"value": year,
"none": True,
}])
try:
country = self._get_config_field("country")
continent_code = country_alpha2_to_continent_code(
country["alpha2"])
continent_name = convert_continent_code_to_continent_name(
continent_code).lower()
continent_name = (continent_name.lower().replace(
"south", "").replace("north", "").strip())
workalendar = importlib.import_module(
f"workalendar.{continent_name}")
fixed_country = "".join(
[part.capitalize() for part in country["country"].split()])
_class = getattr(workalendar, fixed_country)
_instance = _class()
year = year or datetime.datetime.now().year
holidays = _instance.holidays(year)
return [(date.isoformat(), label) for (date, label) in holidays]
except Exception:
self.logger.exception("Unable to get non working days:")
return []
def is_non_working_day(self, day):
"""
Check if specified day is non working day according to current locale configuration
Args:
day (string): day to check (must be iso format XXXX-MM-DD)
Returns:
bool: True if specified day is a non working day, False otherwise
"""
self._check_parameters([{
"name": "day",
"type": str,
"value": day,
}])
year = datetime.date.fromisoformat(day).year
non_working_days = self.get_non_working_days(year=year)
return any(a_day == day for (a_day, label) in non_working_days)
def is_today_non_working_day(self):
"""
Check if today is non working day according to current locale configuration
Args:
day (datetime.date): day to check
Returns:
bool: True if specified day is a non working day, False otherwise
"""
today = datetime.date.today()
return self.is_non_working_day(today.isoformat())
# Coordinates
gx_track = d.getElementsByTagName('gx:Track')[0]
gx_coord_element = gx_track.getElementsByTagName('gx:coord')
if gx_coord_element.length > 0:
gx_coord = gx_track.getElementsByTagName('gx:coord')[0]
coords = gx_coord.firstChild.data.split(' ')
longitude = float(coords[0])
latitude = float(coords[1])
else:
break
#print("longitude:{0}, latitude:{1}".format(longitude, latitude))
# Get timezone of the coordinates
# t = datetime.tzinfo("America/New_York")
tf = TimezoneFinder()
tz = tzwhere.tzwhere(shapely=True)
timezone_str = tf.timezone_at(lng=longitude, lat=latitude)
# timezone_str = tzwhere.tzNameAt(37.3880961, -5.9823299)
#print("timezone of current location: {0}".format(timezone_str))
t = pytz.timezone(timezone_str)
# begin and end time of the visiting
timespan = d.getElementsByTagName('TimeSpan')[0]
begin = timespan.getElementsByTagName('begin')[0].firstChild.data
begin_datetime = dateutil.parser.parse(begin).astimezone(t)
end = timespan.getElementsByTagName('end')[0].firstChild.data
end_datetime = dateutil.parser.parse(end).astimezone(t)
begin_date = begin_datetime.date()
begin_time = begin_datetime.time()
end_date = end_datetime.date()
end_time = end_datetime.time()
#print("Begin date: {0}, Begin time: {1}, End date: {2}, End time: {3}".format(begin_date, begin_time,end_date, end_time))
# insert sql row using this data
def plot_insolation_yearly(beta, longitude, latitude, continuous,
surface_albedo):
line_colors = ['r', 'g', 'b', 'c', 'm', 'y', 'k']
tf = TimezoneFinder()
fig2, ax2 = plt.subplots(1, figsize=(10, 8))
legend_labels = []
sun = ephem.Sun()
place = ephem.Observer()
place.lon, place.lat = str(longitude), str(latitude)
sun_insol = []
time_series = []
solar_time_series = []
daily_irradiation = []
sun_insol_atmosphere_perDay = []
year = 2013
time_zone = tf.timezone_at(lng=longitude, lat=latitude)
utc_offset = pendulum.from_timestamp(0, time_zone).offset_hours
for count, b in enumerate(beta):
if continuous:
start_time = pendulum.datetime(year, 1, 1, 0, 0, 0, tz=time_zone)
for i in range(1, 365):
time_hours, st, daily_irradiation_value, null, null, daily_irradiation_atmosphere = daily_insolation(
start_time, place, utc_offset, sun, b, surface_albedo)
daily_irradiation.append(daily_irradiation_value)
sun_insol_atmosphere_perDay.append(
daily_irradiation_atmosphere)
start_time = start_time.add(days=1)
progressBar(i, 365, bar_length=20)
# if (i<300 and i >293):
# time_hours, st, daily_irradiation_value ,null,null,daily_irradiation_atmosphere = daily_insolation(start_time,place,utc_offset,sun,b,surface_albedo)
# print(i, daily_irradiation_atmosphere)
savgol_smoothed = signal.savgol_filter(sun_insol_atmosphere_perDay,
101, 5)
ax2.plot(range(1, 365),
daily_irradiation,
c=line_colors[count],
label='Angle: {0}'.format(b))
ax2.plot(range(1, 365),
sun_insol_atmosphere_perDay,
':',
c=line_colors[count])
ax2.plot(range(1, 365),
savgol_smoothed,
'--',
c=line_colors[count])
print("")
print(b, ' degrees (extra total): ',
format_e(integrate.simps(daily_irradiation)), "kJ m-2")
print(b, ' degrees (atm raw total): ',
format_e(integrate.simps(sun_insol_atmosphere_perDay)),
"kJ m-2")
print(b, ' degrees (atm savgol total): ',
format_e(integrate.simps(savgol_smoothed)), "kJ m-2")
# current_label = 'Angle: {0}'.format(b)
# legend_labels.append(current_label)
daily_irradiation = []
sun_insol_atmosphere_perDay = []
if continuous:
ax2.legend() #(labels = legend_labels,loc='upper right')
ax2.set_xlabel("Day Number")
ax2.set_ylabel("Irradiation [kJ/m^2]")
#plt.savefig('graph of sun position per month.png', dpi = 600)
plt.show()
def check_timezone_gps(locations):
tf = TimezoneFinder(in_memory=True)
TimezoneFinder.using_numba()
return tf.timezone_at(lng=locations.longitude, lat=locations.latitude)
def plot_insolation_hourly(beta, longitude, latitude, surface_albedo):
lines = ["-", "--", "-.", ":"]
linecycler = cycle(lines)
month_list = [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
'Nov', 'Dec'
]
tf = TimezoneFinder()
fig2, ax2 = plt.subplots(1, figsize=(10, 8))
legend_labels = []
sun = ephem.Sun()
place = ephem.Observer()
place.lon, place.lat = str(longitude), str(latitude)
sun_insol = []
time_series = []
solar_time_series = []
daily_irradiation = []
year = 2013
day = 29
time_zone = tf.timezone_at(lng=longitude, lat=latitude)
utc_offset = pendulum.from_timestamp(0, time_zone).offset_hours
for b in beta:
for month in range(6, 7):
time = pendulum.datetime(year, month, day, 0, 0, 0, tz=time_zone)
place.date = time.in_tz('UTC')
time_hours, st, daily_irradiation_value, sun_insol, sun_insol_atmosphere, daily_irradiation_atmosphere = daily_insolation(
time, place, utc_offset, sun, b, surface_albedo)
top = max(sun_insol)
sun_insol = [x / top for x in sun_insol]
ax2.plot(time_hours, sun_insol, next(linecycler))
# ax2.plot(time_hours,R_b_collector[0],next(linecycler))
# ax2.plot(time_hours,R_b_collector[1],next(linecycler))
# time = pendulum.datetime(year,month,3,0,0,0,tz=time_zone)
# place.date = time.in_tz('UTC')
# time_hours, st, daily_irradiation_value ,sun_insol,sun_insol_atmosphere,daily_irradiation_atmosphere = daily_insolation(time,place,utc_offset,sun,b,surface_albedo)
# ax2.plot(time_hours,sun_insol,next(linecycler))
current_label = 'Month: {1}, Angle: {0}'.format(
b, month_list[month - 1])
legend_labels.append(current_label)
top = max(sun_insol)
# minor_ticks = numpy.arange(0, 25, 24)
# ax2.set_xticks(minor_ticks, minor=True)
ax2.grid(which='both')
ax2.legend(labels=legend_labels, loc='upper right')
ax2.set_xlabel("Time [hrs from midnight]")
ax2.set_ylabel("Irradiation [kJ/m^2]")
#plt.savefig('graph of sun position per month.png', dpi = 600)
plt.show()
def timezone_name_from_coordinates(lng: float, lat: float) -> str:
tf = TimezoneFinder()
return tf.timezone_at(lng=lng, lat=lat)
def __normalize(self, session_log):
'''
Normalize and fill missing fields in a session log
:param session_log: climbing session object
:type session_log: dict
:return: normalized session object
:rtype: dict
'''
try:
available_fields = session_log.keys()
location = get_location(session_log['location'])
if not location:
raise Exception(
f"No location found for {session_log['location']}. Current supported locations include: {get_location_names()}")
# Split the style field by commas and turn it into a list instead
# This is because style could be multiple fields ie. indoor bouldering, indoor lead
session_log['style'] = session_log['style'].split(',')
# Compare the counter list with the location's grading scale
# If any counters are missing, add to it and just defult to 0 for all categories
counted_grades = []
for counter in session_log['counter']:
counted_grades.append(counter['grade'])
missing_counters = list(
set(location.grading) - set(counted_grades))
for counter in missing_counters:
default_counter = {'grade': counter, 'flash': 0,
'redpoint': 0, 'repeat': 0, 'attempts': 0}
if location.is_outdoor:
default_counter['onsight'] = 0
session_log['counter'].append(default_counter)
session_log['counter'] = reformat_counter(
session_log['counter'])
# Look at the optional fields and add filler values
if 'climbers' not in available_fields:
session_log['climbers'] = None
if 'injury' not in available_fields:
session_log['injury'] = {'isTrue': False, 'description': None}
elif session_log['injury']['isTrue'] == False and session_log['injury']['description'] == 'Add a description of injury here':
session_log['injury'] = {'isTrue': False, 'description': None}
if 'media' not in available_fields:
session_log['media'] = None
if 'projects' not in available_fields:
session_log['projects'] = None
else:
for climb in session_log['projects']:
if 'notes' not in climb.keys():
climb['notes'] = None
if 'media' not in climb.keys():
climb['media'] = None
session_log['projects'] = reformat_projects(
session_log['projects'])
# Initializing Timezone info
tf = TimezoneFinder()
location = get_location(session_log['location'])
location_tz = pytz.timezone(tf.timezone_at(
lng=location.lon, lat=location.lat))
# Add time zone to start and end times
local_start = location_tz.normalize(location_tz.localize(datetime.datetime.combine(
session_log['date'], common.str_to_time(session_log['time']['start']).time())))
local_end = location_tz.normalize(location_tz.localize(datetime.datetime.combine(
session_log['date'], common.str_to_time(session_log['time']['end']).time())))
# Convert to UTC
session_log['date'] = datetime.datetime.combine(
session_log['date'], common.str_to_time(session_log['time']['start']).time())
session_log['time']['start'] = local_start
session_log['time']['end'] = local_end
return session_log
except Exception as ex:
raise ex
def get_tz(lat: float, lng: float) -> str:
""" Calculates timezone from coordinates """
tf = TimezoneFinder()
tz = tf.timezone_at(lng=lng, lat=lat)
return tz
def getTimezone(self):
tf = TimezoneFinder(in_memory=True)
return tf.timezone_at(lng=self.longitude,
lat=self.latitude) # America/Toronto
from timezonefinder import TimezoneFinder
TimezoneFinder.using_numba() # this is a static method returning True or False
tf = TimezoneFinder()
# or
tf = TimezoneFinder(in_memory=True)
longitude, latitude = 13.358, 52.5061
tf.timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Berlin'
tf.certain_timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Berlin'
longitude = 12.773955
latitude = 55.578595
tf.closest_timezone_at(lng=longitude, lat=latitude) # returns 'Europe/Copenhagen'
longitude = 42.1052479
latitude = -16.622686
tf.closest_timezone_at(lng=longitude, lat=latitude, delta_degree=2, exact_computation=True, return_distances=True,
force_evaluation=True)
tf.get_geometry(tz_name='Africa/Addis_Ababa', coords_as_pairs=True)
tf.get_geometry(tz_id=400, use_id=True)
# To maximize the chances of getting a result in a Django view it might look like:
def find_timezone(request, lat, lng):
lat = float(lat)
lng = float(lng)