chromium / external / code.launchpad.net / dateutil / 15fc1fa8c1e2c3d088e646d6d47ac9d25d902f95 / . / dateutil / relativedelta.py

""" | |

Copyright (c) 2003-2010 Gustavo Niemeyer <gustavo@niemeyer.net> | |

This module offers extensions to the standard python 2.3+ | |

datetime module. | |

""" | |

__author__ = "Gustavo Niemeyer <gustavo@niemeyer.net>" | |

__license__ = "Simplified BSD" | |

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 excelent | |

work done by M.-A. Lemburg in his mx.DateTime 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's two different ways to build a relativedelta instance. The | |

first one is passing it two date/datetime classes: | |

relativedelta(datetime1, datetime2) | |

And the other way is to use the following keyword arguments: | |

year, month, day, hour, minute, second, microsecond: | |

Absolute information. | |

years, months, weeks, days, hours, minutes, seconds, microseconds: | |

Relative information, may be negative. | |

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: | |

if (not isinstance(dt1, datetime.date)) or (not isinstance(dt2, datetime.date)): | |

raise TypeError("relativedelta only diffs datetime/date") | |

if not type(dt1) == type(dt2): #isinstance(dt1, type(dt2)): | |

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) | |

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 |