def get_last_period_dates(self, cr, uid, company, date, context=None):
""" return the start date and end date of the last period to display """
# return the first day and last day of the month
if company.timesheet_range == 'month':
start_date = date
end_date = start_date + relativedelta(months=+1)
# return the first and last days of the week
elif company.timesheet_range == 'week':
# get monday of current week
start_date = date + relativedelta(weekday=MO(-1))
# get sunday of current week
end_date = date + relativedelta(weekday=SU(+1))
# return the first and last days of the year
else:
start_date = datetime(date.year, 1, 1)
end_date = datetime(date.year, 12, 31)
return start_date, end_date
def test_no_scheduled_task_for_course(self, mock_timezone):
"""A course scheduled to run for a day that has no task messages the user."""
now = timezone.now()
monday = now.date() + relativedelta(weekday=MO(-1))
mock_timezone.localdate.return_value = monday
user = self.make_user()
enrollment = EnrollmentFactory(
grade_level__school_year__school=user.school,
student__school=user.school)
course = CourseFactory(grade_levels=[enrollment.grade_level])
with self.login(user):
self.get("core:daily")
expected_schedule = {"course": course, "no_scheduled_task": True}
assert self.get_context(
"schedules")[0]["courses"][0] == expected_schedule
def get_open_data(self):
last_month_monday = now() - relativedelta(
weeks=4, weekday=MO(-1), hour=0, minute=0)
next_monday = last_month_monday + relativedelta(weeks=1)
orders = Order.objects.filter(calendar__activity__is_open=True,
created_at__range=(last_month_monday,
next_monday),
status=Order.ORDER_APPROVED_STATUS)
data = defaultdict(list)
for order in orders:
student = order.student
if not Review.objects.filter(activity=order.calendar.activity,
author=student).exists():
data[student.user.email].append(order.calendar.activity)
return data
def get_interval_bounds(date_val, interval):
"""
Returns interval bounds the datetime is in.
"""
day = strip_time(date_val)
if interval == 'day':
begin = day
end = day + relativedelta(days=1)
elif interval == 'week':
begin = day - relativedelta(weekday=MO(-1))
end = begin + datetime.timedelta(days=7)
elif interval == 'month':
begin = strip_time(datetime.datetime(date_val.year, date_val.month, 1, tzinfo=date_val.tzinfo))
end = begin + relativedelta(months=1)
end = end - relativedelta(microseconds=1)
return begin, end
def start_end_date_for_period(self):
"""Return the start and end date for a goal period based on today"""
today = date.today()
start_date=today
end_date=today
if self.period == 'daily':
start_date = today
end_date = start_date
elif self.period == 'weekly':
start_date = today + relativedelta(weekday=MO(-1))
end_date = start_date + timedelta(days=7)
elif self.period == 'monthly':
start_date = today.replace(day=1)
end_date = today + relativedelta(months=1, day=1, days=-1)
elif self.period == 'yearly':
start_date = today.replace(month=1, day=1)
end_date = today.replace(month=12, day=31)
return fields.Datetime.to_string(start_date), fields.Datetime.to_string(end_date)
def cve_count_last_week(self):
now = timezone.now()
sunday = (now + relativedelta(days=-1, weekday=SU(-1))) # Last week's sunday (just before this monday)
sunday = sunday.combine(sunday, datetime.time(0), sunday.tzinfo) # Reset time to midnight
last_monday = sunday + relativedelta(weekday=MO(-1)) # Last week's monday
this_monday = sunday + relativedelta(days=1) # This week's monday
cve_history = HistoryRecord.objects.filter(owner=self.user, sampled_at__date__gte=last_monday,
sampled_at__date__lt=this_monday)\
.values('cve_high_count', 'cve_medium_count', 'cve_low_count')\
.annotate(cve_high=Coalesce(Max('cve_high_count'), 0),
cve_med=Coalesce(Max('cve_medium_count'), 0),
cve_lo=Coalesce(Max('cve_low_count'), 0))\
.values('cve_high', 'cve_med', 'cve_lo')
if cve_history.exists():
cve_history = cve_history.first()
return cve_history['cve_high'], cve_history['cve_med'], cve_history['cve_lo']
else:
return 0, 0, 0
def onchange_start_date(self):
if self.start_date:
if self.duration <= 0:
self.duration = 1
date = datetime.strptime(self.start_date, DEFAULT_SERVER_DATE_FORMAT)
if self.type_time == 'tuan':
start_date = date + relativedelta(weekday=MO(-1))
end_date = start_date + timedelta(days=6 * self.duration)
if start_date != date:
self.start_date = start_date
self.end_date = end_date
print "%s %s" % (start_date, end_date)
elif self.type_time == 'thang':
start_date = date.replace(day=1)
end_date = start_date + relativedelta(months=1 * self.duration, day=1, days=-1)
if start_date != date:
self.start_date = start_date
self.end_date = end_date
print "%s %s" % (start_date, end_date)
def truncate(dt, interval):
''' Returns interval bounds the datetime is in. '''
day = datetime.datetime(dt.year, dt.month, dt.day, tzinfo=dt.tzinfo)
if interval == 'hours':
return datetime.datetime(dt.year,
dt.month,
dt.day,
dt.hour,
tzinfo=dt.tzinfo)
elif interval == 'days':
return day
elif interval == 'weeks':
return day - relativedelta(weekday=MO(-1))
elif interval == 'months':
return datetime.datetime(dt.year, dt.month, 1, tzinfo=dt.tzinfo)
elif interval == 'years':
return datetime.datetime(dt.year, 1, 1, tzinfo=dt.tzinfo)
def create_weekly_report_mc(revision):
from crashmanager.models import Client
from .models import Collection, Repository, Report
from .tasks import aggregate_coverage_data
# Some of our builds (e.g. JS shell) use the HG short revision format
# to submit their coverage while the server provides the full revision.
short_revision = revision[:12]
repository = Repository.objects.get(name="mozilla-central")
client = Client.objects.get_or_create(name="Server")[0]
collections = Collection.objects.filter(
Q(revision=revision) | Q(revision=short_revision)).filter(
repository=repository, coverage__isnull=False)
last_monday = collections.first().created + relativedelta(weekday=MO(-1))
mergedCollection = Collection()
mergedCollection.description = "Weekly Report (Week of %s, %s reports)" % (
last_monday.strftime("%-m/%-d"), collections.count())
mergedCollection.repository = repository
mergedCollection.revision = revision
mergedCollection.branch = "master"
mergedCollection.client = client
mergedCollection.coverage = None
mergedCollection.save()
report = Report()
report.coverage = mergedCollection
report.data_created = last_monday
report.save()
# New set of tools is the combination of all tools involved
tools = []
for collection in collections:
tools.extend(collection.tools.all())
mergedCollection.tools.add(*tools)
ids = list(collections.values_list('id', flat=True))
aggregate_coverage_data.delay(mergedCollection.pk, ids)
def _populate(self, year):
# Public holidays
self[date(year, JAN, 1)] = "Nýársdagur"
self[easter(year) - rd(days=3)] = "Skírdagur"
self[easter(year) + rd(weekday=FR(-1))] = "Föstudagurinn langi"
self[easter(year)] = "Páskadagur"
self[easter(year) + rd(days=1)] = "Annar í páskum"
self[date(year, APR, 19) + rd(weekday=TH(+1))] = "Sumardagurinn fyrsti"
self[date(year, MAY, 1)] = "Verkalýðsdagurinn"
self[easter(year) + rd(days=39)] = "Uppstigningardagur"
self[easter(year) + rd(days=49)] = "Hvítasunnudagur"
self[easter(year) + rd(days=50)] = "Annar í hvítasunnu"
self[date(year, JUN, 17)] = "Þjóðhátíðardagurinn"
# First Monday of August
self[date(year, AUG, 1) +
rd(weekday=MO(+1))] = "Frídagur verslunarmanna"
self[date(year, DEC, 24)] = "Aðfangadagur"
self[date(year, DEC, 25)] = "Jóladagur"
self[date(year, DEC, 26)] = "Annar í jólum"
self[date(year, DEC, 31)] = "Gamlársdagur"
def test_get_day_coursework(self):
today = timezone.now().date()
monday = today + relativedelta(weekday=MO(-1))
enrollment = EnrollmentFactory(
grade_level__school_year__start_date=today - datetime.timedelta(days=30)
)
student = enrollment.student
school_year = enrollment.grade_level.school_year
GradeLevelFactory(school_year=school_year)
course = CourseFactory(grade_level=enrollment.grade_level)
coursework_1 = CourseworkFactory(
student=student, course_task__course=course, completed_date=monday
)
coursework_2 = CourseworkFactory(
student=student, course_task__course=course, completed_date=monday
)
day_coursework = student.get_day_coursework(monday)
self.assertEqual(day_coursework, {course.id: [coursework_1, coursework_2]})
def get_candle_time(time, timeframe):
t = time.replace(second=0, microsecond=0)
if timeframe in [PERIOD_M1, PERIOD_M5, PERIOD_M15, PERIOD_M30]:
minute = t.minute // timeframe * timeframe
return t.replace(minute=minute)
if timeframe in [PERIOD_H1, PERIOD_H4]:
t = t.replace(minute=0)
hourframe = int(timeframe / 60)
hour = t.hour // hourframe * hourframe
return t.replace(hour=hour)
if timeframe in [PERIOD_D1]:
return t.replace(hour=0, minute=0)
if timeframe in [PERIOD_W1]:
monday = time + relativedelta(weekday=MO(-1))
return monday.replace(hour=0, minute=0, second=0, microsecond=0)
if timeframe in [PERIOD_MN1]:
return t.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
raise NotImplementedError
class TestCaseCelebrants(TestCase):
today = date.today()
last_monday = today + relativedelta(weekday=MO(-1))
def setUp(self) -> None:
Celebrant.objects.create(first_name="Jan",
last_name="Nowak",
exam='PA',
pass_date=self.today)
Celebrant.objects.create(first_name="Jan",
last_name="Nowak",
exam='TRIAL',
pass_date=(self.today + timedelta(days=1)))
Celebrant.objects.create(first_name="Ola",
last_name="Nowak",
exam='GO',
pass_date=self.last_monday)
Celebrant.objects.create(first_name="Ola",
last_name="Kowalska",
exam='PA',
pass_date=(self.last_monday -
timedelta(days=1)))
def emailD():
today = date.today()
last_Monday = today + relativedelta(weekday=MO(-1))
monday = last_Monday.strftime("%d%m20%y")
today = today.strftime("%d/%m/%y")
body = "Subject:" + datetime.date.today().strftime(
"%A") + " - " + today + "\n"
inputFile = ".//Parsed/" + monday + "/" + datetime.date.today().strftime(
"%A")
if os.path.isfile(inputFile):
f = open(inputFile, "r")
body += f.read()
# body += "\nTo Stop these emails Link to a google form"
print(body)
# email address in plaintext, password in base64 (Just because I didnt like the idea of storing a password in human readable form, still not good)
gmail_user = ""
b = b''
gmail_password = base64.b64decode(b).decode('utf-8')
sent_from = gmail_user
inputFile = "./send_to"
if os.path.isfile(inputFile):
f = open(inputFile, "r")
to = f.readlines()
try:
server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.ehlo()
server.login(gmail_user, gmail_password)
server.sendmail(sent_from, to, body)
server.close()
print("Email sent!")
except:
print("Something went wrong...")
class BrazilianHolidayCalendar(AbstractHolidayCalendar):
"""
Brazilian Public Holidays Calendar based on rules specified by:
https://www.officeholidays.com/countries/brazil/index.php
"""
rules = [
Holiday("New Years Day", month=1, day=1),
Holiday("Carnival", month=2, day=13,
offset=DateOffset(weekday=MO(3))),
Holiday("Good Friday", month=3, day=30),
Holiday("Tiradentes", month=4, day=21),
Holiday("Labour Day", month=5, day=1),
Holiday("Corpus Christi", month=5, day=31),
Holiday("State Rebellion Day", month=7, day=9),
Holiday("Independence Day", month=9, day=7),
Holiday("Our Lady of Aparecida", month=10, day=12),
Holiday("All Souls' Day", month=11, day=2),
Holiday("Republic Day", month=11, day=15),
Holiday("Black Consciousness Day", month=11, day=20),
Holiday("Christmas", month=12, day=25),
Holiday("New Years Day", month=12, day=31),
]
def getDateQueryCondition(date):
if not date:
return ()
now = datetime.datetime.now()
today = datetime.date.today()
startTime = 0
endTime = 0
if 'thisweek' == date:
#this week monday
startTime = today + relativedelta(weekday=MO(-1))
#next week monday
endTime = today + relativedelta(days=+1, weekday=MO)
#this week SUNDAY
#endTime = today+relativedelta(weekday=SU(+1))
elif 'nextweek' == date:
#next week monday
startTime = today + relativedelta(days=+1, weekday=MO)
#after next week monday
endTime = startTime + relativedelta(days=+1, weekday=MO)
#next week SUNDAY
#endTime = today+relativedelta(days=+7,weekday=SU)
elif 'nextmonth' == date:
thisMonthStart = now.strftime('%Y-%m-1')
tmp = thisMonthStart.split('-')
thisMonthStart = datetime.datetime(int(tmp[0]), int(tmp[1]),
int(tmp[2]))
startTime = thisMonthStart + relativedelta(months=+1)
endTime = thisMonthStart + relativedelta(months=+2)
else:
return ()
startTime = time.mktime(startTime.timetuple())
endTime = time.mktime(endTime.timetuple())
#args = (Q(event_begin_time__gte=startTime)&Q(event_begin_time__lte=endTime))|\
#(Q(event_end_time__gte=startTime)&Q(event_end_time__lte=endTime))#|\
#(Q(event_begin_time__lt=startTime)&Q(event_end_time__lt=endTime))
args = (Q(event_begin_time__lte=startTime)&Q(event_end_time__gte=endTime))|\
(Q(event_begin_time__gte=startTime)&Q(event_begin_time__lte=endTime))|\
(Q(event_end_time__gte=startTime)&Q(event_end_time__lte=endTime))
return args
def hello():
df = pd.read_excel('spending.xlsx', skiprows=1)
budget = 100
grouped = df.groupby("Label")
food = grouped.get_group("food")
luxrary = grouped.get_group("luxury")
luxury_food = grouped.get_group("luxury-food")
pprint(food)
def mean_confidence_interval(data, confidence=0.95):
a = 1.0 * np.array(data)
n = len(a)
m, se = np.mean(a), scipy.stats.sem(a)
h = se * sp.stats.t._ppf((1 + confidence) / 2., n - 1)
return m, m - h, m + h
mean, lower, upper = mean_confidence_interval(food["DEBIT"])
date_remaining = 6 - (datetime.datetime.today().weekday())
today = date.today()
last_monday = today + relativedelta(weekday=MO(-1))
print(last_monday)
this_week_spending = food.loc[food["DATE"] >= str(last_monday)]
budget_remaining = budget - this_week_spending["DEBIT"].sum()
budget_remaining = str(budget_remaining)
result = {"budget_remaining": budget_remaining}
return jsonify(result)
def get_punchcard_data(findings, weeks_between, start_date):
punchcard = list()
ticks = list()
highest_count = 0
tick = 0
week_count = 1
# mon 0, tues 1, wed 2, thurs 3, fri 4, sat 5, sun 6
# sat 0, sun 6, mon 5, tue 4, wed 3, thur 2, fri 1
day_offset = {0: 5, 1: 4, 2: 3, 3: 2, 4: 1, 5: 0, 6: 6}
for x in range(-1, weeks_between):
# week starts the monday before
new_date = start_date + relativedelta(weeks=x, weekday=MO(1))
end_date = new_date + relativedelta(weeks=1)
append_tick = True
days = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0}
for finding in findings:
if new_date.date() < finding.date <= end_date.date():
# [0,0,(20*.02)]
# [week, day, weight]
days[day_offset[finding.date.weekday()]] += 1
if days[day_offset[finding.date.weekday()]] > highest_count:
highest_count = days[day_offset[finding.date.weekday()]]
if sum(days.values()) > 0:
for day, count in days.items():
punchcard.append([tick, day, count])
if append_tick:
ticks.append([tick, new_date.strftime("<span class='small'>%m/%d<br/>%Y</span>")])
append_tick = False
tick += 1
week_count += 1
# adjust the size
ratio = (sqrt(highest_count / pi))
for punch in punchcard:
punch[2] = (sqrt(punch[2] / pi)) / ratio
return punchcard, ticks, highest_count
def replace_days(dictionary):
weekday = dictionary.get("weekday", None)
if weekday:
week_expr = dictionary["weekday"]
week_day = week_expr[:2]
week_int = int(week_expr.split("(")[1].split(")")[0])
if week_day == "MO":
dictionary["weekday"] = MO(week_int)
elif week_day == "TU":
dictionary["weekday"] = TU(week_int)
elif week_day == "WE":
dictionary["weekday"] = WE(week_int)
elif week_day == "TH":
dictionary["weekday"] = TH(week_int)
elif week_day == "FR":
dictionary["weekday"] = FR(week_int)
elif week_day == "SA":
dictionary["weekday"] = SA(week_int)
elif week_day == "SU":
dictionary["weekday"] = SU(week_int)
else:
logger.error("Wrong day code")
return dictionary
def this_weekend(date):
""" Returns a daterange with the start being friday 4pm and the end
being sunday midnight, relative to the given date.
"""
this_morning = datetime(date.year,
date.month,
date.day,
0,
0,
tzinfo=date.tzinfo)
if this_morning.weekday() in (weekdays["SA"], weekdays["SU"]):
weekend_start = this_morning + relativedelta(weekday=FR(-1))
else:
weekend_start = this_morning + relativedelta(weekday=FR(+1))
weekend_end = weekend_start + relativedelta(weekday=MO(1))
weekend_start += timedelta(hours=16)
weekend_end += timedelta(microseconds=-1)
return weekend_start, weekend_end
def get_bounds(dt, interval):
''' Returns interval bounds the datetime is in. '''
day = _to_datetime(_remove_time(dt))
dt = _to_datetime(dt)
if interval == 'minute':
begin = datetime.datetime(dt.year,
dt.month,
dt.day,
dt.hour,
dt.minute,
tzinfo=dt.tzinfo)
end = begin + relativedelta(minutes=1)
elif interval == 'hour':
begin = datetime.datetime(dt.year,
dt.month,
dt.day,
dt.hour,
tzinfo=dt.tzinfo)
end = begin + relativedelta(hours=1)
elif interval == 'day':
begin = day
end = day + relativedelta(days=1)
elif interval == 'week':
begin = day - relativedelta(weekday=MO(-1))
end = begin + datetime.timedelta(days=7)
elif interval == 'month':
begin = datetime.datetime(dt.year, dt.month, 1, tzinfo=dt.tzinfo)
end = begin + relativedelta(months=1)
elif interval == 'year':
begin = datetime.datetime(dt.year, 1, 1, tzinfo=dt.tzinfo)
end = datetime.datetime(dt.year + 1, 1, 1, tzinfo=dt.tzinfo)
else:
raise InvalidInterval('Inverval not supported.')
end = end - relativedelta(microseconds=1)
return begin, end
def get_period_date_ranges(self):
from dateutil.relativedelta import MO, relativedelta
from_date, to_date = getdate(self.filters.from_date), getdate(
self.filters.to_date)
increment = {
"Monthly": 1,
"Quarterly": 3,
"Half-Yearly": 6,
"Yearly": 12
}.get(self.filters.range, 1)
if self.filters.range in ["Monthly", "Quarterly"]:
from_date = from_date.replace(day=1)
elif self.filters.range == "Yearly":
from_date = get_fiscal_year(from_date)[1]
else:
from_date = from_date + relativedelta(from_date, weekday=MO(-1))
self.periodic_daterange = []
for dummy in range(1, 53):
if self.filters.range == "Weekly":
period_end_date = add_days(from_date, 6)
else:
period_end_date = add_to_date(from_date,
months=increment,
days=-1)
if period_end_date > to_date:
period_end_date = to_date
self.periodic_daterange.append(period_end_date)
from_date = add_days(period_end_date, 1)
if period_end_date == to_date:
break
def parse(raw_date):
weekday = {
'monday': MO(-1),
'tuesday': TU(-1),
'wednesday': WE(-1),
'thursday': TH(-1),
'friday': FR(-1),
'saturday': SA(-1),
'sunday': SU(-1),
}
if raw_date == 'today':
date = datetime.now().date()
elif raw_date == 'yesterday':
date = datetime.now().date() - relativedelta(days=1)
elif raw_date in weekday:
date = datetime.now().date() + relativedelta(weekday=weekday[raw_date])
elif re.match('\d{4}-w\d{2}', raw_date) is not None:
fromDate = datetime.strptime(raw_date + '-1', "%Y-W%W-%w").date()
toDate = fromDate + relativedelta(days=7)
return fromDate, toDate
else:
date = datetime.strptime(raw_date, '%Y-%m-%d')
toDate = date + relativedelta(days=1)
return date, toDate
def get_timesheet(self, start_date=None, end_date=None):
if start_date is None and end_date is None:
# default to get this week's timesheet (excl. previous month)
start_date = max(
[TODAY + relativedelta(day=1), TODAY + relativedelta(weekday=MO(-1))]
)
end_date = TODAY + relativedelta(weekday=FR)
r = self.session.post(
self.INPUT_TIME_URL,
data={
"UserContextID": self.user_context_id,
"StaffID": self.staff_id,
"Mode": "Week",
"StartDate": start_date.strftime("%d-%b-%Y"),
"EndDate": end_date.strftime("%d-%b-%Y"),
},
)
customer_options, project_options, task_options = self.get_timecodes()
return Timesheet(
html=r.html,
customer_options=customer_options,
project_options=project_options,
task_options=task_options,
)
days_of_week=(MONDAY, TUESDAY, WEDNESDAY, THURSDAY),
)
USNewYearsDay = Holiday(
'New Years Day',
month=1,
day=1,
# When Jan 1 is a Sunday, US markets observe the subsequent Monday.
# When Jan 1 is a Saturday (as in 2005 and 2011), no holiday is observed.
observance=sunday_to_monday)
USMartinLutherKingJrAfter1998 = Holiday(
'Dr. Martin Luther King Jr. Day',
month=1,
day=1,
# The US markets didn't observe MLK day as a holiday until 1998.
start_date=Timestamp('1998-01-01'),
offset=DateOffset(weekday=MO(3)),
)
USLincolnsBirthDayBefore1954 = Holiday(
'Lincoln'
's Birthday',
month=2,
day=12,
start_date=Timestamp('1874-01-01'),
end_date=Timestamp('1953-12-31'),
observance=sunday_to_monday,
)
USWashingtonsBirthDayBefore1964 = Holiday(
'Washington'
's Birthday',
month=2,
day=22,
def get_monday_of_week(day_to_get_bills):
formatted_day = datetime.strptime(day_to_get_bills, '%Y%m%d').date()
return (formatted_day + relativedelta(weekday=MO(-1))).strftime('%Y%m%d')
def _populate(self, year):
holidays.US._populate(self, year)
self.pop(date(year, 10, 1) + relativedelta(weekday=MO(+2)))
NewYearsHolidayJan2 = Holiday(
"New Year's Holiday (Jan 2)",
month=1,
day=2,
)
NewYearsHolidayJan3 = Holiday(
"New Year's Holiday (Jan 3)",
month=1,
day=3,
)
ComingOfAgeDay = Holiday(
"Coming of Age Day",
month=1,
day=1,
offset=DateOffset(weekday=MO(2)),
)
NationalFoundationDay = Holiday(
"National Foundation Day",
month=2,
day=11,
observance=sunday_to_monday,
)
# The dates on which the vernal/autumnal equinox will be observed
# are announced on the first weekday of February of the previous
# year, so we treat them as ad-hoc holidays, even though they
# occur every year. For more info, see:
# https://en.wikipedia.org/wiki/Public_holidays_in_Japan#cite_note-3
# For the list of equinoxes going back to 2000, see:
def _populate(self, year):
# ACT: Holidays Act 1958
# NSW: Public Holidays Act 2010
# NT: Public Holidays Act 2013
# QLD: Holidays Act 1983
# SA: Holidays Act 1910
# TAS: Statutory Holidays Act 2000
# VIC: Public Holidays Act 1993
# WA: Public and Bank Holidays Act 1972
# TODO do more research on history of Aus holidays
# New Year's Day
name = "New Year's Day"
jan1 = date(year, JAN, 1)
self[jan1] = name
if self.observed and jan1.weekday() in WEEKEND:
self[jan1 + rd(weekday=MO)] = name + " (Observed)"
# Australia Day
jan26 = date(year, JAN, 26)
if year >= 1935:
if self.prov == "NSW" and year < 1946:
name = "Anniversary Day"
else:
name = "Australia Day"
self[jan26] = name
if self.observed and year >= 1946 and jan26.weekday() in WEEKEND:
self[jan26 + rd(weekday=MO)] = name + " (Observed)"
elif year >= 1888 and self.prov != "SA":
name = "Anniversary Day"
self[jan26] = name
# Adelaide Cup
if self.prov == "SA":
name = "Adelaide Cup"
if year >= 2006:
# subject to proclamation ?!?!
self[date(year, MAR, 1) + rd(weekday=MO(+2))] = name
else:
self[date(year, MAR, 1) + rd(weekday=MO(+3))] = name
# Canberra Day
# Info from https://www.timeanddate.com/holidays/australia/canberra-day
# and https://en.wikipedia.org/wiki/Canberra_Day
if self.prov == "ACT" and year >= 1913:
name = "Canberra Day"
if year >= 1913 and year <= 1957:
self[date(year, MAR, 12)] = name
elif year >= 1958 and year <= 2007:
self[date(year, MAR, 1) + rd(weekday=MO(+3))] = name
elif year >= 2008 and year != 2012:
self[date(year, MAR, 1) + rd(weekday=MO(+2))] = name
elif year == 2012:
self[date(year, MAR, 12)] = name
# Easter
self[easter(year) + rd(weekday=FR(-1))] = "Good Friday"
if self.prov in ("ACT", "NSW", "NT", "QLD", "SA", "VIC"):
self[easter(year) + rd(weekday=SA(-1))] = "Easter Saturday"
if self.prov in ("ACT", "NSW", "QLD", "VIC"):
self[easter(year)] = "Easter Sunday"
self[easter(year) + rd(weekday=MO)] = "Easter Monday"
# Anzac Day
if year > 1920:
name = "Anzac Day"
apr25 = date(year, APR, 25)
self[apr25] = name
if self.observed:
if apr25.weekday() == SAT and self.prov in ("WA", "NT"):
self[apr25 + rd(weekday=MO)] = name + " (Observed)"
elif apr25.weekday() == SUN and self.prov in (
"ACT",
"QLD",
"SA",
"WA",
"NT",
):
self[apr25 + rd(weekday=MO)] = name + " (Observed)"
# Western Australia Day
if self.prov == "WA" and year > 1832:
if year >= 2015:
name = "Western Australia Day"
else:
name = "Foundation Day"
self[date(year, JUN, 1) + rd(weekday=MO(+1))] = name
# Sovereign's Birthday
if year >= 1952:
name = "Queen's Birthday"
elif year > 1901:
name = "King's Birthday"
if year >= 1936:
name = "Queen's Birthday"
if self.prov == "QLD":
if year == 2012:
self[date(year, JUN, 11)] = "Queen's Diamond Jubilee"
if year < 2016 and year != 2012:
dt = date(year, JUN, 1) + rd(weekday=MO(+2))
self[dt] = name
else:
dt = date(year, OCT, 1) + rd(weekday=MO)
self[dt] = name
elif self.prov == "WA":
# by proclamation ?!?!
self[date(year, OCT, 1) + rd(weekday=MO(-1))] = name
elif self.prov in ("NSW", "VIC", "ACT", "SA", "NT", "TAS"):
dt = date(year, JUN, 1) + rd(weekday=MO(+2))
self[dt] = name
elif year > 1911:
self[date(year, JUN, 3)] = name # George V
elif year > 1901:
self[date(year, NOV, 9)] = name # Edward VII
# Picnic Day
if self.prov == "NT":
name = "Picnic Day"
self[date(year, AUG, 1) + rd(weekday=MO)] = name
# Bank Holiday
if self.prov == "NSW":
if year >= 1912:
name = "Bank Holiday"
self[date(year, 8, 1) + rd(weekday=MO)] = name
# Labour Day
name = "Labour Day"
if self.prov in ("NSW", "ACT", "SA"):
self[date(year, OCT, 1) + rd(weekday=MO)] = name
elif self.prov == "WA":
self[date(year, MAR, 1) + rd(weekday=MO)] = name
elif self.prov == "VIC":
self[date(year, MAR, 1) + rd(weekday=MO(+2))] = name
elif self.prov == "QLD":
if 2013 <= year <= 2015:
self[date(year, OCT, 1) + rd(weekday=MO)] = name
else:
self[date(year, MAY, 1) + rd(weekday=MO)] = name
elif self.prov == "NT":
name = "May Day"
self[date(year, MAY, 1) + rd(weekday=MO)] = name
elif self.prov == "TAS":
name = "Eight Hours Day"
self[date(year, MAR, 1) + rd(weekday=MO(+2))] = name
# Family & Community Day
if self.prov == "ACT":
name = "Family & Community Day"
if 2007 <= year <= 2009:
self[date(year, NOV, 1) + rd(weekday=TU)] = name
elif year == 2010:
# first Monday of the September/October school holidays
# moved to the second Monday if this falls on Labour day
# TODO need a formula for the ACT school holidays then
# http://www.cmd.act.gov.au/communication/holidays
self[date(year, SEP, 26)] = name
elif year == 2011:
self[date(year, OCT, 10)] = name
elif year == 2012:
self[date(year, OCT, 8)] = name
elif year == 2013:
self[date(year, SEP, 30)] = name
elif year == 2014:
self[date(year, SEP, 29)] = name
elif year == 2015:
self[date(year, SEP, 28)] = name
elif year == 2016:
self[date(year, SEP, 26)] = name
elif year == 2017:
self[date(year, SEP, 25)] = name
# Reconciliation Day
if self.prov == "ACT":
name = "Reconciliation Day"
if year >= 2018:
self[date(year, 5, 27) + rd(weekday=MO)] = name
if self.prov == "VIC":
# Grand Final Day
if year == 2020:
# Rescheduled due to COVID-19
self[date(year, OCT, 23)] = "Grand Final Day"
elif year == 2021:
# Rescheduled due to COVID-19
self[date(year, SEP, 24)] = "Grand Final Day"
elif year >= 2015:
self[date(year, SEP, 24) + rd(weekday=FR)] = "Grand Final Day"
# Melbourne Cup
self[date(year, NOV, 1) + rd(weekday=TU)] = "Melbourne Cup"
# The Royal Queensland Show (Ekka)
# The Show starts on the first Friday of August - providing this is
# not prior to the 5th - in which case it will begin on the second
# Friday. The Wednesday during the show is a public holiday.
if self.prov == "QLD":
name = "The Royal Queensland Show"
if year == 2020:
self[date(year, AUG, 14)] = name
if year == 2021:
self[date(year, OCT, 29)] = name
else:
self[date(year, AUG, 5) + rd(weekday=FR) +
rd(weekday=WE)] = name
# Christmas Day
name = "Christmas Day"
dec25 = date(year, DEC, 25)
self[dec25] = name
if self.observed and dec25.weekday() in WEEKEND:
self[date(year, DEC, 27)] = name + " (Observed)"
# Boxing Day
if self.prov == "SA":
name = "Proclamation Day"
else:
name = "Boxing Day"
dec26 = date(year, DEC, 26)
self[dec26] = name
if self.observed and dec26.weekday() in WEEKEND:
self[date(year, DEC, 28)] = name + " (Observed)"
print("Login Successful")
else:
print("Login Failed")
sys.exit(0)
else:
print('there was an error logging in')
print("Logged in", r.status_code)
headers = {'Authtoken': token, 'Content-type_of_backup': 'application/xml'}
type_of_backup = 'latest_daily_backup'
backup_start_hours = dt.datetime.strptime('100000', '%H%M%S').time()
today = date.today()
if type_of_backup == 'oldest_daily_backup':
start_date = today + relativedelta(weekday=MO(-1))
backup_start_time = dt.datetime.combine(start_date, backup_start_hours)
backup_end_time = backup_start_time + timedelta(hours=12)
elif type_of_backup == 'latest_full_backup':
start_date = today + relativedelta(weekday=FR(-1))
backup_start_time = dt.datetime.combine(start_date, backup_start_hours)
backup_end_time = backup_start_time + timedelta(hours=48)
elif type_of_backup == 'latest_daily_backup':
start_date = today - datetime.timedelta(days=0)
backup_start_time = dt.datetime.combine(start_date, backup_start_hours)
backup_end_time = backup_start_time + timedelta(hours=3)
def backup_time(backup_end_time, backup_start_time):
