def artistdashboard(request):
prev = request.GET.get('prev', None)
igene_day_leaves = Leave.objects.filter(
leave_type="I_GENE_HLDAY").values_list("date", flat=True)
weekend_leaves = Leave.objects.filter(leave_type="WEEKEND").values_list(
"date", flat=True)
if (prev == None):
print(time.tzset())
print(time.ctime())
print(time.time())
print(time.localtime())
print(datetime.today())
print(datetime.utcnow())
print(timezone.now().date())
year, week, today = date.today().isocalendar()
datelist = [date.fromisocalendar(year, week, x) for x in range(1, 8)]
else:
d = datetime.today() - timedelta(days=7 * int(prev))
year, week, today = d.date().isocalendar()
print(week)
datelist = [date.fromisocalendar(year, week, x) for x in range(1, 8)]
print(request.user)
return render(
request, "artistdashboard.html", {
"datelist": datelist,
"igene_day_leaves": igene_day_leaves,
"weekend_leaves": weekend_leaves
})
def getYearDays(request):
days_dict = {}
for i in range(1, 13):
monthdays_list = []
year = date.today().year
startyear, start_week, day = date(year, i, 1).isocalendar()
end_week = date(year, i,
calendar.monthrange(year, i)[1]).isocalendar()[1]
if i == 1 and (year != startyear):
monthdays_list.append([
date.fromisocalendar(
startyear, start_week, weekday) if date.fromisocalendar(
startyear, start_week, weekday).month == i else None
for weekday in range(1, 8)
])
for week in range(1, end_week +
1) if i == 1 else range(start_week, end_week + 1):
weekday_list = [
date.fromisocalendar(year, week, weekday) if
date.fromisocalendar(year, week, weekday).month == i else None
for weekday in range(1, 8)
]
monthdays_list.append(weekday_list)
days_dict[i] = monthdays_list
print(days_dict)
return JsonResponse({"result": days_dict})
def get_christmas_holidays(
self, year, in_december=True, in_january=True
):
""" Christmas holidays run partially in December and partially in January
(spillover from previous year).
"""
if in_december:
# 27 December is always in a full week of holidays
week = date(year, 12, 27).isocalendar()[1]
# Holiday starts on the preceding Saturday
try:
start = date.fromisocalendar(year, week - 1, 6)
except AttributeError:
# Adapted from https://stackoverflow.com/a/59200842
first = date(year, 1, 1)
base = 1 if first.isocalendar()[1] == 1 else 8
start = first + timedelta(
days=base - first.isocalendar()[2] + 7 * (week - 1) - 2
)
dates = [
(
start + timedelta(days=i), "Christmas holiday"
) for i in range((date(year, 12, 31) - start).days + 1)
]
if in_january:
dates.extend(
self.get_christmas_holidays(year, in_december=False)
)
return dates
n_days = 16
# 27 December is always in a full week of holidays
week = date(year - 1, 12, 27).isocalendar()[1]
# Holiday ends 15 days after the preceding Saturday
try:
end = date.fromisocalendar(
year - 1, week - 1, 6
) + timedelta(days=n_days - 1)
except AttributeError:
# Adapted from https://stackoverflow.com/a/59200842
first = date(year - 1, 1, 1)
base = 1 if first.isocalendar()[1] == 1 else 8
end = first + timedelta(
days=base - first.isocalendar()[2] + 7 * (week - 1)
+ n_days - 3
)
return [
(
date(year, 1, 1) + timedelta(days=i), "Christmas holiday"
) for i in range((end - date(year, 1, 1)).days + 1)
]
def leaveDashboard(request):
months = [
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
]
days_dict = {}
igene_day_leaves = Leave.objects.filter(
leave_type="I_GENE_HLDAY").values_list("date", flat=True)
igene_holidays = Leave.objects.filter(leave_type="I_GENE_HLDAY")
weekend_leaves = Leave.objects.filter(leave_type="WEEKEND").values_list(
"date", flat=True)
year = date.today().year
sunday_count = 0
dt = date(year, 1, 1)
dt += timedelta(days=6 - dt.weekday())
while dt.year == year:
if dt not in igene_day_leaves and dt not in weekend_leaves:
sunday_count += 1
dt += timedelta(days=7)
total_days = 366 - sunday_count if calendar.isleap(
year) else 365 - sunday_count
for i in range(1, 13):
monthdays_list = []
startyear, start_week, day = date(year, i, 1).isocalendar()
end_week = date(year, i,
calendar.monthrange(year, i)[1]).isocalendar()[1]
if i == 1 and (year != startyear):
monthdays_list.append([
date.fromisocalendar(
startyear, start_week, weekday) if date.fromisocalendar(
startyear, start_week, weekday).month == i else None
for weekday in range(1, 8)
])
for week in range(1, end_week +
1) if i == 1 else range(start_week, end_week + 1):
weekday_list = [
date.fromisocalendar(year, week, weekday) if
date.fromisocalendar(year, week, weekday).month == i else None
for weekday in range(1, 8)
]
monthdays_list.append(weekday_list)
days_dict[i] = monthdays_list
return render(
request, "dashboard.html", {
"months": months,
"month_days": days_dict,
"range": range(1, 13),
"igene_day_leaves": igene_day_leaves,
"igene_holidays": igene_holidays,
"weekend_leaves": weekend_leaves,
"total_days":
total_days - len(igene_day_leaves) - len(weekend_leaves)
})
def registreer_week_bevestigd(response, persoon_guid, jaar, week):
uren_status_list = []
dagen_van_de_week_list = []
dagen_week_query_list = []
week_nummer_list = []
week_dag_dict = {}
account_id = response.user.id
persoon_ingelogd = Personen.objects.get(account=account_id)
persoon_guid = persoon_ingelogd.persoon_guid
persoon_pk = persoon_ingelogd.id
nu = datetime.datetime.now()
huidig_jaar = nu.year
huidige_week = week
for dag in range(1, 8):
dagen_van_de_week_list.append([
date.fromisocalendar(jaar, week, dag),
date.fromisocalendar(jaar, week, dag).strftime("%A")
])
dagen_week_query_list.append(date.fromisocalendar(jaar, week, dag))
for week_nummer in range(week - 1, week + 2):
week_nummer_list.append(week_nummer)
uren_registratie_persoon = UrenRegistratie.objects.filter(
persoonnr=persoon_pk)
for dag in dagen_week_query_list:
uren_registratie_dag = uren_registratie_persoon.filter(datum=dag)
uren_registratie_dag_persoon = uren_registratie_dag.values(
'persoonnr').order_by('persoonnr')
uren_registratie_dag_totaal = uren_registratie_dag_persoon.annotate(
aantal_uren=Sum('aantal_uur'))
week_dag_dict[dag] = [
UrenRegistratieTableBevestigd(
uren_registratie_persoon.filter(datum=dag)),
uren_registratie_dag_totaal
]
return render(
response, 'claus_uren/registreer_week_bevestigd.html', {
"persoon_ingelogd": persoon_ingelogd,
"dagen_van_de_week_list": dagen_van_de_week_list,
"week_nummer_list": week_nummer_list,
"week": week,
"persoon_guid": persoon_guid,
"week_dag_dict": week_dag_dict,
})
def _insert_many_expenses():
# Every time period has 'displaying scope' in Statistic. Comments explain this scope.
time = get_today_now().time()
# In year, month, week and day will be displayed
today = get_today_now().date()
now = get_today_now()
# Only in year, month and week will be displayed
this_week_date = date.fromisocalendar(year=today.isocalendar()[0],
week=today.isocalendar()[1],
day=3)
if this_week_date.day == today.day:
this_week_date = date.fromisocalendar(year=today.isocalendar()[0],
week=today.isocalendar()[1],
day=5)
this_week = datetime.combine(this_week_date, time)
# Only in year and month will be displayed
this_month_date = date(year=today.year, month=today.month, day=10)
if this_month_date.day == today.day or this_month_date.isocalendar(
)[1] == today.isocalendar()[1]:
this_month_date = date(year=today.year, month=today.month,
day=20) # in year and month will be displayed
this_month = datetime.combine(this_month_date, time)
# Only in year will be displayed
this_year_date = date(year=today.year, month=2, day=10)
if this_year_date.month == today.month:
this_year_date = date(year=today.year, month=11,
day=10) # in year will be displayed
this_year = datetime.combine(this_year_date, time)
prev_year_date = date(year=today.year - 1, month=3,
day=10) # never be displayed
next_year_date = date(year=today.year - 1, month=3,
day=10) # never be displayed
prev_year = datetime.combine(prev_year_date, time)
next_year = datetime.combine(next_year_date, time)
money = 'Cash'
card = 'Card'
data_expense = [(1, Decimal('150.00'), now, 1, money, None, 'test'),
(2, Decimal('150.00'), now, 1, card, None, 'test'),
(3, Decimal('25.00'), now, 7, card, None, 'test')]
Expense.insert_many(data_expense,
fields=[
Expense.id, Expense.amount, Expense.time_creating,
Expense.category_id, Expense.payment_type,
Expense.additional_info, Expense.raw_text
]).execute()
def add_date(self, no_date, year, week):
day_dates = {'mon': 1, 'tue': 2, 'wen': 3, 'thu': 4, 'fri': 5}
res = []
for elem in no_date:
x = str(next(iter(elem)))[0:3]
day_of_week = day_dates[x]
shift_date = date.fromisocalendar(year, week, day_of_week)
elem['date'] = shift_date
#res.append( first )
first = date.fromisocalendar(2021, 1, 1)
with_date = no_date
return with_date
def __init__(self):
self.users = []
kwargs1 = {"card": Card(1, "1111111111111111", "111", date.fromisocalendar(2021, 1, 1))}
kwargs2 = {"card": Card(2, "2222222222222222", "222", date.fromisocalendar(2021, 1, 1))}
deal2 = Deal(2, 2, 2)
user1 = User(1, "user1", "*****@*****.**", "+000000000000", **kwargs1)
user2 = User(2, "user2", "*****@*****.**", "+222222222222", **kwargs2)
user2.register_seller_deal(deal2)
user1.register_buyers_deal(deal2)
self.users.append(user1)
self.users.append(user2)
def wochenplanung(PrüffeldVar = '', yearVar = 0, KWVar=0, fileVar=''):
#In Version 2.0 for GUI, the steps for creating file and KW are no longer required but are kept if Wochenplanung is run as __main__
if yearVar == 0:
P = input('Prüffeld: ')
if P in ['e', 'E', 'eetz', 'EETZ']:
Prüffeld = 'EETZ'
else:
Prüffeld = 'UPZ'
while True:
KWstr = input('Bitte KW eingeben: ')
yearstr = input('Jahr eingeben: ')
try:
assert len(yearstr) == 4
KW = int(KWstr)
year = int(yearstr)
break
except AssertionError as e:
e.args += ('Ungültige Jahreszahl', yearstr)
raise
except:
print('Falsches Format bei KW oder Jahr')
while True:
filename = input('Dateiname eingeben: ')
file = r'..\{}'.format(filename)
if os.path.isfile(file):
break
else:
print('Datei nicht gefunden. Erneut eingeben.\n')
else:
Prüffeld = PrüffeldVar.get()
year = yearVar.get()
KW = KWVar.get()
file = fileVar
#Copy Excel Template and create new File
fname = copyx(Prüffeld,KW)
# Get Monday for current CW
monday = date.fromisocalendar(year, KW, 1)
# Open workbook
workbook = openpyxl.load_workbook(fname)
sheet = workbook.active
# Update Excel with current date
prepare_excel(monday, workbook, sheet, Prüffeld, KW, year)
# Read the AKF data from eBas Export
akfs = read_eBas(file, Prüffeld)
#Call planning function
planning(workbook, sheet, monday, akfs, Prüffeld)
workbook.save(fname)
workbook.close()
shutil.move(fname, "..\{}".format(fname))
def get_spring_holidays(self, year):
n_days = 9
week = 9
# Exceptional years
if year in [2024, 2021]:
week = 8
# Holiday starts on the preceding Saturday
try:
start = date.fromisocalendar(year, week - 1, 6)
except AttributeError:
# Adapted from https://stackoverflow.com/a/59200842
first = date(year, 1, 1)
base = 1 if first.isocalendar()[1] == 1 else 8
start = first + timedelta(days=base - first.isocalendar()[2] + 7 *
(week - 1) - 2)
# Some regions have their spring holiday 1 week earlier
try:
if self.region in SPRING_HOLIDAYS_EARLY_REGIONS[year]:
start = start - timedelta(weeks=1)
except KeyError:
raise NotImplementedError(f"Unknown spring holidays for {year}.")
return [(start + timedelta(days=i), "Spring holiday")
for i in range(n_days)]
def get(self, request):
keyword = request.GET.get('keyword', '2')
limit = request.GET.get('limit', '6')
today_iso = datetime.datetime.now().isocalendar()
year = today_iso[0]
week = today_iso[1]
day = today_iso[2]
week_start = date.fromisocalendar(year, week, 1)
now = datetime.datetime.now()
books = LibraryBook.objects.prefetch_related('book_set').filter(
created_at__range=[week_start, now],
book__keyword_id=int(keyword)).values(
'book_id', 'book__title', 'book__image_url',
'book__author').annotate(
count=Count('book_id')).order_by('-count')[:int(limit)]
book_list = [{
"id": book.get('book_id'),
"title": book.get('book__title'),
"image": book.get('book__image_url'),
"author": book.get('book__author')
} for book in books]
if not book_list:
return JsonResponse({"message": "NO_BOOKS"}, status=400)
return JsonResponse({"recommendBook": book_list}, status=200)
def get_view(self, database, view='byWeek', level=3):
url = self.url + "/{}/_design/sentimentDocs/_view/{}?reduce=true&group_level={}".format(
database, view, level)
output = requests.get(url)
if output.status_code == 404:
print("Unable to retrieve view")
else:
output_json = output.json()
avg_sentiment = [
x['value']['sum'] / x['value']['count']
for x in output_json['rows']
]
count = [x['value']['count'] for x in output_json['rows']]
if view == 'byWeek' or view == 'byWeek2':
time = [
str(x['key'][1]) + "-" + str(x['key'][2])
for x in output_json['rows']
]
toDate = lambda x: date.fromisocalendar(
int(x.split("-")[0]), int(x.split("-")[1]), 1)
time = [toDate(x).strftime('%d-%m-%Y') for x in time]
return avg_sentiment, count, time
else:
sa2 = [x['key'][0] for x in output_json['rows']]
return avg_sentiment, count, sa2
def get_summer_holidays(self, year):
n_days = 44
week = 29
# Holiday starts on the preceding Saturday
try:
start = date.fromisocalendar(year, week - 1, 6)
except AttributeError:
# Adapted from https://stackoverflow.com/a/59200842
first = date(year, 1, 1)
base = 1 if first.isocalendar()[1] == 1 else 8
start = first + timedelta(days=base - first.isocalendar()[2] + 7 *
(week - 1) - 2)
# Some regions have their summer holiday 1 week earlier
try:
if self.region in SUMMER_HOLIDAYS_EARLY_REGIONS[year]:
start = start - timedelta(weeks=1)
except KeyError:
raise NotImplementedError("Unknown summer holidays for %d." % year)
# Some regions have their summer holiday 1 week later
try:
if self.region in SUMMER_HOLIDAYS_LATE_REGIONS[year]:
start = start + timedelta(weeks=1)
except KeyError:
raise NotImplementedError("Unknown summer holidays for %d." % year)
return [(start + timedelta(days=i), "Summer holiday")
for i in range(n_days)]
def data_items(self):
week = self.kwargs['week']
week_shift = Shift.objects.filter(date__week=week)
holidays = Holidays.objects.filter(date__week=week)
leaves = Leaves.objects.filter(date_from__week=week)
first = date.fromisocalendar(2021, week, 1)
m = str(first)
mn = m[-2:]
mon = int(mn)
dates = []
for x in range(0, 5):
dates.append(mon)
mon += 1
data = self.data_row()
for shift in week_shift:
data[shift.educator_shift.user.username][self.date_filter(
shift.date)] = self.details(shift.shift_start, shift.shift_end,
shift.lunch)
data[shift.educator_shift.user.
username]['room'] = shift.educator_shift.room
for holiday in holidays:
#if self.date_filter(holiday.date) in dates:
data[shift.educator_shift.user.username][self.date_filter(
holiday.date)] = holiday.name
for leave in leaves:
data[leave.educator.user.username][self.date_filter(
leave.date_from)] = 'Leave: ' + leave.leave_type
return data
def write_diary(users_meetings, worksheet):
meetings_by_week = seperate_by_week(users_meetings)
start_week_num = meetings_by_week[0][0]["Start Time"].isocalendar()[1]
week_date = date.fromisocalendar(2020, start_week_num, 1)
for week in meetings_by_week:
week_date = week_date + datetime.timedelta(7)
write_week(week, worksheet, week_date)
return
def createOutputExcel(outputData):
wb = Workbook()
ws = wb.active
ws.title = 'Budget Projection'
columnNames = [
"Name", "SA Rate", "Deltek Rate", "Avg Run", "Hours", "Dollars"
]
for w in range(1, nTotalNumWeeks + 1):
nThYear = int(w / 54)
nYear = 2020 + int(nThYear)
nWeek = w - (53 * nThYear)
columnNames.append(
"Week " + str(nWeek) + " \n[" +
date.fromisocalendar(nYear, nWeek, 7).strftime("%m/%d/%y") + "]")
ws.freeze_panes = 'G3'
headerCnt = len(columnNames)
for cells in ws.iter_rows(1, 1, 1, headerCnt):
for cell in cells:
cell.value = columnNames[cell.column - 1]
cell.alignment = Alignment(wrapText=True, horizontal='center')
rowNum = 2
rowCnt = len(outputData) + 1
for name, stats in outputData.items():
for cells in ws.iter_rows(rowNum, rowNum, 1, headerCnt):
cells[0].value = name
ws.column_dimensions[cells[0].column_letter].width = 25
cells[1].value = stats['SpringAhead Rate']
cells[1].number_format = '"$"#'
ws.column_dimensions[cells[1].column_letter].width = 8
cells[2].value = stats['Deltek Rate']
cells[2].number_format = '"$"#'
ws.column_dimensions[cells[2].column_letter].width = 8
cells[3].value = stats['Avg Run']
cells[3].number_format = '0.00'
ws.column_dimensions[cells[3].column_letter].width = 7
cells[4].value = stats['Hours']
cells[4].number_format = '#,##0.00'
ws.column_dimensions[cells[4].column_letter].width = 9
cells[5].value = stats['Dollars']
cells[5].number_format = '"$"#,##0.00'
ws.column_dimensions[cells[5].column_letter].width = 14
for w in range(1, nTotalNumWeeks + 1):
cells[w + 5].value = float(stats[w])
if rowNum > rowCnt:
cells[w + 5].number_format = '"$"#,##0.00'
else:
cells[w + 5].number_format = '#,##0.00'
ws.column_dimensions[cells[w + 5].column_letter].width = 12
ws.column_dimensions[cells[w + 5].column_letter].height = 29
rowNum = rowNum + 1
setExcelFormulas(ws, rowCnt, headerCnt)
wb.save(outputFile)
def __init__(self):
self.users = []
self.confirmed = {}
kwargs1 = {
"card":
Card(0, "111111111111111", "111", date.fromisocalendar(2021, 1, 1))
}
user1 = User(0, "user1", "*****@*****.**", "+111111111111", **kwargs1)
self.users.append(user1)
def week_number_to_date_range(week_number):
if not week_number:
week_number = date.today().isocalendar()[1]
start_of_week = date.fromisocalendar(year=date.today().year,
week=week_number,
day=1)
end_of_week = start_of_week + timedelta(days=6)
return (start_of_week, end_of_week)
def render_snippet(md: markdown.Markdown, snippet: Snippet) -> RenderedSnippet:
return RenderedSnippet(
email=snippet.user.email,
id=snippet.user.id,
year=snippet.year,
week=snippet.week,
week_begin=date.fromisocalendar(snippet.year, snippet.week, 1),
content=snippet and md.convert(snippet.text),
tags=sorted(snippet.tags, key=lambda tag: tag.text),
)
def compute_loads_with_exceptions(loads_dataframe, exceptions_service_dict,
year, week):
# Creo un dizionario che contiene le frequenze giornaliere per ogni stazione
frequencies_dict = {}
hours = []
# Riempio la lista di ore
for i in range(4, 26, 1):
if i < 10:
hours.append('0' + str(i) + ':00:00')
else:
hours.append(str(i) + ':00:00')
for i in range(1, 8):
date_to_consider = date.fromisocalendar(year, week, i)
date_string = str(date_to_consider).replace('-', '')
day = calendar.day_name[date_to_consider.weekday()].lower()
frequencies_dict[day] = []
'''Questo dizionario temporaneo contiene:
- 'Inizio' -> ora d'inizio dell'analisi dei carichi
- 'Fine' -> ora di fine dell'analisi dei carichi
- 'Stazioni' -> oggetto contenente il numero di treni che passano nelle stazioni
nell'intervallo di tempo individuato da inizio e fine'''
temporary_dict = {}
for index_hour, hour in enumerate(hours):
if index_hour + 1 < len(hours):
temporary_dict['Inizio'] = hour
temporary_dict['Fine'] = hours[index_hour + 1]
# Creo un dizionario che rappresenta l'oggetto da inserire nella chiave 'Stazioni'
routes_dict = {}
for index_row, row in loads_dataframe.iterrows():
key = row['stop_id']
# Controllo che il treno non sia stato cancellato
if row[day] == 1 and hour <= row['arrival_time'] < hours[index_hour + 1] and \
check_no_service_exception(exceptions_service_dict, row['service_id'],
date_string):
if key not in routes_dict:
routes_dict[key] = 1
else:
routes_dict[key] += 1
temporary_dict['Stazioni'] = routes_dict.copy()
frequencies_dict[day].append(temporary_dict.copy())
if week < 10:
week_string = "0" + str(week)
else:
week_string = str(week)
# Salvo il file come oggetto JSON
with open(
'Carichi//loads_complete_with_exceptions_' + str(year) +
week_string + '.json', 'w') as fp:
json.dump(frequencies_dict, fp)
def update_collecting_date(self):
now = timezone.now().isocalendar()
if self.user.collecting_day.isoday > now[2]: #need a better query
next_date_iso = now[:2] + (self.user.collecting_day.isoday, )
else:
new_week = now[1] + 1
next_date_iso = now[:1] + (new_week, ) + (
self.user.collecting_day.isoday, )
new_datetime = datetime.combine(date.fromisocalendar(*next_date_iso),
self.user.collecting_time)
self.collecting_datetime = new_datetime
def get_subjects_by_week(week: int,
year: int = datetime.now().year
) -> List[List[Subject]]:
subjects_list = []
for i in range(5):
subjects_date = datetime.combine(
date.fromisocalendar(year, week, i + 1),
datetime.min.time()).date()
subjects_list.append(get_subjects_by_date(current_date=subjects_date))
return subjects_list
def get_week_range(iso_calendar):
iso_calendar_year = iso_calendar[0]
iso_calendar_week = iso_calendar[1]
if iso_calendar[2] == 7:
iso_calendar_week += 1
if iso_calendar_week == 54:
iso_calendar_year += 1
iso_calendar_week = 1
beginning_of_week = date.fromisocalendar(iso_calendar_year,
iso_calendar_week, 1)
return (beginning_of_week - timedelta(days=1),
beginning_of_week + timedelta(days=5))
def week_header(self):
week = self.kwargs['week']
first = date.fromisocalendar(2021, week, 1)
m = str(first)
mn = m[-2:]
mon = int(mn)
values = []
for x in range(0, 5):
values.append(mon)
mon += 1
keys = ['Mon', 'Tue', 'Wen', 'Thur', 'Fri']
week_day = dict(zip(keys, values))
return week_day
def get_week_list(year_number):
max_weeknumber = date(int(year_number), 12, 28).isocalendar()[
1] # check in with weeknumber the last day of the year is in
day_of_the_week = range(1, 6)
week_number = range(1, max_weeknumber + 1)
current_week = datetime.now().isocalendar()[1]
week_list = []
for w in week_number:
for d in day_of_the_week:
show_date = date.fromisocalendar(
int(year_number), w, d) # year, week number, day of the week
week_list.append([show_date, show_date.strftime('%A')])
return week_list, max_weeknumber
def get_dates_from_week(self, year, week):
""" Method gets year and week, and return 8 dates - days of this week and day next. Next day is neccesary to
check if long visit can be booked at last day"""
days = []
for i in range(1, 8):
days.append(date.fromisocalendar(year, week, i))
previous_day = days[0] - timedelta(days=1)
days.insert(0, previous_day)
next_day = days[-1] + timedelta(days=1)
days.append(next_day)
return days
def read_testzahl(self):
testzahl_path = find_latest_file(os.path.join(PARENT_DIRECTORY, "Testzahlen", "raw_data"))[0]
testzahl_df = pd.read_excel(testzahl_path, sheet_name='1_Testzahlerfassung', skipfooter=1)
testzahl_df = testzahl_df.drop(0)
datum = []
for key, value in testzahl_df.iterrows():
kalender = value['Kalenderwoche'].split('/')
kalender_clean = []
for k in kalender:
kalender_clean.append(int(re.sub('\\D', '', k)))
datum.append(date.fromisocalendar(kalender_clean[1], kalender_clean[0], 7))
testzahl_df.index = pd.to_datetime(datum)
testzahl_df = testzahl_df.resample("1D").backfill()
testzahl_df.sort_index(ascending=True, inplace=True)
testzahl_df["Testungen_7d_mean"] = testzahl_df["Anzahl Testungen"] / 7
testzahl_df["Positiv_7d_mean"] = testzahl_df['Positiv getestet'] / 7
return testzahl_df
def render_snippet_form(
form: SnippetsForm, user: User, year: int, week: int
) -> Text:
snippet = Snippet.get_by_week(user.id, year, week)
text = snippet and snippet.text
form.text.data = text
form.year.data = year
form.week.data = week
tags = snippet and sorted(tag.text for tag in snippet.tags) or []
form.tags.data = ", ".join(tags)
return render_template(
"edit.html.j2",
name=user.name,
user_id=user.id,
week_begin=date.fromisocalendar(year, week, 1),
content=text and markdown.markdown(text),
form=form,
tags=tags,
)
def get_may_holidays(self, year):
n_days = 9
week = 18
# Exceptional years
if year == 2017:
week = 17
# Holiday starts on the preceding Saturday
try:
start = date.fromisocalendar(year, week - 1, 6)
except AttributeError:
# Adapted from https://stackoverflow.com/a/59200842
first = date(year, 1, 1)
base = 1 if first.isocalendar()[1] == 1 else 8
start = first + timedelta(days=base - first.isocalendar()[2] + 7 *
(week - 1) - 2)
return [(start + timedelta(days=i), "May holiday")
for i in range(n_days)]
def make_date(self, year=0, month=0, day=0, weekday=0, error=False, today=False):
if today:
new_date = self.today
if error:
new_date = self.today
if not year:
year = self.today.year
elif len(year) == 2:
year = '20' + year
if weekday:
week = self.today.isocalendar().week
new_date = date.fromisocalendar(year, week, weekday)
else:
if not month:
month = self.today.month
try:
new_date = date(int(year), int(month), int(day))
except ValueError:
new_date = self.today
self.output_date = new_date
