| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450 |
- # -*- coding: utf-8 -*-
- import datetime
- import calendar
- from six import integer_types
- __all__ = ["relativedelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
- class weekday(object):
- __slots__ = ["weekday", "n"]
- def __init__(self, weekday, n=None):
- self.weekday = weekday
- self.n = n
- def __call__(self, n):
- if n == self.n:
- return self
- else:
- return self.__class__(self.weekday, n)
- def __eq__(self, other):
- try:
- if self.weekday != other.weekday or self.n != other.n:
- return False
- except AttributeError:
- return False
- return True
- def __repr__(self):
- s = ("MO", "TU", "WE", "TH", "FR", "SA", "SU")[self.weekday]
- if not self.n:
- return s
- else:
- return "%s(%+d)" % (s, self.n)
- MO, TU, WE, TH, FR, SA, SU = weekdays = tuple([weekday(x) for x in range(7)])
- class relativedelta(object):
- """
- The relativedelta type is based on the specification of the excellent
- work done by M.-A. Lemburg in his
- `mx.DateTime <http://www.egenix.com/files/python/mxDateTime.html>`_ extension.
- However, notice that this type does *NOT* implement the same algorithm as
- his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.
- There are two different ways to build a relativedelta instance. The
- first one is passing it two date/datetime classes::
- relativedelta(datetime1, datetime2)
- The second one is passing it any number of the following keyword arguments::
- relativedelta(arg1=x,arg2=y,arg3=z...)
- year, month, day, hour, minute, second, microsecond:
- Absolute information (argument is singular); adding or subtracting a
- relativedelta with absolute information does not perform an aritmetic
- operation, but rather REPLACES the corresponding value in the
- original datetime with the value(s) in relativedelta.
- years, months, weeks, days, hours, minutes, seconds, microseconds:
- Relative information, may be negative (argument is plural); adding
- or subtracting a relativedelta with relative information performs
- the corresponding aritmetic operation on the original datetime value
- with the information in the relativedelta.
- weekday:
- One of the weekday instances (MO, TU, etc). These instances may
- receive a parameter N, specifying the Nth weekday, which could
- be positive or negative (like MO(+1) or MO(-2). Not specifying
- it is the same as specifying +1. You can also use an integer,
- where 0=MO.
- leapdays:
- Will add given days to the date found, if year is a leap
- year, and the date found is post 28 of february.
- yearday, nlyearday:
- Set the yearday or the non-leap year day (jump leap days).
- These are converted to day/month/leapdays information.
- Here is the behavior of operations with relativedelta:
- 1. Calculate the absolute year, using the 'year' argument, or the
- original datetime year, if the argument is not present.
- 2. Add the relative 'years' argument to the absolute year.
- 3. Do steps 1 and 2 for month/months.
- 4. Calculate the absolute day, using the 'day' argument, or the
- original datetime day, if the argument is not present. Then,
- subtract from the day until it fits in the year and month
- found after their operations.
- 5. Add the relative 'days' argument to the absolute day. Notice
- that the 'weeks' argument is multiplied by 7 and added to
- 'days'.
- 6. Do steps 1 and 2 for hour/hours, minute/minutes, second/seconds,
- microsecond/microseconds.
- 7. If the 'weekday' argument is present, calculate the weekday,
- with the given (wday, nth) tuple. wday is the index of the
- weekday (0-6, 0=Mon), and nth is the number of weeks to add
- forward or backward, depending on its signal. Notice that if
- the calculated date is already Monday, for example, using
- (0, 1) or (0, -1) won't change the day.
- """
- def __init__(self, dt1=None, dt2=None,
- years=0, months=0, days=0, leapdays=0, weeks=0,
- hours=0, minutes=0, seconds=0, microseconds=0,
- year=None, month=None, day=None, weekday=None,
- yearday=None, nlyearday=None,
- hour=None, minute=None, second=None, microsecond=None):
- if dt1 and dt2:
- # datetime is a subclass of date. So both must be date
- if not (isinstance(dt1, datetime.date) and
- isinstance(dt2, datetime.date)):
- raise TypeError("relativedelta only diffs datetime/date")
- # We allow two dates, or two datetimes, so we coerce them to be
- # of the same type
- if (isinstance(dt1, datetime.datetime) !=
- isinstance(dt2, datetime.datetime)):
- if not isinstance(dt1, datetime.datetime):
- dt1 = datetime.datetime.fromordinal(dt1.toordinal())
- elif not isinstance(dt2, datetime.datetime):
- dt2 = datetime.datetime.fromordinal(dt2.toordinal())
- self.years = 0
- self.months = 0
- self.days = 0
- self.leapdays = 0
- self.hours = 0
- self.minutes = 0
- self.seconds = 0
- self.microseconds = 0
- self.year = None
- self.month = None
- self.day = None
- self.weekday = None
- self.hour = None
- self.minute = None
- self.second = None
- self.microsecond = None
- self._has_time = 0
- months = (dt1.year*12+dt1.month)-(dt2.year*12+dt2.month)
- self._set_months(months)
- dtm = self.__radd__(dt2)
- if dt1 < dt2:
- while dt1 > dtm:
- months += 1
- self._set_months(months)
- dtm = self.__radd__(dt2)
- else:
- while dt1 < dtm:
- months -= 1
- self._set_months(months)
- dtm = self.__radd__(dt2)
- delta = dt1 - dtm
- self.seconds = delta.seconds+delta.days*86400
- self.microseconds = delta.microseconds
- else:
- self.years = years
- self.months = months
- self.days = days+weeks*7
- self.leapdays = leapdays
- self.hours = hours
- self.minutes = minutes
- self.seconds = seconds
- self.microseconds = microseconds
- self.year = year
- self.month = month
- self.day = day
- self.hour = hour
- self.minute = minute
- self.second = second
- self.microsecond = microsecond
- if isinstance(weekday, integer_types):
- self.weekday = weekdays[weekday]
- else:
- self.weekday = weekday
- yday = 0
- if nlyearday:
- yday = nlyearday
- elif yearday:
- yday = yearday
- if yearday > 59:
- self.leapdays = -1
- if yday:
- ydayidx = [31, 59, 90, 120, 151, 181, 212,
- 243, 273, 304, 334, 366]
- for idx, ydays in enumerate(ydayidx):
- if yday <= ydays:
- self.month = idx+1
- if idx == 0:
- self.day = yday
- else:
- self.day = yday-ydayidx[idx-1]
- break
- else:
- raise ValueError("invalid year day (%d)" % yday)
- self._fix()
- def _fix(self):
- if abs(self.microseconds) > 999999:
- s = self.microseconds//abs(self.microseconds)
- div, mod = divmod(self.microseconds*s, 1000000)
- self.microseconds = mod*s
- self.seconds += div*s
- if abs(self.seconds) > 59:
- s = self.seconds//abs(self.seconds)
- div, mod = divmod(self.seconds*s, 60)
- self.seconds = mod*s
- self.minutes += div*s
- if abs(self.minutes) > 59:
- s = self.minutes//abs(self.minutes)
- div, mod = divmod(self.minutes*s, 60)
- self.minutes = mod*s
- self.hours += div*s
- if abs(self.hours) > 23:
- s = self.hours//abs(self.hours)
- div, mod = divmod(self.hours*s, 24)
- self.hours = mod*s
- self.days += div*s
- if abs(self.months) > 11:
- s = self.months//abs(self.months)
- div, mod = divmod(self.months*s, 12)
- self.months = mod*s
- self.years += div*s
- if (self.hours or self.minutes or self.seconds or self.microseconds
- or self.hour is not None or self.minute is not None or
- self.second is not None or self.microsecond is not None):
- self._has_time = 1
- else:
- self._has_time = 0
- def _set_months(self, months):
- self.months = months
- if abs(self.months) > 11:
- s = self.months//abs(self.months)
- div, mod = divmod(self.months*s, 12)
- self.months = mod*s
- self.years = div*s
- else:
- self.years = 0
- def __add__(self, other):
- if isinstance(other, relativedelta):
- return relativedelta(years=other.years+self.years,
- months=other.months+self.months,
- days=other.days+self.days,
- hours=other.hours+self.hours,
- minutes=other.minutes+self.minutes,
- seconds=other.seconds+self.seconds,
- microseconds=(other.microseconds +
- self.microseconds),
- leapdays=other.leapdays or self.leapdays,
- year=other.year or self.year,
- month=other.month or self.month,
- day=other.day or self.day,
- weekday=other.weekday or self.weekday,
- hour=other.hour or self.hour,
- minute=other.minute or self.minute,
- second=other.second or self.second,
- microsecond=(other.microsecond or
- self.microsecond))
- if not isinstance(other, datetime.date):
- raise TypeError("unsupported type for add operation")
- elif self._has_time and not isinstance(other, datetime.datetime):
- other = datetime.datetime.fromordinal(other.toordinal())
- year = (self.year or other.year)+self.years
- month = self.month or other.month
- if self.months:
- assert 1 <= abs(self.months) <= 12
- month += self.months
- if month > 12:
- year += 1
- month -= 12
- elif month < 1:
- year -= 1
- month += 12
- day = min(calendar.monthrange(year, month)[1],
- self.day or other.day)
- repl = {"year": year, "month": month, "day": day}
- for attr in ["hour", "minute", "second", "microsecond"]:
- value = getattr(self, attr)
- if value is not None:
- repl[attr] = value
- days = self.days
- if self.leapdays and month > 2 and calendar.isleap(year):
- days += self.leapdays
- ret = (other.replace(**repl)
- + datetime.timedelta(days=days,
- hours=self.hours,
- minutes=self.minutes,
- seconds=self.seconds,
- microseconds=self.microseconds))
- if self.weekday:
- weekday, nth = self.weekday.weekday, self.weekday.n or 1
- jumpdays = (abs(nth)-1)*7
- if nth > 0:
- jumpdays += (7-ret.weekday()+weekday) % 7
- else:
- jumpdays += (ret.weekday()-weekday) % 7
- jumpdays *= -1
- ret += datetime.timedelta(days=jumpdays)
- return ret
- def __radd__(self, other):
- return self.__add__(other)
- def __rsub__(self, other):
- return self.__neg__().__radd__(other)
- def __sub__(self, other):
- if not isinstance(other, relativedelta):
- raise TypeError("unsupported type for sub operation")
- return relativedelta(years=self.years-other.years,
- months=self.months-other.months,
- days=self.days-other.days,
- hours=self.hours-other.hours,
- minutes=self.minutes-other.minutes,
- seconds=self.seconds-other.seconds,
- microseconds=self.microseconds-other.microseconds,
- leapdays=self.leapdays or other.leapdays,
- year=self.year or other.year,
- month=self.month or other.month,
- day=self.day or other.day,
- weekday=self.weekday or other.weekday,
- hour=self.hour or other.hour,
- minute=self.minute or other.minute,
- second=self.second or other.second,
- microsecond=self.microsecond or other.microsecond)
- def __neg__(self):
- return relativedelta(years=-self.years,
- months=-self.months,
- days=-self.days,
- hours=-self.hours,
- minutes=-self.minutes,
- seconds=-self.seconds,
- microseconds=-self.microseconds,
- leapdays=self.leapdays,
- year=self.year,
- month=self.month,
- day=self.day,
- weekday=self.weekday,
- hour=self.hour,
- minute=self.minute,
- second=self.second,
- microsecond=self.microsecond)
- def __bool__(self):
- return not (not self.years and
- not self.months and
- not self.days and
- not self.hours and
- not self.minutes and
- not self.seconds and
- not self.microseconds and
- not self.leapdays and
- self.year is None and
- self.month is None and
- self.day is None and
- self.weekday is None and
- self.hour is None and
- self.minute is None and
- self.second is None and
- self.microsecond is None)
- # Compatibility with Python 2.x
- __nonzero__ = __bool__
- def __mul__(self, other):
- f = float(other)
- return relativedelta(years=int(self.years*f),
- months=int(self.months*f),
- days=int(self.days*f),
- hours=int(self.hours*f),
- minutes=int(self.minutes*f),
- seconds=int(self.seconds*f),
- microseconds=int(self.microseconds*f),
- leapdays=self.leapdays,
- year=self.year,
- month=self.month,
- day=self.day,
- weekday=self.weekday,
- hour=self.hour,
- minute=self.minute,
- second=self.second,
- microsecond=self.microsecond)
- __rmul__ = __mul__
- def __eq__(self, other):
- if not isinstance(other, relativedelta):
- return False
- if self.weekday or other.weekday:
- if not self.weekday or not other.weekday:
- return False
- if self.weekday.weekday != other.weekday.weekday:
- return False
- n1, n2 = self.weekday.n, other.weekday.n
- if n1 != n2 and not ((not n1 or n1 == 1) and (not n2 or n2 == 1)):
- return False
- return (self.years == other.years and
- self.months == other.months and
- self.days == other.days and
- self.hours == other.hours and
- self.minutes == other.minutes and
- self.seconds == other.seconds and
- self.leapdays == other.leapdays and
- self.year == other.year and
- self.month == other.month and
- self.day == other.day and
- self.hour == other.hour and
- self.minute == other.minute and
- self.second == other.second and
- self.microsecond == other.microsecond)
- def __ne__(self, other):
- return not self.__eq__(other)
- def __div__(self, other):
- return self.__mul__(1/float(other))
- __truediv__ = __div__
- def __repr__(self):
- l = []
- for attr in ["years", "months", "days", "leapdays",
- "hours", "minutes", "seconds", "microseconds"]:
- value = getattr(self, attr)
- if value:
- l.append("%s=%+d" % (attr, value))
- for attr in ["year", "month", "day", "weekday",
- "hour", "minute", "second", "microsecond"]:
- value = getattr(self, attr)
- if value is not None:
- l.append("%s=%s" % (attr, repr(value)))
- return "%s(%s)" % (self.__class__.__name__, ", ".join(l))
- # vim:ts=4:sw=4:et
|