mirror of https://github.com/krateng/maloja.git
594 lines
16 KiB
Python
594 lines
16 KiB
Python
from datetime import timezone, timedelta, date, time, datetime
|
|
from calendar import monthrange
|
|
from os.path import commonprefix
|
|
import math
|
|
|
|
from .pkg_global.conf import malojaconfig
|
|
|
|
|
|
OFFSET = malojaconfig["TIMEZONE"]
|
|
TIMEZONE = timezone(timedelta(hours=OFFSET))
|
|
UTC = timezone.utc
|
|
|
|
FIRST_SCROBBLE = int(datetime.utcnow().replace(tzinfo=UTC).timestamp())
|
|
|
|
def register_scrobbletime(timestamp):
|
|
global FIRST_SCROBBLE
|
|
if timestamp < FIRST_SCROBBLE:
|
|
FIRST_SCROBBLE = int(timestamp)
|
|
|
|
|
|
|
|
|
|
|
|
# Object that represents a contextual time range relevant for displaying chart information
|
|
# there is no smaller unit than days
|
|
# also, two distinct objects could represent the same timerange
|
|
# (e.g. 2019/03 is not the same as 2019/03/01 - 2019/03/31)
|
|
|
|
|
|
# Generic Time Range
|
|
class MTRangeGeneric:
|
|
|
|
# despite the above, ranges that refer to the exact same real time range should evaluate as equal
|
|
def __eq__(self,other):
|
|
if not isinstance(other,MTRangeGeneric): return False
|
|
return (self.first_stamp() == other.first_stamp() and self.last_stamp() == other.last_stamp())
|
|
|
|
# gives a hashable object that uniquely identifies this time range
|
|
def hashable(self):
|
|
return self.first_stamp(),self.last_stamp()
|
|
|
|
|
|
def info(self):
|
|
return {**self.__json__(),"uri":self.uri()}
|
|
|
|
def __json__(self):
|
|
return {
|
|
"fromstring":self.fromstr(),
|
|
"tostr":self.tostr(),
|
|
"fromstamp":self.first_stamp(),
|
|
"tostamp":self.last_stamp(),
|
|
"description":self.desc()
|
|
}
|
|
|
|
def uri(self):
|
|
return "&".join(k + "=" + self.urikeys()[k] for k in self.urikeys())
|
|
|
|
def unlimited(self):
|
|
return False
|
|
|
|
def timestamps(self):
|
|
return (self.first_stamp(),self.last_stamp())
|
|
|
|
# whether we currently live or will ever again live in this range
|
|
def active(self):
|
|
return (self.last_stamp() > datetime.utcnow().timestamp())
|
|
|
|
def __contains__(self,timestamp):
|
|
return timestamp >= self.first_stamp() and timestamp <= self.last_stamp()
|
|
|
|
# Any range that has one defining base unit, whether week, year, etc.
|
|
class MTRangeSingular(MTRangeGeneric):
|
|
def fromstr(self):
|
|
return str(self)
|
|
def tostr(self):
|
|
return str(self)
|
|
|
|
def urikeys(self):
|
|
return {"in":str(self)}
|
|
|
|
|
|
# a range that is exactly a gregorian calendar unit (year, month or day)
|
|
class MTRangeGregorian(MTRangeSingular):
|
|
def __init__(self,*ls):
|
|
# in case we want to call with non-unpacked arguments
|
|
if isinstance(ls[0], (tuple, list)): ls = ls[0]
|
|
|
|
self.tup = tuple(ls)
|
|
self.precision = len(ls)
|
|
|
|
self.year = ls[0]
|
|
if len(ls)>1: self.month = ls[1]
|
|
if len(ls)>2: self.day = ls[2]
|
|
dt = [1970,1,1]
|
|
dt[:len(ls)] = ls
|
|
self.dateobject = date(dt[0],dt[1],dt[2])
|
|
|
|
def __str__(self):
|
|
return "/".join(str(part) for part in self.tup)
|
|
|
|
|
|
# whether we currently live or will ever again live in this range
|
|
# USE GENERIC SUPER METHOD INSTEAD
|
|
# def active(self):
|
|
# tod = datetime.datetime.utcnow().date()
|
|
# if tod.year > self.year: return False
|
|
# if self.precision == 1: return True
|
|
# if tod.year == self.year:
|
|
# if tod.month > self.month: return False
|
|
# if self.precision == 2: return True
|
|
# if tod.month == self.month and tod.day > self.day: return False
|
|
# return True
|
|
|
|
|
|
|
|
def desc(self,prefix=False):
|
|
prefixes = (None,'in ','in ','on ')
|
|
formats = ('%Y','%B','%d')
|
|
|
|
timeformat = ' '.join(reversed(formats[0:self.precision]))
|
|
|
|
if prefix: return prefixes[self.precision] + self.dateobject.strftime(timeformat)
|
|
else: return self.dateobject.strftime(timeformat)
|
|
|
|
|
|
def informal_desc(self):
|
|
# TODO: ignore year when same year etc
|
|
now = datetime.now(tz=timezone.utc)
|
|
today = date(now.year,now.month,now.day)
|
|
if self.precision == 3:
|
|
diff = (today - dateobject).days
|
|
if diff == 0: return "Today"
|
|
if diff == 1: return "Yesterday"
|
|
if diff < 7 and diff > 1: return timeobject.strftime("%A")
|
|
#elif len(t) == 2:
|
|
return self.desc()
|
|
|
|
# describes only the parts that are different than another range object
|
|
def contextual_desc(self,other):
|
|
# TODO: more elegant maybe?
|
|
if not isinstance(other, MTRangeGregorian): return self.desc()
|
|
|
|
relevant = self.desc().split(" ")
|
|
if self.year == other.year:
|
|
relevant.pop()
|
|
if self.precision > 1 and other.precision > 1 and self.month == other.month:
|
|
relevant.pop()
|
|
if self.precision > 2 and other.precision > 2 and self.day == other.day:
|
|
relevant.pop()
|
|
return " ".join(relevant)
|
|
|
|
|
|
# get objects with one higher precision that start or end this one
|
|
def start(self):
|
|
if self.precision in [1, 2]: return MTRangeGregorian(*self.tup,1)
|
|
return self
|
|
def end(self):
|
|
if self.precision == 1: return MTRangeGregorian(*self.tup,12)
|
|
elif self.precision == 2: return MTRangeGregorian(*self.tup,monthrange(self.year,self.month)[1])
|
|
return self
|
|
|
|
# get highest precision objects (day) that start or end this one
|
|
def first_day(self):
|
|
if self.precision == 3: return self
|
|
else: return self.start().first_day()
|
|
def last_day(self):
|
|
if self.precision == 3: return self
|
|
else: return self.end().last_day()
|
|
|
|
# get first or last timestamp of this range
|
|
def first_stamp(self):
|
|
day = self.first_day().dateobject
|
|
return int(datetime.combine(day,time(tzinfo=TIMEZONE)).timestamp())
|
|
def last_stamp(self):
|
|
day = self.last_day().dateobject + timedelta(days=1)
|
|
return int(datetime.combine(day,time(tzinfo=TIMEZONE)).timestamp() - 1)
|
|
|
|
# next range of equal length (not exactly same amount of days, but same precision level)
|
|
def next(self,step=1):
|
|
if abs(step) == math.inf: return None
|
|
if self.precision == 1:
|
|
return MTRangeGregorian(self.year + step)
|
|
elif self.precision == 2:
|
|
dt = [self.year,self.month]
|
|
dt[1] += step
|
|
while dt[1] > 12:
|
|
dt[1] -= 12
|
|
dt[0] += 1
|
|
while dt[1] < 1:
|
|
dt[1] += 12
|
|
dt[0] -= 1
|
|
return MTRangeGregorian(*dt)
|
|
elif self.precision == 3:
|
|
newdate = self.dateobject + timedelta(days=step)
|
|
return MTRangeGregorian(newdate.year,newdate.month,newdate.day)
|
|
def prev(self,step=1):
|
|
return self.next(step*(-1))
|
|
|
|
|
|
|
|
# a range that is exactly one christian week (starting on sunday)
|
|
class MTRangeWeek(MTRangeSingular):
|
|
def __init__(self,year=None,week=None):
|
|
|
|
# do this so we can construct the week with overflow (eg 2020/-3)
|
|
thisisoyear_firstday = date.fromchrcalendar(year,1,1)
|
|
self.firstday = thisisoyear_firstday + timedelta(days=7*(week-1))
|
|
self.firstday = date(self.firstday.year,self.firstday.month,self.firstday.day)
|
|
# for compatibility with pre python3.8 (https://bugs.python.org/issue32417)
|
|
|
|
|
|
self.lastday = self.firstday + timedelta(days=6)
|
|
|
|
# now get the actual year and week number (in case of overflow)
|
|
self.year,self.week,_ = self.firstday.chrcalendar()
|
|
|
|
|
|
|
|
def __str__(self):
|
|
return f"{self.year}/W{self.week}"
|
|
|
|
|
|
|
|
def desc(self,prefix=False):
|
|
if prefix:
|
|
return f"in Week {self.week} {self.year}"
|
|
else:
|
|
return f"Week {self.week} {self.year}"
|
|
|
|
def informal_desc(self):
|
|
now = datetime.now(tz=timezone.utc)
|
|
if now.year == self.year: return f"Week {self.week}"
|
|
return self.desc()
|
|
|
|
def contextual_desc(self,other):
|
|
if isinstance(other, MTRangeWeek) and other.year == self.year: return f"Week {self.week}"
|
|
return self.desc()
|
|
|
|
def start(self):
|
|
return self.first_day()
|
|
def end(self):
|
|
return self.last_day()
|
|
|
|
def first_day(self):
|
|
return MTRangeGregorian(self.firstday.year,self.firstday.month,self.firstday.day)
|
|
def last_day(self):
|
|
return MTRangeGregorian(self.lastday.year,self.lastday.month,self.lastday.day)
|
|
|
|
def first_stamp(self):
|
|
day = self.firstday
|
|
return int(datetime.combine(day,time(tzinfo=TIMEZONE)).timestamp())
|
|
def last_stamp(self):
|
|
day = self.lastday + timedelta(days=1)
|
|
return int(datetime.combine(day,time(tzinfo=TIMEZONE)).timestamp() - 1)
|
|
|
|
def next(self,step=1):
|
|
if abs(step) == math.inf: return None
|
|
return MTRangeWeek(self.year,self.week + step)
|
|
|
|
# a range that is defined by separate start and end
|
|
class MTRangeComposite(MTRangeGeneric):
|
|
|
|
def __init__(self,since=None,to=None):
|
|
since,to = time_pad(since,to)
|
|
self.since = since
|
|
self.to = to
|
|
if isinstance(self.since,MTRangeComposite): self.since = self.since.start()
|
|
if isinstance(self.to,MTRangeComposite): self.to = self.to.end()
|
|
|
|
def __str__(self):
|
|
return f"{self.since} - {self.to}"
|
|
def fromstr(self):
|
|
return str(self.since)
|
|
def tostr(self):
|
|
return str(self.to)
|
|
|
|
# whether we currently live or will ever again live in this range
|
|
def active(self):
|
|
if self.to is None: return True
|
|
return self.to.active()
|
|
|
|
def unlimited(self):
|
|
return (self.since is None and self.to is None)
|
|
|
|
def urikeys(self):
|
|
keys = {}
|
|
if self.since is not None: keys["since"] = str(self.since)
|
|
if self.to is not None: keys["to"] = str(self.to)
|
|
return keys
|
|
|
|
def desc(self,prefix=False):
|
|
if self.since is not None and self.to is not None:
|
|
if prefix:
|
|
return f"from {self.since.contextual_desc(self.to)} to {self.to.desc()}"
|
|
else:
|
|
return f"{self.since.contextual_desc(self.to)} to {self.to.desc()}"
|
|
if self.since is not None and self.to is None:
|
|
return f"since {self.since.desc()}"
|
|
if self.since is None and self.to is not None:
|
|
return f"until {self.to.desc()}"
|
|
if self.since is None and self.to is None:
|
|
return ""
|
|
|
|
def informal_desc(self):
|
|
# dis gonna be hard
|
|
return "Not implemented"
|
|
|
|
def start(self):
|
|
return self.since
|
|
|
|
def end(self):
|
|
return self.to
|
|
|
|
def first_day(self):
|
|
return self.since.first_day()
|
|
def last_day(self):
|
|
return self.to.last_day()
|
|
|
|
def first_stamp(self):
|
|
if self.since is None: return FIRST_SCROBBLE
|
|
else: return self.since.first_stamp()
|
|
def last_stamp(self):
|
|
#if self.to is None: return int(datetime.utcnow().replace(tzinfo=timezone.utc).timestamp())
|
|
if self.to is None: return today().last_stamp()
|
|
else: return self.to.last_stamp()
|
|
|
|
def next(self,step=1):
|
|
if abs(step) == math.inf: return None
|
|
if self.since is None or self.to is None: return None
|
|
# hop from the start element by one until we reach the end element
|
|
diff = 1
|
|
nxt = self.since
|
|
while (nxt != self.to):
|
|
diff += 1
|
|
nxt = nxt.next(step=1)
|
|
|
|
newstart = self.since.next(step=diff*step)
|
|
newend = self.to.next(step=diff*step)
|
|
|
|
return MTRangeComposite(newstart,newend)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def today():
|
|
tod = datetime.now(tz=TIMEZONE)
|
|
return MTRangeGregorian(tod.year,tod.month,tod.day)
|
|
def thisweek():
|
|
tod = datetime.now(tz=TIMEZONE)
|
|
tod = date(tod.year,tod.month,tod.day)
|
|
y,w,_ = tod.chrcalendar()
|
|
return MTRangeWeek(y,w)
|
|
def thismonth():
|
|
tod = datetime.now(tz=TIMEZONE)
|
|
return MTRangeGregorian(tod.year,tod.month)
|
|
def thisyear():
|
|
tod = datetime.now(tz=TIMEZONE)
|
|
return MTRangeGregorian(tod.year)
|
|
def alltime():
|
|
return MTRangeComposite(None,None)
|
|
|
|
|
|
|
|
|
|
|
|
def range_desc(r,**kwargs):
|
|
if r is None: return ""
|
|
return r.desc(**kwargs)
|
|
|
|
def time_str(t):
|
|
obj = time_fix(t)
|
|
return obj.desc()
|
|
|
|
|
|
currenttime_string_representations = (
|
|
(today,["today","day"]),
|
|
(thisweek,["week","thisweek"]),
|
|
(thismonth,["month","thismonth"]),
|
|
(thisyear,["year","thisyear"]),
|
|
(lambda:None,["alltime"])
|
|
)
|
|
month_string_representations = (
|
|
["january","jan"],
|
|
["february","feb"],
|
|
["march","mar"],
|
|
["april","apr"],
|
|
["may"],
|
|
["june","jun"],
|
|
["july","jul"],
|
|
["august","aug"],
|
|
["september","sep"],
|
|
["october","oct"],
|
|
["november","nov"],
|
|
["december","dec"],
|
|
)
|
|
weekday_string_representations = (
|
|
["sunday","sun"],
|
|
["monday","mon"],
|
|
["tuesday","tue"],
|
|
["wednesday","wed"],
|
|
["thursday","thu"],
|
|
["friday","fri"],
|
|
["saturday","sat"]
|
|
)
|
|
|
|
def get_last_instance(category,current,target,amount):
|
|
offset = (target-current) % -(amount)
|
|
return category().next(offset)
|
|
|
|
str_to_time_range = {
|
|
**{s:callable for callable,strlist in currenttime_string_representations for s in strlist},
|
|
**{s:(lambda i=index:get_last_instance(thismonth,datetime.utcnow().month,i,12)) for index,strlist in enumerate(month_string_representations,1) for s in strlist},
|
|
**{s:(lambda i=index:get_last_instance(today,datetime.utcnow().isoweekday()+1%7,i,7)) for index,strlist in enumerate(weekday_string_representations,1) for s in strlist}
|
|
}
|
|
|
|
|
|
# converts strings and stuff to objects
|
|
def time_fix(t):
|
|
if t is None or isinstance(t,MTRangeGeneric): return t
|
|
|
|
if isinstance(t, str):
|
|
t = t.lower()
|
|
|
|
if t in str_to_time_range:
|
|
return str_to_time_range[t]()
|
|
|
|
if isinstance(t,str): t = t.split("/")
|
|
#if isinstance(t,tuple): t = list(t)
|
|
try:
|
|
t = [int(p) for p in t]
|
|
return MTRangeGregorian(t[:3])
|
|
except Exception:
|
|
pass
|
|
|
|
if isinstance(t[1],str) and t[1].startswith("w"):
|
|
try:
|
|
year = int(t[0])
|
|
weeknum = int(t[1][1:])
|
|
return MTRangeWeek(year=year,week=weeknum)
|
|
except Exception:
|
|
raise
|
|
|
|
|
|
|
|
def get_range_object(since=None,to=None,within=None):
|
|
|
|
since,to,within = time_fix(since),time_fix(to),time_fix(within)
|
|
|
|
# check if we can simplify
|
|
if since is not None and to is not None and since == to: within = since
|
|
# TODO
|
|
|
|
if within is not None:
|
|
return within
|
|
else:
|
|
return MTRangeComposite(since,to)
|
|
|
|
|
|
|
|
|
|
# makes times the same precision level
|
|
def time_pad(f,t,full=False):
|
|
|
|
if f is None or t is None: return f,t
|
|
|
|
# week handling
|
|
if isinstance(f,MTRangeWeek) and isinstance(t,MTRangeWeek):
|
|
if full: return f.start(),t.end()
|
|
else: return f,t
|
|
if not isinstance(f,MTRangeWeek) and isinstance(t,MTRangeWeek):
|
|
t = t.end()
|
|
if isinstance(f,MTRangeWeek) and not isinstance(t,MTRangeWeek):
|
|
f = f.start()
|
|
|
|
while (f.precision < t.precision) or (full and f.precision < 3):
|
|
f = f.start()
|
|
while (f.precision > t.precision) or (full and t.precision < 3):
|
|
t = t.end()
|
|
|
|
return f,t
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
### TIMESTAMPS
|
|
|
|
def timestamp_desc(t,short=False):
|
|
|
|
timeobj = datetime.fromtimestamp(t,tz=TIMEZONE)
|
|
|
|
if not short: return timeobj.strftime(malojaconfig["TIME_FORMAT"])
|
|
|
|
difference = int(datetime.now().timestamp() - t)
|
|
|
|
thresholds = (
|
|
(10,"just now"),
|
|
(2*60,f"{difference} seconds ago"),
|
|
(2*60*60,f"{difference/60:.0f} minutes ago"),
|
|
(2*24*60*60,f"{difference/(60*60):.0f} hours ago"),
|
|
(5*24*60*60,f"{timeobj.strftime('%A')}"),
|
|
(31*24*60*60,f"{difference/(60*60*24):.0f} days ago"),
|
|
(12*31*24*60*60,f"{timeobj.strftime('%B')}"),
|
|
(math.inf,f"{timeobj.strftime('%Y')}")
|
|
)
|
|
|
|
for t,s in thresholds:
|
|
if difference < t: return s
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def time_stamps(since=None,to=None,within=None,range=None):
|
|
|
|
if range is None: range = get_range_object(since=since,to=to,within=within)
|
|
return range.first_stamp(),range.last_stamp()
|
|
|
|
|
|
|
|
def delimit_desc_p(d):
|
|
return delimit_desc(**d)
|
|
|
|
def delimit_desc(step="month",stepn=1,trail=1):
|
|
txt = ""
|
|
if stepn != 1: txt += str(stepn) + "-"
|
|
txt += {"year":"Yearly","month":"Monthly","week":"Weekly","day":"Daily"}[step.lower()]
|
|
if trail is math.inf: txt += " Cumulative"
|
|
elif trail != 1: txt += " Trailing" #we don't need all the info in the title
|
|
|
|
return txt
|
|
|
|
|
|
|
|
|
|
def day_from_timestamp(stamp):
|
|
dt = datetime.fromtimestamp(stamp,tz=TIMEZONE)
|
|
return MTRangeGregorian(dt.year,dt.month,dt.day)
|
|
def month_from_timestamp(stamp):
|
|
dt = datetime.fromtimestamp(stamp,tz=TIMEZONE)
|
|
return MTRangeGregorian(dt.year,dt.month)
|
|
def year_from_timestamp(stamp):
|
|
dt = datetime.fromtimestamp(stamp,tz=TIMEZONE)
|
|
return MTRangeGregorian(dt.year)
|
|
def week_from_timestamp(stamp):
|
|
dt = datetime.fromtimestamp(stamp,tz=TIMEZONE)
|
|
d = date(dt.year,dt.month,dt.day)
|
|
y,w,_ = d.chrcalendar()
|
|
return MTRangeWeek(y,w)
|
|
|
|
def from_timestamp(stamp,unit):
|
|
if unit == "day": return day_from_timestamp(stamp)
|
|
if unit == "week": return week_from_timestamp(stamp)
|
|
if unit == "month": return month_from_timestamp(stamp)
|
|
if unit == "year": return year_from_timestamp(stamp)
|
|
|
|
|
|
# since, to and within can accept old notations or objects. timerange can only be a new object.
|
|
def ranges(since=None,to=None,within=None,timerange=None,step="month",stepn=1,trail=1,max_=None):
|
|
|
|
(firstincluded,lastincluded) = time_stamps(since=since,to=to,within=within,range=timerange)
|
|
|
|
d_start = from_timestamp(firstincluded,step)
|
|
d_start = d_start.next(stepn-1) #last part of first included range
|
|
i = 0
|
|
current_end = d_start
|
|
current_start = current_end.next((stepn*trail-1)*-1)
|
|
#ranges = []
|
|
while current_end.first_stamp() < lastincluded and (max_ is None or i < max_):
|
|
|
|
|
|
if current_start == current_end:
|
|
yield current_start
|
|
#ranges.append(current_start)
|
|
else:
|
|
yield MTRangeComposite(current_start,current_end)
|
|
#ranges.append(MTRangeComposite(current_start,current_end))
|
|
current_end = current_end.next(stepn)
|
|
current_start = current_end.next((stepn*trail-1)*-1)
|
|
|
|
i += 1
|
|
|
|
#return ranges
|