def get_evts(bot, timezone, type=None):
result = []
for evt in weekly_events:
if type is not None and evt['type'] != type:
continue
evt_begin = evt['begin'].split(':')
dt_evt_begin = DateUtil.get_dt_now(bot.tz_str).replace(
hour=int(evt_begin[0]),
minute=int(evt_begin[1]),
second=0,
microsecond=0
)
while dt_evt_begin.isoweekday() != int(evt['weekday']):
dt_evt_begin += timedelta(days=1)
dt_evt_begin = dt_evt_begin.replace(tzinfo=None)
dt_evt_begin = timezone.localize(dt_evt_begin, is_dst=False)
evt_end = evt['end'].split(':')
dt_evt_end = DateUtil.get_dt_now(bot.tz_str).replace(
hour=int(evt_end[0]),
minute=int(evt_end[1]),
second=0,
microsecond=0
)
while dt_evt_end.isoweekday() != int(evt['weekday']):
dt_evt_end += timedelta(days=1)
dt_evt_end = dt_evt_end.replace(tzinfo=None)
dt_evt_end = timezone.localize(dt_evt_end, is_dst=False)
evt['dt_begin'] = dt_evt_begin
evt['dt_end'] = dt_evt_end
result.append(evt)
result.sort(key=lambda x: x['dt_begin'])
return result
def format_request(self, date_to, date_from, time_zone, sale_statuses):
print date_to.get(), date_from.get(), time_zone.get(
), sale_statuses.get()
# Update all sales
if sale_statuses.get() == "":
status = ""
print "yeap"
fmt = "%Y-%m-%d %H:%M:%S"
utc = pytz.utc
utc.zone
try:
timezone = timezone(time_zone.get())
print "timezone shii worked %s" % (timezone)
except:
print time_zone.get()
print "time zone given is the wrong format"
return False
if date_from == "":
date_from = date_to
# Changes date and time entered to a datetime object
dateToFormat = datetime.strptime(date_to, "%Y-%m-%d %H:%M:%S")
dateFromFormat = datetime.strptime(date_from, "%Y-%m-%d %H:%M:%S")
# Localize the datetime to the timezone specified
dateToDateTime = timezone.localize(
datetime(dateToFormat.year, dateToFormat.month, dateToFormat.day,
dateToFormat.hour, dateToFormat.minute,
dateToFormat.second))
dateFromDateTime = timezone.localize(
datetime(dateFromFormat.year, dateFromFormat.month,
dateFromFormat.day, dateFromFormat.hour,
dateFromFormat.minute, dateFromFormat.second))
# Convert the datetime to UTC time
self.dateToUTC = dateToDateTime.astimezone(utc)
self.dateFromUTC = dateFromDateTime.astimezone(utc)
# String format of the UTC time to help match with datetime format in API responses
self.strdateToUTC = dateToUTC.strftime(fmt)
self.strdateFromUTC = dateFromUTC.strftime(fmt)
print strdateToUTC, strdateFromUTC
saleResponse = register_sales(status)
# Check how many pages the request has
if sale_statuses.get() == "":
check_pages(saleResponse)
return False
def get_file_metadata(file_location):
return {
'creation_datetime':
timezone.localize(
datetime.fromtimestamp(os.path.getctime(file_location))),
'modified_datetime':
timezone.localize(
datetime.fromtimestamp(os.path.getmtime(file_location))),
'file_size_bytes':
os.path.getsize(file_location),
}
def get_current_day(zone='UTC', add_hr=0):
timezone = pytz.timezone(zone)
dt = timezone.localize(datetime.now())
format = "%Y-%m-%d 00:00:00"
ret_day = datetime.strptime(dt.strftime(format),
format) + timedelta(hours=int(add_hr))
return ret_day
def fmt_timezone():
"""
Return current time with format
"""
timezone = get_timezone()
loc_dt = timezone.localize(datetime.utcnow())
return loc_dt.strftime('%b %d, %Y %H:%M:%S')
def check_incoming_transactions(user_id, n=0):
user = User.query.filter_by(id=user_id).first()
if user.is_authenticated:
bundles = user.get_bundles(n)
n = len(bundles)
#Finds the amount of transactions in the database related
#to the current user and compares it to the newly retrieved
#bundle length. If equal, wait 120 seconds, try again. If
#not equal, new transactions are added to db, then wait 120s.
transaction_count = db.session.query(
User.transactions).filter_by(id=user_id).count()
print("Number of Transactions is: " + str(transaction_count))
print("N is equal to: " + str(n))
if n == transaction_count:
print("NO NEW TRANSACTIONS")
print(timezone.localize(datetime.now()) + timedelta(seconds=120))
check_incoming_transactions.apply_async(
(user_id, n),
eta=timezone.localize(datetime.now()) + timedelta(seconds=120))
else:
print("NEW TRANSACTION INCOMING")
new_messages = {}
for message in bundles:
tx = message[0]
print(tx.address)
#user_identifier = TryteString.decode(tx.signature_message_fragment)
receiving_address = tx.address
payment_amount = int(tx.value)
timestamp = tx.timestamp
incomingTransaction = Transaction(
transaction_id=str(uuid.uuid4()),
user_identifier=user.identifier,
payment_amount=payment_amount,
payment_address=receiving_address,
timestamp=timestamp)
db.session.add(incomingTransaction)
db.session.commit()
check_incoming_transactions.apply_async(
(user_id, n),
eta=timezone.localize(datetime.now()) + timedelta(seconds=120))
else:
return False
def test_1_supermoon(self):
import pytz
timezone = pytz.timezone("UTC")
apogees, perigees = apsis(2049)
dt = datetime.datetime(2049, 8, 13, 9, 20)
dt_aware = timezone.localize(dt)
result = apsisconincidence(apogees, perigees, dt_aware)
self.assertFalse(result['within 24 hours']['apogee'])
self.assertTrue(result['within 24 hours']['perigee'])
def _make_aware(value, timezone):
"""
Makes a naive datetime.datetime in a given time zone aware.
"""
if hasattr(timezone, 'localize'):
# available for pytz time zones
return timezone.localize(value, is_dst=None)
else:
# may be wrong around DST changes
return value.replace(tzinfo=timezone)
def _make_aware(value, timezone):
"""
Makes a naive datetime.datetime in a given time zone aware.
"""
if hasattr(timezone, 'localize'):
# available for pytz time zones
return timezone.localize(value, is_dst=None)
else:
# may be wrong around DST changes
return value.replace(tzinfo=timezone)
def update_balance(user_id):
user = User.query.filter_by(id=user_id).first()
if user.is_authenticated:
user.balance = user.get_balance()
print("Users balance is " + str(user.balance))
db.session.commit()
update_balance.apply_async(
(user_id, ),
eta=timezone.localize(datetime.now()) + timedelta(seconds=120))
else:
return False
def execute_agreement(user_id, client_id):
payment_agreement = PaymentAgreement.query.filter_by(
user_id=user_id, client_id=client_id).first()
transaction = payment_agreement.send_payment()
if type(transaction) is Transaction:
return execute_agreement.apply_async(
(user_id, client_id),
eta=timezone.localize(datetime.now()) +
timedelta(seconds=payment_agreement.payment_time))
else:
print("Transaction was not successful.")
payment_agreement.is_active = 0
db.session.commit()
return False
def fromHex(self, hex, timezone=utc):
if len(hex) == 128:
self.date = datetime.datetime(2000+int(hex[0:2], 16), int(hex[2:4], 16), int(hex[4:6], 16), int(hex[6:8], 16), int(hex[8:10], 16), int(hex[10:12], 16))
self.trackpointCount = int(Utilities.swap(hex[12:16]), 16)
self.duration = datetime.timedelta(seconds=int(Utilities.swap(hex[16:24]), 16)/10)
self.distance = int(Utilities.swap(hex[24:32]), 16)
self.lapCount = int(Utilities.swap(hex[32:36]), 16)
self.pointer = hex[36:40]
self.calories = int(Utilities.swap(hex[48:52]), 16)
self.topspeed = int(Utilities.swap(hex[56:64]), 16)/100
self.climb = int(Utilities.swap(hex[68:72]), 16)
# localize date and then convert to UTC
self.date = timezone.localize(self.date).astimezone(utc)
return self
else:
raise GB500ParseException(self.__class__.__name__, len(hex), 128)
def fromHex(self, idx, hex, timezone=utc, units=""):
self.index = idx
self.date = datetime.datetime(2000+int(hex[0:2], 16), int(hex[2:4], 16), int(hex[4:6], 16), int(hex[6:8], 16), int(hex[8:10], 16), int(hex[10:12], 16))
self.trackpointCount = int(Utilities.swap(hex[12:16]), 16)
self.duration = datetime.timedelta(seconds=int(Utilities.swap(hex[16:24]), 16)/10)
self.distance = float(int(Utilities.swap(hex[24:32]), 16))
self.lapCount = int(hex[32:36], 16)
self.pointer = hex[36:40]
# localize date
self.date = timezone.localize(self.date)
# todo support for imperial units
if units == "imperial":
self.distance = round(self.distance * 0.000621371, 1)
else:
self.distance = round(self.distance * 0.001, 1)
return self
def timezone_example():
from datetime import datetime
import pytz
d = datetime.now()
timezone = pytz.timezone("Australia/Sydney")
date_timezone_aware = timezone.localize(d)
print(
f"The Time is {date_timezone_aware} where the TZ is {date_timezone_aware.tzinfo}"
)
#pytz
# https://www.journaldev.com/23370/python-pytz Thanks !
# interesting info on the country / city combos : https://www.iso.org/iso-3166-country-codes.html
print('all_timezones =', pytz.all_timezones, '\n')
print('country_names =')
for key, val in pytz.country_names.items():
print(key, '=', val, end=',')
print('\n')
print('IN full name =', pytz.country_names['IN'])
def schedule_to_service_calendar(sched, agency_id):
timezone = timezone_from_agency(sched, agency_id)
day_start, day_end = day_bounds_from_sched(sched)
startdate, enddate = [ datetime.datetime( *parse_date(x) ) for x in sched.GetDateRange() ]
cal = ServiceCalendar()
for currdate in iter_dates(startdate, enddate):
local_dt = timezone.localize(currdate)
service_ids = [x.encode("ascii") for x in get_service_ids( sched, currdate )]
this_day_begins = timezone.normalize( local_dt + timedelta(seconds=day_start) )
this_day_ends = timezone.normalize( local_dt + timedelta(seconds=day_end) )
cal.add_period( TimeHelpers.datetime_to_unix(this_day_begins), TimeHelpers.datetime_to_unix(this_day_ends), service_ids )
return cal
def convertDateToGoogleStr(timezone, d):
dateStr = timezone.normalize(timezone.localize(d)).astimezone(tz.tzutc()).isoformat('T')
return dateStr
# Set times
start_year = 2019
start_month = month
start_day = 1
end_year = 2019
end_month = month
#end_day = monthrange(end_year, end_month)[1]
end_day = 1
# set start and end date
start = datetime.datetime(start_year, start_month, start_day, hour=0)
end = datetime.datetime(end_year, end_month, end_day, hour=23)
timezone = pytz.timezone("utc")
start = timezone.localize(start)
end = timezone.localize(end)
# Load data
# Data from "urbanova_mapping_1.33km.py"
name = base_dir + '1p33_' + start.strftime("%Y%m%d") + '_' + end.strftime(
"%Y%m%d") #+'_PST'
def load_obj(name):
with open(name + '.pkl', 'rb') as f:
return pickle.load(f)
airpact = load_obj(name)
def getcurr_datetime(zone='UTC', add_hr=0):
timezone = pytz.timezone(zone)
dt = timezone.localize(datetime.now())
format = "%Y-%m-%d %H:%M:%S"
return datetime.strptime(dt.strftime(format),
format) + timedelta(hours=int(add_hr))
def test_normal_datetime_timezone(self, value, timezone, expected):
result = typepy.DateTime(value,
strict_level=StrictLevel.MIN,
timezone=timezone).convert()
assert result == timezone.localize(expected)
def getcurr_datetime_String(zone='UTC', format="%Y-%m-%dT%H:%M:%SZ"):
timezone = pytz.timezone(zone)
dt = timezone.localize(datetime.now())
return dt.strftime(format)
def pre_process_dataset(cells_df, same_position_base_stations, dataset_basepath, label, \
time_period_in_minutes, output_basepath, ranges, aggregation_type, put_zeroes):
traffic_volume_output_filepath = output_basepath + "/traffic_load.dat"
print "> Writing file %s" % traffic_volume_output_filepath
if not os.path.exists(output_basepath):
os.makedirs(output_basepath)
files_list = os.listdir(dataset_basepath)
files_list.sort()
unique_base_stations = [
cell_id for cell_id in cells_df.index
if not cell_id in same_position_base_stations
]
all_cells = [
cell_id
for same_position_cells in same_position_base_stations.values()
for cell_id in same_position_cells
] + unique_base_stations
'''parser = lambda x: timezone('UTC')\
.localize(datetime.datetime.utcfromtimestamp(int(x)))\
.astimezone(timezone('CET')).strftime("%Y-%m-%d %H:%M:%S")'''
first = True
for filename in files_list:
if not filename.startswith("TCPSessCourtParisLyon_"):
continue
date_format = filename.split(
"_") #format is TCPSessCourtParisLyon_300_2016_09_nidt
traffic_volume_filepath = dataset_basepath + '/' + filename
names = ['datetime', 'cell_id', 'category', 'uplink', 'downlink']
traffic_df = pd.read_csv(
traffic_volume_filepath, sep=';', header=None,
names=names) #, parse_dates=[0], date_parser=parser)
#print "Number of lines in %s: %d" %(filename, len(traffic_df))
#traffic_df = traffic_df[traffic_df.category.isin(traffic_kind)] #filtering by category
#print "Number of lines in %s after filtering to categories %s: %d" %(filename, str(traffic_kind), len(traffic_df))
# filter to relevant cells
traffic_df = traffic_df[traffic_df['cell_id'].isin(all_cells)]
print "Number of lines in %s after filtering to selected cells: %d" % (
filename, len(traffic_df))
traffic_df["datetime"] = pd.to_datetime(
traffic_df.datetime,
unit='s').apply(lambda x: x.tz_localize('UTC'))
traffic_df = traffic_df.groupby(['datetime', 'cell_id',
'category']).sum()
traffic_df = traffic_df.reset_index()
#bad date --->>>>>traffic_df["datetime"] = pd.to_datetime(traffic_df["datetime"])
time_period_in_minutes = str(time_period_in_minutes)
print "Considering sum of uplink and downlink for selected service categories..."
if aggregation_type == 'uplink':
traffic_df['traffic_load'] = traffic_df['uplink']
elif aggregation_type == 'downlink':
traffic_df['traffic_load'] = traffic_df['downlink']
else:
traffic_df[
'traffic_load'] = traffic_df['uplink'] + traffic_df['downlink']
#traffic_df = traffic_df[(traffic_df.datetime >= ranges[0] + " 00:00:00") & (traffic_df.datetime <= ranges[1] + " 23:59:59")]
if put_zeroes:
traffic_df = traffic_df[[
'datetime', 'cell_id', 'category', 'traffic_load'
]]
traffic_df = traffic_df.set_index("datetime").groupby(
["cell_id",
"category"]).resample(time_period_in_minutes + 'Min').sum()
traffic_df = traffic_df.reset_index()
# get communication data (sms+call french and non-french)
year = int(date_format[2])
month = int(date_format[3])
day = int(date_format[4])
next_year = int(date_format[5])
next_month = int(date_format[6])
next_day = int(date_format[7])
timezone = pytz.timezone("Europe/Paris")
date_from = datetime.datetime(year, month, day, 0, 0, 0)
date_from = timezone.localize(date_from)
date_to = datetime.datetime(next_year, next_month, next_day, 0, 0,
0)
date_to = timezone.localize(date_to)
timezone = pytz.timezone("UTC")
date_from = date_from.astimezone(timezone)
date_to = date_to.astimezone(timezone)
num_days = (date_to - date_from).days + 1
num_periods = num_days * round(
24.0 * 60.0 / int(time_period_in_minutes))
print "Checking daylight saving change"
day_light_savings_change_positive = (next_month == 10
and next_day == 31
and month == 10 and day == 1)
day_light_savings_change_negative = (next_month == 3
and next_day == 31
and month == 3 and day == 1)
if day_light_savings_change_positive:
old_num_periods = num_periods
num_periods += 1 * 60.0 / int(time_period_in_minutes)
print "Positive daylight saving change detected. Adding %d slots to num_periods: %d" % (
old_num_periods - num_periods, num_periods)
elif day_light_savings_change_negative:
old_num_periods = num_periods
num_periods -= 1 * 60.0 / int(time_period_in_minutes)
print "Negative daylight saving change detected. Removing %d slots to num_periods: %d" % (
old_num_periods - num_periods, num_periods)
else:
print "No daylight saving change detected"
hour_range = pd.date_range(date_from,
periods=num_periods,
freq=str(time_period_in_minutes) +
'Min',
tz="UTC")
print "There are %d categories in the dataset..." % (
len(CATEGORIES))
print str(CATEGORIES)
index = [[d, cell, c] for cell in all_cells for d in hour_range
for c in CATEGORIES]
# this df will be just an index
temp_df = pd.DataFrame(index)
temp_df.columns = ['datetime', 'cell_id', 'category']
temp_df = temp_df.set_index(['datetime', 'cell_id', 'category'])
traffic_df = traffic_df.set_index(
["datetime", "cell_id", 'category'])
traffic_df = traffic_df.reindex_axis(temp_df.index).fillna(0)
traffic_df = traffic_df.reset_index()
else:
traffic_df = traffic_df.set_index("datetime").groupby(
["cell_id",
'category']).resample(time_period_in_minutes + 'Min',
how='sum',
base=0)
traffic_df = traffic_df.reset_index()
traffic_df = traffic_df[[
'datetime', 'cell_id', 'category', 'traffic_load'
]]
traffic_df = traffic_df[np.isfinite(traffic_df['traffic_load'])]
for new_id in same_position_base_stations:
subset_df = traffic_df[traffic_df["cell_id"].isin(
same_position_base_stations[new_id])]
subset_df = subset_df.groupby(["datetime", 'category']).sum()
subset_df = subset_df.reset_index()
traffic_df = traffic_df[~traffic_df["cell_id"].
isin(same_position_base_stations[new_id])]
subset_df["cell_id"] = new_id
traffic_df = traffic_df.append(subset_df, ignore_index=True)
traffic_df["datetime"] = traffic_df["datetime"].apply(
lambda x: x.tz_convert('CET'))
traffic_df['#name_of_the_day'] = traffic_df['datetime'].apply(
lambda x: x.strftime('%A'))
traffic_df['date'] = traffic_df['datetime'].apply(
lambda x: x.strftime('%Y-%m-%d'))
traffic_df['time'] = traffic_df['datetime'].apply(
lambda x: x.strftime('%H:%M:%S'))
traffic_df['aggregation'] = label
traffic_df = pd.merge(traffic_df,
cells_df,
left_on='cell_id',
right_index=True)
traffic_df = traffic_df.rename(columns={'X': 'lon', 'Y': 'lat'})
traffic_df = traffic_df[[
"#name_of_the_day", "date", "time", "cell_id", "lon", "lat",
"aggregation", 'category', "traffic_load"
]]
traffic_df = traffic_df.sort_values(by=["date", "time"])
#print traffic_df.head()
grouped_traffic_df = traffic_df.groupby([
"#name_of_the_day", "date", "time", "cell_id", "lon", "lat",
"aggregation", 'category'
])
#size = grouped_traffic_df.size()
#print "Should be not empty only with positive daylight traffic change..."
#print size[size > 1].head()
#print size[size > 1].tail()
traffic_df = grouped_traffic_df.sum()
traffic_df = traffic_df.reset_index()
traffic_df = traffic_df[[
"#name_of_the_day", "date", "time", "cell_id", "lon", "lat",
"aggregation", 'category', "traffic_load"
]]
traffic_df = traffic_df.sort_values(by=['date', 'time', 'cell_id'])
# final_df[['traffic_load']] = final_df[['traffic_load']].astype(int)
if first:
first = False
traffic_df.to_csv(traffic_volume_output_filepath,
sep=" ",
index=False)
else:
traffic_df.to_csv(traffic_volume_output_filepath,
sep=" ",
mode="a",
header=False,
index=False)
def get_TodayStr(zone='UTC'):
timezone = pytz.timezone(zone)
dt = timezone.localize(datetime.now())
format = "%Y-%m-%d %H:%M:%S"
return datetime.strptime(dt.strftime(format), format)
return tody.strftime('%Y-%m-%d 00:00')
def set_date():
date = datetime.now()
timezone = pytz.timezone("Asia/Kolkata")
d_aware = timezone.localize(date)
date_format = "%d-%b-%Y %H:%M:%S"
return date, date_format
async def reminder(self, ctx, *args):
'''Set a reminder! (format: oki.reminder <w>d <x>h <y>m <z>s <message>)'''
member = ctx.author
day = 0
hour = 0
mins = 0
sec = 0
msg = "default"
count = 0
timezone = pytz.timezone("America/Los_Angeles")
present_time = datetime.now()
pp_time = timezone.localize(present_time)
p_time = pp_time.strftime("%b %d, %I:%M:%S %Z")
print("present time at LV is " + p_time)
# oki.reminder 1d 3h 3m 2s WOOT
dCount = 0
hCount = 0
mCount = 0
sCount = 0
while args[count][0].isnumeric() and args[count][-1].isalpha(
) and count < 4:
if args[count][-1] == 'd':
dCount += 1
if dCount < 2:
day = int(args[count][:-1])
else:
break
elif args[count][-1] == 'h':
hCount += 1
if hCount < 2:
hour = int(arg[count][:-1])
else:
break
elif args[count][-1] == 'm':
mCount += 1
if mCount < 2:
mins = int(args[count][:-1])
else:
break
elif args[count][-1] == 's':
sCount += 1
if sCount < 2:
sec = int(args[count][:-1])
else:
break
print(args[count][-1])
print(args[count][:-1])
print(count)
count += 1
msg = ' '.join(args[count:])
await ctx.send("days: " + str(day) + ", hours: " + str(hour) +
", minutes: " + str(mins) + ", seconds: " + str(sec))
update_time = datetime.now() + timedelta(
days=day, hours=hour, minutes=mins, seconds=sec)
u_time = update_time.strftime("%b %d, %I:%M:%S")
print("updated time at LV is " + u_time)
while u_time >= p_time:
present_time = datetime.now()
pp_time = timezone.localize(present_time)
p_time = pp_time.strftime("%b %d, %I:%M:%S")
# print("this is current present time: " +
# p_time + ", reminder: " + u_time)
await asyncio.sleep(1)
await member.send(msg)
try:
start_date = date(*map(int, sys.argv[2].split('-')))
except:
print 'Scanning service calendar to find the month with maximum service.'
print 'NOTE that this is not necessarily accurate and you can end up with sparse service in the chosen period.'
start_date = db.find_max_service()
print 'calendar start date is %s' % start_date
timezones = db.agency_timezones()
if len(db.agency_timezones()) > 1:
print 'Currently we only support one timezone being active, selected: ' + timezones[
0]
print 'using timezone ' + timezones[0]
timezone = timezone(timezones[0])
start_time = timezone.localize(
datetime.datetime.combine(start_date, datetime.time.min))
#Check whether DST is active on the serviceday, that means AFTER 3am, hence the +1 day.
dst_active = start_time.timetuple().tm_isdst
if dst_active == 1:
print 'DST active on start_time, adding one hour to start_time'
calendar_start_time = time.mktime(
(start_time + timedelta(hours=dst_active)).timetuple())
print 'epoch time at which calendar starts: %d' % calendar_start_time
sids = db.service_ids()
print '%d distinct service IDs' % len(sids)
bitmask_for_sid = {}
dst_mask = 0
for sid in sids:
bitmask_for_sid[sid] = 0
def convert_time_to_balanced_time(time=None, zipcode=10010, pretty_print=False):
#zipcodes to lat/long to astral's location
search = SearchEngine(simple_zipcode=True) # set simple_zipcode=False to use rich info database
zipcode_obj = search.by_zipcode(zipcode)
#the below won't work outside the US, need to reconcile uszipcode's timezone with atral's timezone
location = astral.Location(('name', 'region', zipcode_obj.lat, zipcode_obj.lng, "US/"+zipcode_obj.timezone, 0))
if time is None:
now = datetime.now()
else:
now = time
timezone = pytz.timezone(location.timezone)
time = timezone.localize(now)
#print(time)
beginning_of_today = datetime(time.year, time.month, time.day)
sun = location.sun(date=beginning_of_today, local=True)
#print(sun)
#print()
beginning_of_yesterday = datetime(time.year, time.month, time.day) - timedelta(days=1)
sun_yesterday = location.sun(date=beginning_of_yesterday, local=True)
beginning_of_tomorrow = datetime(time.year, time.month, time.day) + timedelta(days=1)
sun_tomorrow = location.sun(date=beginning_of_tomorrow, local=True)
six_am = datetime(time.year, time.month, time.day, 6)
six_pm = datetime(time.year, time.month, time.day, 18)
todays_seconds = sun['sunset'] - sun['sunrise']
#print("todays seconds: "+str(todays_seconds.total_seconds())+" or "+str(todays_seconds)+" hours.")
last_nights_seconds = sun['sunrise'] - sun_yesterday['sunset']
#print("last night's seconds: "+str(last_nights_seconds.total_seconds())+" or "+str(last_nights_seconds)+" hours.")
tonights_seconds = sun_tomorrow['sunrise'] - sun['sunset']
#print("tonight's seconds: "+str(tonights_seconds.total_seconds())+" or "+str(tonights_seconds)+" hours.")
seconds_from_time_to_next_sunrise = sun['sunrise'] - time #use sun, not sun_tomorrow, because pre-dawn is same day
#print("seconds_from_time_to_sunrise"+str(seconds_from_time_to_next_sunrise.total_seconds()))
seconds_from_sunrise_to_time = time - sun['sunrise'] #same-day
#print("seconds_from_sunrise_to_time"+str(seconds_from_sunrise_to_time.total_seconds()))
seconds_from_sunset_until_time = time - sun['sunset'] #same-day, at night after sunset
#print("seconds_from_sunset_to_time"+str(seconds_from_sunset_until_time.total_seconds()))
balanced_seconds = timedelta(seconds=12*60*60)
multiplier_how_much_shorter_today_is = balanced_seconds / todays_seconds
#print("today's shortness multiplier, each second moves at x"+str(multiplier_how_much_shorter_today_is))
multiplier_how_much_longer_tonight_is = (balanced_seconds / tonights_seconds)
#print("tonight's multiplier: , each second moves at x"+str(multiplier_how_much_longer_tonight_is))
multiplier_how_much_longer_last_night_was = (balanced_seconds / last_nights_seconds)
#print("last night's multiplier: , each second moves at x"+str(multiplier_how_much_longer_last_night_was))
if time >= sun['sunrise'] and time <= sun['sunset']:
seconds_to_add_to_six_am = seconds_from_sunrise_to_time.total_seconds()*multiplier_how_much_shorter_today_is
#print("seconds to add to today's 6 AM: "+str(seconds_to_add_to_six_am)+", or "+str(seconds_to_add_to_six_am/60/60)+" hours.")
modified_time = six_am + timedelta(seconds=(seconds_to_add_to_six_am))
elif time < sun['sunrise']:
seconds_to_subtract_from_this_six_am = seconds_from_time_to_next_sunrise.total_seconds()*(multiplier_how_much_longer_last_night_was)
#print("seconds to subtract from this 6 am: "+str(seconds_to_subtract_from_this_six_am)+", or "+str(seconds_to_subtract_from_this_six_am/60/60)+" hours.")
modified_time = six_am - timedelta(seconds=(seconds_to_subtract_from_this_six_am))
elif time > sun['sunset']:
seconds_to_add_to_tonights_six_pm = seconds_from_sunset_until_time.total_seconds()*multiplier_how_much_longer_tonight_is
#print("seconds to add to tonight's 6 PM: "+str(seconds_to_add_to_tonights_six_pm)+", or "+str(seconds_to_add_to_tonights_six_pm/60/60)+" hours.")
modified_time = six_pm + timedelta(seconds=(seconds_to_add_to_tonights_six_pm))
if pretty_print == False:
return modified_time
else:
return modified_time.strftime("%I:%M:%S %p")
# second command line parameter: start date for 32-day calendar
try :
start_date = date( *map(int, sys.argv[2].split('-')) )
except :
print 'Scanning service calendar to find the month with maximum service.'
print 'NOTE that this is not necessarily accurate and you can end up with sparse service in the chosen period.'
start_date = db.find_max_service()
print 'calendar start date is %s' % start_date
timezones = db.agency_timezones()
if len(db.agency_timezones()) > 1:
print 'Currently we only support one timezone being active, selected: '+timezones[0]
print 'using timezone '+timezones[0]
timezone = timezone(timezones[0])
start_time = timezone.localize(datetime.datetime.combine(start_date, datetime.time.min))
#Check whether DST is active on the serviceday, that means AFTER 3am, hence the +1 day.
dst_active = start_time.timetuple().tm_isdst
if dst_active == 1:
print 'DST active on start_time, adding one hour to start_time'
calendar_start_time = time.mktime((start_time+timedelta(hours=dst_active)).timetuple())
print 'epoch time at which calendar starts: %d' % calendar_start_time
sids = db.service_ids()
print '%d distinct service IDs' % len(sids)
bitmask_for_sid = {}
dst_mask = 0
for sid in sids :
bitmask_for_sid[sid] = 0
for day_offset in range(32) :
def to_utc(self, timezone, naive):
return timezone.normalize(timezone.localize(naive)).astimezone(pytz.utc)
