gestioCOF/kfet/statistic.py

167 lines
5.1 KiB
Python
Raw Permalink Normal View History

from datetime import date, datetime, time, timedelta
from dateutil.relativedelta import relativedelta
from django.utils import timezone
2020-03-09 15:10:02 +01:00
KFET_WAKES_UP_AT = time(5, 0) # La K-Fêt ouvre à 5h (UTC) du matin
def kfet_day(year, month, day, start_at=KFET_WAKES_UP_AT):
2020-03-09 15:06:55 +01:00
"""Étant donné une date, renvoie un objet `datetime`
correspondant au début du 'jour K-Fêt' correspondant."""
return datetime.combine(date(year, month, day), start_at, tzinfo=timezone.utc)
def to_kfet_day(dt, start_at=KFET_WAKES_UP_AT):
2020-03-09 15:06:55 +01:00
"""
Retourne le 'jour K-Fêt' correspondant à un objet `datetime` donné
"""
kfet_dt = kfet_day(year=dt.year, month=dt.month, day=dt.day)
if dt.time() < start_at:
kfet_dt -= timedelta(days=1)
return kfet_dt
class Scale(object):
2020-03-09 15:06:55 +01:00
"""
Classe utilisée pour subdiviser un QuerySet (e.g. des opérations) sur
une échelle de temps donnée, avec un pas de temps fixe.
Cette échelle peut être spécifiée :
- par un début et une fin,
- par un début/une fin et un nombre de subdivisions.
2020-05-08 11:09:29 +02:00
Si le booléen `std_chunk` est activé, le début de la première subdivision
est généré via la fonction `get_chunk_start`.
2020-03-09 15:06:55 +01:00
"""
name = None
step = None
def __init__(self, n_steps=0, begin=None, end=None, last=False, std_chunk=True):
self.std_chunk = std_chunk
if last:
end = timezone.now()
if std_chunk:
if begin is not None:
begin = self.get_chunk_start(begin)
if end is not None:
end = self.do_step(self.get_chunk_start(end))
2020-09-16 19:19:29 +02:00
if begin is not None and n_steps:
self.begin = begin
self.end = self.do_step(self.begin, n_steps=n_steps)
2020-09-16 19:19:29 +02:00
elif end is not None and n_steps:
self.end = end
self.begin = self.do_step(self.end, n_steps=-n_steps)
elif begin is not None and end is not None:
self.begin = begin
self.end = end
else:
raise Exception(
"Two of these args must be specified: "
"n_steps, begin, end; "
"or use last and n_steps"
)
2020-03-09 16:09:12 +01:00
self._gen_datetimes()
@staticmethod
def by_name(name):
for cls in Scale.__subclasses__():
if cls.name == name:
return cls
return None
def __getitem__(self, i):
return self.datetimes[i], self.datetimes[i + 1]
def __len__(self):
return len(self.datetimes) - 1
def do_step(self, dt, n_steps=1):
return dt + self.step * n_steps
2020-03-09 16:09:12 +01:00
def _gen_datetimes(self):
datetimes = [self.begin]
tmp = self.begin
while tmp < self.end:
tmp = self.do_step(tmp)
datetimes.append(tmp)
2020-03-09 16:09:12 +01:00
self.datetimes = datetimes
def get_labels(self, label_fmt=None):
if label_fmt is None:
label_fmt = self.label_fmt
return [
begin.strftime(label_fmt.format(i=i, rev_i=len(self) - i))
for i, (begin, end) in enumerate(self)
]
def chunkify_qs(self, qs, field="at", aggregate=None):
2020-03-09 15:06:55 +01:00
"""
Découpe un queryset en subdivisions, avec agrégation optionnelle des résultats
NB : on pourrait faire ça en une requête, au détriment de la lisibilité...
"""
begin_f = "{}__gte".format(field)
end_f = "{}__lte".format(field)
chunks = [qs.filter(**{begin_f: begin, end_f: end}) for begin, end in self]
if aggregate is None:
return chunks
else:
return [chunk.aggregate(agg=aggregate)["agg"] or 0 for chunk in chunks]
class DayScale(Scale):
name = "day"
step = timedelta(days=1)
label_fmt = "%A"
@classmethod
def get_chunk_start(cls, dt):
return to_kfet_day(dt)
class WeekScale(Scale):
name = "week"
step = timedelta(days=7)
label_fmt = "%d %b."
@classmethod
2017-04-03 15:10:53 +02:00
def get_chunk_start(cls, dt):
dt_kfet = to_kfet_day(dt)
offset = timedelta(days=dt_kfet.weekday())
2017-04-03 15:10:53 +02:00
return dt_kfet - offset
class MonthScale(Scale):
name = "month"
step = relativedelta(months=1)
label_fmt = "%B"
@classmethod
def get_chunk_start(cls, dt):
return to_kfet_day(dt).replace(day=1)
2016-12-09 21:45:34 +01:00
2020-09-16 17:16:49 +02:00
SCALE_CLASS_CHOICES = ((cls.name, cls.name) for cls in Scale.__subclasses__())
SCALE_DICT = {cls.name: cls for cls in Scale.__subclasses__()}
def scale_url_params(scales_def):
2020-03-09 15:06:55 +01:00
"""
Convertit une spécification de scales en arguments GET utilisables par ScaleMixin.
La spécification est de la forme suivante :
2020-09-16 17:16:49 +02:00
- scales_def : liste de champs de la forme (label, scale, scale_args, default)
2020-03-09 15:06:55 +01:00
- scale_args : arguments à passer à Scale.__init__
2020-09-16 17:16:49 +02:00
- default : le graphe à montrer par défaut
2020-03-09 15:06:55 +01:00
"""
2016-12-09 21:45:34 +01:00
params_list = []
for label, cls, params, default in scales_def:
2020-09-16 17:16:49 +02:00
url_params = {"scale-name": cls.name}
url_params.update({"scale-" + key: value for key, value in params.items()})
params_list.append(dict(label=label, url_params=url_params, default=default))
2016-12-09 21:45:34 +01:00
return params_list