def test_holiday_for_year_by_name(self):
d = SchoolHolidayDates()
res = d.holiday_for_year_by_name(2017, 'Vacances de la Toussaint')
self.assertEquals(len(res), 16)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date) for date in [
'2017-10-21', '2017-10-22', '2017-10-23', '2017-10-24',
'2017-10-25', '2017-10-26', '2017-10-27', '2017-10-28',
'2017-10-29', '2017-10-30', '2017-10-31', '2017-11-01',
'2017-11-02', '2017-11-03', '2017-11-04', '2017-11-05'
]
]
self.assertEquals(sorted([v['date'] for v in res.values()]),
expected_dates)
with self.assertRaisesRegexp(UnsupportedYearException,
'No data for year: 2005'):
self.assertEquals({},
d.holiday_for_year_by_name(
2005, 'Vacances de la Toussaint'))
with self.assertRaisesRegexp(UnsupportedHolidayException,
'Unknown holiday name: Foo'):
self.assertEquals({}, d.holiday_for_year_by_name(2017, 'Foo'))
def processing(dataInt):
## missing value
df = dataInt.copy()
df_num = df.drop(['timestamp','loc_1', 'loc_2', 'loc_secondary_1', 'loc_secondary_2', 'loc_secondary_3'], axis=1)
df_NonNum = df.select_dtypes(include=[np.object])
imputed_training_mice = mice(df_num.values)
data_mice = pd.DataFrame(imputed_training_mice, columns = df_num.columns, index = list(df.index.values))
dClean = data_mice.join(df_NonNum)
## drop variable inutile
d_tr = dClean.drop(['loc_1', 'loc_2', 'loc_secondary_1', 'loc_secondary_2', 'loc_secondary_3'], axis=1)
## create extra attribute
conv(d_tr)
d_tr['timestamp'] = pd.to_datetime(d_tr.timestamp, format = '%Y-%m-%dT%H:%M:%S.%f')
## create season and rangeInYear
s = pd.to_datetime(pd.Series(d_tr['timestamp']))
d_tr['rangeInYear'] = s.dt.strftime('%j').astype(int)
d_tr['season'] = d_tr['rangeInYear'].apply(lambda d : get_season(d))
#create jours working days
d_tr['is_business_day'] = d_tr['datetime_perso'].apply(lambda e : int(business_day(e)))
# Is it an holiday for zone A, B or C?
d = SchoolHolidayDates()
d_tr['is_holiday'] = d_tr['datetime_perso'].apply(lambda f : int(d.is_holiday(datetime.date(f))))
dataInt1 = d_tr.drop(['rangeInYear', 'datetime_perso', 'date', 'timestamp'], axis=1)
return (dataInt1)
def __add_holidays_columns__(self, df) :
d = SchoolHolidayDates()
new_df = df.copy()
new_df[cf.SCHOOL_HOLIDAYS_A_COL] = new_df[cf.DATE_COL].apply(lambda row : d.is_holiday_for_zone(date(row.year, row.month, row.day), 'A') )
new_df[cf.SCHOOL_HOLIDAYS_B_COL] = new_df[cf.DATE_COL].apply(lambda row : d.is_holiday_for_zone(date(row.year, row.month, row.day), 'B') )
new_df[cf.SCHOOL_HOLIDAYS_C_COL] = new_df[cf.DATE_COL].apply(lambda row : d.is_holiday_for_zone(date(row.year, row.month, row.day), 'C') )
return new_df
def progression(request):
date_rentree = reglage_date.objects.get(nom='Rentrée').jour
CB1 = reglage_date.objects.get(nom='Lundi concours blanc 1').jour
CB2 = reglage_date.objects.get(nom='Lundi concours blanc 2').jour
while date_rentree.weekday() != 0:
date_rentree += -datetime.timedelta(days=1)
print(date_rentree, date_rentree.weekday())
cours = []
tds = []
tps = []
semaines = []
d = SchoolHolidayDates()
for sean in seance.objects.all():
if sean.ressource.type_de_ressource()[0] == 'cours':
if sean.duree_seance == 0:
cours[-1].append(sean)
else:
for i in range(sean.duree_seance):
cours.append([sean])
if sean.ressource.type_de_ressource()[0] == 'td':
if sean.duree_seance == 0:
tds[-1].append(sean)
else:
for i in range(sean.duree_seance):
tds.append([sean])
if sean.ressource.type_de_ressource()[0] == 'tp':
if sean.duree_seance == 0:
tps[-1].append(sean)
else:
for i in range(sean.duree_seance):
tps.append([sean])
cours = cours + [''] * (max(len(cours), len(tds), len(tps)) - len(cours))
tds = tds + [''] * (max(len(cours), len(tds), len(tps)) - len(tds))
tps = tps + [''] * (max(len(cours), len(tds), len(tps)) - len(tps))
present = 0
i, j = 0, 0
print(tps)
while j < len(cours):
date = date_rentree + datetime.timedelta(days=7 * i)
if date < date.today():
color = "#cccdcd"
elif date <= date.today() and date > date.today() - datetime.timedelta(
days=7):
color = "#03a5f6"
else:
color = ""
if d.is_holiday_for_zone(date, 'C') and d.is_holiday_for_zone(
date + datetime.timedelta(days=1), 'C') and date.month != 8:
semaines.append([i + 1, date, color, False, True, False])
elif date == CB1 or date == CB2:
semaines.append([i + 1, date, color, False, False, True])
else:
semaines.append(
[i + 1, date, color, [cours[j], tds[j], tps[j]], False, False])
j += 1
i += 1
return render(request, 'progression.html', {'semaines': semaines})
def test_holidays_for_year_zone_and_name(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_zone_and_name(2017, 'A',
'Vacances de printemps')
self.assertEquals(len(res), 17)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date) for date in [
'2017-04-15', '2017-04-16', '2017-04-17', '2017-04-18',
'2017-04-19', '2017-04-20', '2017-04-21', '2017-04-22',
'2017-04-23', '2017-04-24', '2017-04-25', '2017-04-26',
'2017-04-27', '2017-04-28', '2017-04-29', '2017-04-30',
'2017-05-01'
]
]
self.assertEquals(sorted([v['date'] for v in res.values()]),
expected_dates)
with self.assertRaisesRegexp(UnsupportedYearException,
'No data for year: 2005'):
d.holidays_for_year_zone_and_name(2005, 'A',
'Vacances de printemps')
with self.assertRaisesRegexp(UnsupportedZoneException,
'Unsupported zone: D'):
d.holidays_for_year_zone_and_name(2017, 'D',
'Vacances de printemps')
with self.assertRaisesRegexp(UnsupportedHolidayException,
'Unknown holiday name: Foo'):
d.holidays_for_year_zone_and_name(2017, 'A', 'Foo')
def test_supported_holidays_are_complete(self):
d = SchoolHolidayDates()
res = d.holidays_for_year(2019)
names = set()
for _, v in res.items():
names.add(v["nom_vacances"])
expected = set(SchoolHolidayDates.SUPPORTED_HOLIDAY_NAMES)
self.assertEquals(names, expected)
def test_supported_holidays_are_complete(self):
d = SchoolHolidayDates()
res = d.holidays_for_year(2019)
names = set()
for _, v in res.items():
names.add(v["nom_vacances"])
expected = set(SchoolHolidayDates.SUPPORTED_HOLIDAY_NAMES)
self.assertEquals(names, expected)
def test_holidays_for_year(self):
d = SchoolHolidayDates()
res = d.holidays_for_year(2018)
self.assertEquals(len(res), 151)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 2024"):
self.assertEquals({}, d.holidays_for_year(2024))
def test_holidays_for_year(self):
d = SchoolHolidayDates()
res = d.holidays_for_year(2018)
self.assertEquals(len(res), 151)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 2021"
):
self.assertEquals({}, d.holidays_for_year(2021))
class OperationsStatsTransformer(BaseTransformer):
DATE_COLUMNS = ["date_heure_reception_alerte_locale", "date_heure_reception_alerte"]
def __init__(self, filepath):
super(OperationsStatsTransformer, self).__init__(filepath)
self.bank_holidays = {}
self.school_holiday = SchoolHolidayDates()
def transform(self, output):
df = self.read_csv()
df["phase_journee"] = df.apply(lambda row: self.phase_journee(row), axis=1)
df["est_jour_ferie"] = df.apply(lambda row: self.est_jour_ferie(row), axis=1)
df["est_vacances_scolaires"] = df.apply(
lambda row: self.est_vacances_scolaires(row), axis=1
)
df.drop(["latitude", "longitude"] + self.DATE_COLUMNS, axis=1, inplace=True)
self.to_csv(df, output)
def phase_journee(self, row):
heure_locale = row["date_heure_reception_alerte_locale"]
heure_utc = row["date_heure_reception_alerte"]
latitude, longitude = row["latitude"], row["longitude"]
try:
sunrise, sunset = SunriseSunset(heure_utc, latitude, longitude).calculate()
except ValueError:
return np.nan
# coucher du soleil -> lever du soleil
if sunset <= heure_utc <= sunrise:
return "nuit"
# 12:00 -> 13:59
elif 12 <= heure_locale.hour <= 13:
return "déjeuner"
# lever du soleil -> 10:59
elif heure_locale.hour <= 11:
return "matinée"
# 14:00 -> coucher du soleil
elif heure_locale.hour >= 14:
return "après-midi"
else:
raise ValueError("Date is invalid " + str(heure_locale))
def est_jour_ferie(self, row):
date = row["date_heure_reception_alerte_locale"].date()
if date.year not in self.bank_holidays:
dates = JoursFeries.for_year(date.year).values()
self.bank_holidays[date.year] = dates
return date in self.bank_holidays[date.year]
def est_vacances_scolaires(self, row):
try:
date = row["date_heure_reception_alerte_locale"].date()
return self.school_holiday.is_holiday(date)
except UnsupportedYearException:
return np.nan
def test_holidays_for_year_and_zone(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_and_zone(2017, "A")
self.assertEquals(len(res), 118)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
self.assertTrue(v["vacances_zone_a"])
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 1985"
):
self.assertFalse(d.holidays_for_year_and_zone(1985, "D"))
with self.assertRaisesRegexp(UnsupportedZoneException, "Unsupported zone: D"):
self.assertFalse(d.holidays_for_year_and_zone(2017, "D"))
def test_holidays_for_year_and_zone(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_and_zone(2017, "A")
self.assertEquals(len(res), 118)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
self.assertTrue(v["vacances_zone_a"])
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 1985"):
self.assertFalse(d.holidays_for_year_and_zone(1985, "D"))
with self.assertRaisesRegexp(UnsupportedZoneException,
"Unsupported zone: D"):
self.assertFalse(d.holidays_for_year_and_zone(2017, "D"))
def test_holidays_for_year_and_zone(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_and_zone(2017, 'A')
self.assertEquals(len(res), 120)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
self.assertTrue(v['vacances_zone_a'])
with self.assertRaisesRegexp(UnsupportedYearException,
'No data for year: 2005'):
self.assertFalse(d.holidays_for_year_and_zone(2005, 'D'))
with self.assertRaisesRegexp(UnsupportedZoneException,
'Unsupported zone: D'):
self.assertFalse(d.holidays_for_year_and_zone(2017, 'D'))
def test_is_holiday_for_zone(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "A"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "B"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "C"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 3, 7), "A"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 6, 7), "A"))
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 1985"):
d.is_holiday_for_zone(datetime.date(1985, 2, 7), "D")
with self.assertRaisesRegexp(UnsupportedZoneException,
"Unsupported zone: D"):
self.assertFalse(
d.is_holiday_for_zone(datetime.date(2009, 2, 7), "D"))
with self.assertRaisesRegexp(ValueError,
"date should be a datetime.date"):
d.is_holiday_for_zone(datetime.datetime(2017, 12, 1, 2, 0), "A")
def test_holiday_for_year_by_name(self):
d = SchoolHolidayDates()
res = d.holiday_for_year_by_name(2017, "Vacances de la Toussaint")
self.assertEquals(len(res), 16)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date)
for date in [
"2017-10-21",
"2017-10-22",
"2017-10-23",
"2017-10-24",
"2017-10-25",
"2017-10-26",
"2017-10-27",
"2017-10-28",
"2017-10-29",
"2017-10-30",
"2017-10-31",
"2017-11-01",
"2017-11-02",
"2017-11-03",
"2017-11-04",
"2017-11-05",
]
]
self.assertEquals(sorted([v["date"] for v in res.values()]), expected_dates)
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 1985"
):
self.assertEquals(
{}, d.holiday_for_year_by_name(1985, "Vacances de la Toussaint")
)
with self.assertRaisesRegexp(
UnsupportedHolidayException, "Unknown holiday name: Foo"
):
self.assertEquals({}, d.holiday_for_year_by_name(2017, "Foo"))
def get_encoded_calendar_df(data_final):
# Load school holidays for France
fr_holidays = SchoolHolidayDates()
df_vacances = pd.DataFrame()
for year in list(set(data_final['year'])):
df_vacances = pd.concat([df_vacances, pd.DataFrame.from_dict(fr_holidays.holidays_for_year(year)).T])
# Load bank holidays for France
df_jf = pd.DataFrame()
for year in list(set(data_final['year'])):
df_jf = pd.concat([df_jf, pd.DataFrame([
{'date': el[0], 'jour_ferie': el[1]} for el in sorted(holidays.FRA(years=year).items())])])
# Merge school and bank holidays
df_holidays = pd.merge(df_vacances, df_jf, how='outer', on='date')
# Create features from df_holidays dataframes (school holidays and bank holidays):
# - 3 binary features for school holidays, taking 1 if the given zone is on holiday, else 0 (vacances_zone_a,
# vacances_zone_b, vacances_zone_c)
# Definition of a dictionary to encode boolean into numeric
dict_map_vac = {
True: 1,
False: 0
}
# Apply dictionary to each holiday column for the three zones (A, B, C)
df_holidays['vacances_zone_a'] = df_holidays['vacances_zone_a'].map(dict_map_vac)
df_holidays['vacances_zone_b'] = df_holidays['vacances_zone_b'].map(dict_map_vac)
df_holidays['vacances_zone_c'] = df_holidays['vacances_zone_c'].map(dict_map_vac)
# - 1 binary feature for bank holiday, taking 1 if it is a bank holiday, else 0
# The column "jour ferie" contains either the name of the holiday or a missing value (NaN)
# The idea is to put a '1' when it's a holiday (i.e. when the value is different from nan, else 0)
df_holidays['jour_ferie'] = df_holidays['jour_ferie'].map(lambda x: 1 if str(x) != 'nan' else 0)
# - To go further: Try to create a combined feature with school and bank holidays
df_holidays['holiday'] = df_holidays['vacances_zone_a'] + df_holidays['vacances_zone_b'] + df_holidays[
'vacances_zone_c'] + df_holidays['jour_ferie']
df_holidays['date'] = df_holidays['date'].map(lambda x: str(x))
data_final_cal = pd.merge(data_final, df_holidays, how='left', left_on='release_date', right_on='date').fillna(0)
data_final_cal['month'] = data_final_cal['release_date'].map(lambda x: int(x[5:7]))
data_final_cal = apply_cos(data_final_cal, 'month', 'cos_month', 12)
return data_final_cal
def test_is_holiday(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday(datetime.date(2017, 12, 25)))
self.assertFalse(d.is_holiday(datetime.date(2017, 12, 1)))
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 1985"):
d.is_holiday(datetime.date(1985, 2, 7))
with self.assertRaisesRegexp(ValueError,
"date should be a datetime.date"):
d.is_holiday(datetime.datetime(2017, 12, 1, 2, 0))
def test_is_holiday_for_zone(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "A"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "B"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "C"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 3, 7), "A"))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 6, 7), "A"))
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 1985"
):
d.is_holiday_for_zone(datetime.date(1985, 2, 7), "D")
with self.assertRaisesRegexp(UnsupportedZoneException, "Unsupported zone: D"):
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), "D"))
with self.assertRaisesRegexp(ValueError, "date should be a datetime.date"):
d.is_holiday_for_zone(datetime.datetime(2017, 12, 1, 2, 0), "A")
def test_holidays_for_year_zone_and_name(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_zone_and_name(2017, "A",
"Vacances de printemps")
self.assertEquals(len(res), 17)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date) for date in [
"2017-04-15",
"2017-04-16",
"2017-04-17",
"2017-04-18",
"2017-04-19",
"2017-04-20",
"2017-04-21",
"2017-04-22",
"2017-04-23",
"2017-04-24",
"2017-04-25",
"2017-04-26",
"2017-04-27",
"2017-04-28",
"2017-04-29",
"2017-04-30",
"2017-05-01",
]
]
self.assertEquals(sorted([v["date"] for v in res.values()]),
expected_dates)
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 1985"):
d.holidays_for_year_zone_and_name(1985, "A",
"Vacances de printemps")
with self.assertRaisesRegexp(UnsupportedZoneException,
"Unsupported zone: D"):
d.holidays_for_year_zone_and_name(2017, "D",
"Vacances de printemps")
with self.assertRaisesRegexp(UnsupportedHolidayException,
"Unknown holiday name: Foo"):
d.holidays_for_year_zone_and_name(2017, "A", "Foo")
def test_holiday_for_year_by_name(self):
d = SchoolHolidayDates()
res = d.holiday_for_year_by_name(2017, "Vacances de la Toussaint")
self.assertEquals(len(res), 16)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date) for date in [
"2017-10-21",
"2017-10-22",
"2017-10-23",
"2017-10-24",
"2017-10-25",
"2017-10-26",
"2017-10-27",
"2017-10-28",
"2017-10-29",
"2017-10-30",
"2017-10-31",
"2017-11-01",
"2017-11-02",
"2017-11-03",
"2017-11-04",
"2017-11-05",
]
]
self.assertEquals(sorted([v["date"] for v in res.values()]),
expected_dates)
with self.assertRaisesRegexp(UnsupportedYearException,
"No data for year: 1985"):
self.assertEquals({},
d.holiday_for_year_by_name(
1985, "Vacances de la Toussaint"))
with self.assertRaisesRegexp(UnsupportedHolidayException,
"Unknown holiday name: Foo"):
self.assertEquals({}, d.holiday_for_year_by_name(2017, "Foo"))
def test_is_holiday_for_zone(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday_for_zone(datetime.date(2009, 2, 7), 'A'))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), 'B'))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 2, 7), 'C'))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 3, 7), 'A'))
self.assertFalse(d.is_holiday_for_zone(datetime.date(2009, 6, 7), 'A'))
with self.assertRaisesRegexp(UnsupportedYearException,
'No data for year: 2005'):
d.is_holiday_for_zone(datetime.date(2005, 2, 7), 'D')
with self.assertRaisesRegexp(UnsupportedZoneException,
'Unsupported zone: D'):
self.assertFalse(
d.is_holiday_for_zone(datetime.date(2009, 2, 7), 'D'))
def test_is_holiday(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday(datetime.date(2017, 12, 25)))
self.assertFalse(d.is_holiday(datetime.date(2017, 12, 1)))
with self.assertRaisesRegexp(UnsupportedYearException,
'No data for year: 2005'):
d.is_holiday(datetime.date(2005, 2, 7))
def test_is_holiday(self):
d = SchoolHolidayDates()
self.assertTrue(d.is_holiday(datetime.date(2017, 12, 25)))
self.assertFalse(d.is_holiday(datetime.date(2017, 12, 1)))
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 1985"
):
d.is_holiday(datetime.date(1985, 2, 7))
with self.assertRaisesRegexp(ValueError, "date should be a datetime.date"):
d.is_holiday(datetime.datetime(2017, 12, 1, 2, 0))
def test_holidays_for_year_zone_and_name(self):
d = SchoolHolidayDates()
res = d.holidays_for_year_zone_and_name(2017, "A", "Vacances de printemps")
self.assertEquals(len(res), 17)
for k, v in res.items():
self.assertEquals(sorted(v.keys()), self.EXPECTED_KEYS)
expected_dates = [
self.parse_date(date)
for date in [
"2017-04-15",
"2017-04-16",
"2017-04-17",
"2017-04-18",
"2017-04-19",
"2017-04-20",
"2017-04-21",
"2017-04-22",
"2017-04-23",
"2017-04-24",
"2017-04-25",
"2017-04-26",
"2017-04-27",
"2017-04-28",
"2017-04-29",
"2017-04-30",
"2017-05-01",
]
]
self.assertEquals(sorted([v["date"] for v in res.values()]), expected_dates)
with self.assertRaisesRegexp(
UnsupportedYearException, "No data for year: 1985"
):
d.holidays_for_year_zone_and_name(1985, "A", "Vacances de printemps")
with self.assertRaisesRegexp(UnsupportedZoneException, "Unsupported zone: D"):
d.holidays_for_year_zone_and_name(2017, "D", "Vacances de printemps")
with self.assertRaisesRegexp(
UnsupportedHolidayException, "Unknown holiday name: Foo"
):
d.holidays_for_year_zone_and_name(2017, "A", "Foo")
conv(d_tr)
#d_tr['day of week']=d_tr['datetime_perso'].dt.dayofweek
d_tr['timestamp'] = pd.to_datetime(d_tr.timestamp,
format='%Y-%m-%dT%H:%M:%S.%f')
## create season and rangeInYear
s = pd.to_datetime(pd.Series(d_tr['timestamp']))
d_tr['rangeInYear'] = s.dt.strftime('%j').astype(int)
## create jours working days
d_tr['is_business_day'] = d_tr['datetime_perso'].apply(
lambda e: int(business_day(e)))
# Is it an holiday for zone A, B or C?
d = SchoolHolidayDates()
d_tr['is_holiday'] = d_tr['datetime_perso'].apply(
lambda f: int(d.is_holiday(datetime.date(f))))
d_tr['season'] = d_tr['rangeInYear'].apply(lambda d: get_season(d))
d_tr = d_tr.drop(['rangeInYear', 'datetime_perso', 'date', 'timestamp'],
axis=1)
d_ready = pd.merge(d_tr, dataOut, on='ID', how='left')
## gerer les dummies et les variables num
train_new = d_ready[d_ready['consumption_1'].notnull()]
train_new = train_new.drop(['ID'], axis=1)
test_new = d_ready[d_ready['consumption_1'].isnull()]
test_new = test_new.drop(['consumption_1', 'consumption_2', 'ID'], axis=1)
train_new.shape
ts1.head()
ts2.head()
df.tail()
## create season and rangeInYear
s = pd.Series(dataInt['timestamp'])
s = pd.to_datetime(s)
dataInt['rangeInYear'] = s.dt.strftime('%j').astype(int)
#dataInt_Xy = dataInt_Xy.drop_duplicates(subset = ['rangeInYear']) # A ENLRVER
dataInt['season'] = dataInt['rangeInYear'].apply(lambda d : get_season(d))
## create jours working days
dataInt['is_business_day'] = dataInt['datetime_perso'].apply(lambda e : int(business_day(e)))
# Is it an holiday for zone A, B or C?
d = SchoolHolidayDates()
dataInt['is_holiday'] = dataInt['datetime_perso'].apply(lambda f : int(d.is_holiday(datetime.date(f))))
dataInt.groupby('month')['consumption_1'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'monthly consum 1')
dataInt.groupby('month')['consumption_2'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'monthly consum 2')
dataInt.groupby('day of week')['consumption_1'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'daily consum 1')
dataInt.groupby('day of week')['consumption_2'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'daily consum 2')
dataInt.groupby('hour')['consumption_1'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'hourly consum 1')
dataInt.groupby('hour')['consumption_2'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'hourly consum 2')
dataInt.groupby('is_business_day')['consumption_1'].mean().plot.bar(fontsize=14, figsize=(10,7), title= ' business day consum 1')
dataInt.groupby('is_business_day')['consumption_2'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'business day consum 2')
dataInt.groupby('is_holiday')['consumption_1'].mean().plot.bar(fontsize=14, figsize=(10,7), title= ' holiday day consum 1')
dataInt.groupby('is_holiday')['consumption_2'].mean().plot.bar(fontsize=14, figsize=(10,7), title= 'holiday day consum 2')
def home(request):
name = 'Home'
projects = Projet.objects.all().order_by('-created')
count = Projet.objects.all().count()
coffees = int(count * 12)
barre = BarreRaccourcie.objects.all()
cpu = int(psutil.cpu_percent())
disk_usage = int(psutil.disk_usage('/').percent)
cpu_freq = int(psutil.cpu_freq().current)
x = datetime.datetime.now()
year = int(x.strftime("%y"))
month = int(x.strftime("%m"))
day = int(x.strftime("%d"))
months = []
projects_months = []
onemonth = [1, 3, 5, 7, 8, 10, 12] #31 days month
zeromonth = [4, 6, 9, 11] #30 days month
strangemonth = 2 #28 or 29 days month (february)
for i in range(0, 7):
if month - (6 - i) < 1:
months.append(12 - (6 - month - i))
else:
months.append(month - (6 - i))
for project in projects:
projects_months.append(str(project.created)[5:7])
file = open("holidays.txt", "r+")
today = datetime.date(2000 + year, month, day)
date = file.readline()
if str(x)[:10] == str(date)[:10] and False:
is_holiday = file.readline()
daysbeforeholiday = int(file.readline())
else:
d = SchoolHolidayDates()
is_holiday = d.is_holiday_for_zone(
datetime.date(2000 + year, month, day), 'C')
daysbeforeholiday = 0
if is_holiday == False:
while is_holiday == False:
if month in onemonth and day == 31:
month = month + 1
day = 1
elif month in zeromonth and day == 30:
month = month + 1
day = 1
elif month == 2 and day == 28:
month = month + 1
day = 1
day = day + 1
is_holiday = d.is_holiday_for_zone(
datetime.date(2000 + year, month, day), 'C')
holiday_date = datetime.date(2000 + year, month, day)
delta = holiday_date - today
daysbeforeholiday = delta.days
is_holiday = False
open('holidays.txt', 'w').close()
file = open("holidays.txt", "r+")
file.write('%s\n' % datetime.datetime.now())
#file.write(datetime.datetime.now().strftime("%H:%M:%S") + os.linesep)
file.write('%s\n' % is_holiday)
file.write('%s\n' % daysbeforeholiday)
return render(
request, 'index.html', {
'projects': projects,
'count': count,
"barre": barre,
'cpu': cpu,
'disk': disk_usage,
'cpu_freq': cpu_freq,
'months': months,
'projects_months': projects_months,
'name': name,
'is_holiday': is_holiday,
'daysbeforeholiday': daysbeforeholiday,
'coffees': coffees
})
def __init__(self, filepath):
super(OperationsStatsTransformer, self).__init__(filepath)
self.bank_holidays = {}
self.school_holiday = SchoolHolidayDates()
def add_rows(data_df, new_data_df):
df = data_df.copy()
shd = SchoolHolidayDates()
df_tn = pd.read_csv(TOURN_FILE,
index_col=0,
parse_dates=True,
date_parser=parse_date,
sep=';')
for d in new_data_df.index:
print('Adding data for date:', d)
# print(new_data_df.index)
# Jour feries
fer = int(d.date() in JoursFeries.for_year(d.year).values())
# Vacances scolaires
vac = int(shd.is_holiday_for_zone(d.date(), 'C'))
# Tournament
tourn = 0
for tn_date in df_tn.index:
if d in pd.date_range(end=tn_date, periods=4):
tourn = 1
# Weather
t = d.isoformat()
url = f'https://api.darksky.net/forecast/{DARKSKY_API_KEY3}/48.854891,2.203673,{t}?exclude=hourly,currently&flags&lang=fr&units=si'
response = requests.get(url)
if response.status_code is not 200:
print('Http Error')
weather = response.json()
temp_max = get_attribute(weather, 'temperatureMax')
temp_min = get_attribute(weather, 'temperatureMin')
wind = get_attribute(weather, 'windGust')
rain = get_attribute(weather, 'precipProbability')
# add scale rain between 0 and 4 include
rain = add_scale_rain(rain)
# Competition a Saint-Cloud
nbPlay = new_data_df.loc[d, 'nbPlay']
# Restaurant open ?
open_res = new_data_df.loc[d, 'open']
# Number of covers
nbCov = new_data_df.loc[d, 'nbCov']
#print(nbCov)
#print(temp_min)
#print(type(wind))
df.loc[d] = pd.Series(
{
'fer': fer,
'vac': vac,
'tourn': tourn,
'tempMoy': round((temp_max + temp_min) / 2, 2),
'tempMax': temp_max,
'tempMin': temp_min,
'wind': wind,
'rain': rain, ##True if rain > 0.5 else False,
'nbPlay': nbPlay,
'open': open_res,
'nbCov': nbCov
},
name=d)
return df