def __add__(self, other):
result = datetime.__add__(self, other)
if result is NotImplemented:
return result
return self.from_datetime(result)
def __add__(self, other):
# __add__ is only supported between datetime and timedelta
dt = datetime.__add__(self.replace(tzinfo=None), other)
# Required to support the case where tzinfo is None
dt = dt.replace(tzinfo=self.tzinfo)
return self.__class__.from_datetime(dt)
def __add__(self, arg):
if isinstance(arg, int) or isinstance(arg, long) or isinstance(
arg, float):
offset = arg
key = {"seconds": offset}
dt = datetime.__add__(self, timedelta(**key))
return self._fromDateTime(dt)
def __add__(self, addend):
"""Autonormalized addition of datetimes and timedeltas."""
added = _datetime.__add__(self, addend)
if added is NotImplemented:
return added
added = self.tzinfo.normalize(added)
return datetime.__from_datetime_with_tz(added)
def __add__(self, x):
"""
Aggiunge 'x' alla data; se x è di tipo numerico (int/float/long) viene
restituita la data maggiorata di 'x' giorni, altrimenti funzionalità
standard della somma di un datetime.datetime con altro (timdelta)
"""
if isinstance(x, (int, float, long)):
return _datetime(self.year, self.month, self.day, self.hour, self.minute, self.second)+timedelta(days=x)
d = dtime.__add__(self, x)
return _datetime(d.year, d.month, d.day, d.hour, d.minute, d.second)
def __add__(self, x):
"""
Aggiunge 'x' alla data; se x è di tipo numerico (int/float/long) viene
restituita la data maggiorata di 'x' giorni, altrimenti funzionalità
standard della somma di un datetime.datetime con altro (timdelta)
"""
if isinstance(x, (int, float, long)):
return _datetime(self.year, self.month, self.day, self.hour,
self.minute, self.second) + timedelta(days=x)
d = dtime.__add__(self, x)
return _datetime(d.year, d.month, d.day, d.hour, d.minute, d.second)
def __add__(self,t):
# if return value is <type 'timedelta'>
if t.__class__ == self.__class__ or \
t.__class__ == self.__ZERODATE[0].__class__:
return datetime.__add__(self,t)
# else (mydatetime-timedelta) should be mydatetime
else:
tmp = super(mydatetime,self).__add__(self,t)
return self.__class__(
tmp.year,tmp.month,tmp.day,tmp.hour,
tmp.minute,tmp.second,tmp.microsecond,tmp.tzinfo
)
def __add__(self, t):
d = self
if getattr(t, "years", 0) \
or getattr(t, "months", 0):
# January 31 + 1 month = February 28.
y = (d.month + t.months - 1) // 12 + d.year + t.years
m = (d.month + t.months + 0) % 12 or 12
r = monthrange(y, m)
d = date(y, m, min(d.day, r[1]), d.hour, d.minute, d.second,
d.microsecond)
d = datetime.__add__(d, t)
return date(d.year, d.month, d.day, d.hour, d.minute, d.second,
d.microsecond, self.format)
def __add__(self, other):
if isinstance(other, TimeDelta) or isinstance(other, timedelta):
# add values without sub-seconds, then deal with normalized
# sub-seconds separately.
# FIXME: this results in 2 ctor calls, make more efficient
whole_seconds_self = self.todatetime().replace(microsecond=0)
whole_seconds_other = timedelta(seconds=int(other.total_seconds()))
result = datetime.__add__(whole_seconds_self, whole_seconds_other)
(
frac_second_self,
frac_second_other,
result_frac_second_exponent,
) = util.normalize_frac_seconds(self, other)
result_frac_second = frac_second_self + frac_second_other
result_frac_second_multiplied = result_frac_second * (
10**result_frac_second_exponent)
if result_frac_second_multiplied >= 1:
result += timedelta(seconds=1)
result_frac_second -= 10**abs(result_frac_second_exponent)
elif result_frac_second_multiplied < 0:
result -= timedelta(seconds=1)
result_frac_second = (
10**abs(result_frac_second_exponent)) + result_frac_second
# FIXME: fold?
return DateTime(
year=result.year,
month=result.month,
day=result.day,
hour=result.hour,
minute=result.minute,
second=result.second,
tzinfo=result.tzinfo,
frac_second=result_frac_second,
frac_second_exponent=result_frac_second_exponent,
)
return NotImplemented
def __add__(self, other):
return datetimedict.fromdatetime(datetime.__add__(self, other))
def __add__(self, other):
return datetimedict.fromdatetime(datetime.__add__(self, other))
def _add_and_convert(a, b):
return T(datetime.__add__(a, b))
def __add__(self, time):
d = datetime.__add__(self, time)
return date(d.year, d.month, d.day, d.hour, d.minute, d.second,
d.microsecond, self.format)
def __add__(self, addend):
"""Autonormalized addition of datetimes and timedeltas."""
added = _datetime.__add__(self, addend)
added = self.tzinfo.normalize(added)
return datetime.__from_datetime_with_tz(added)
def __add__(a, b):
return T(datetime.__add__(a, b))
def __add__(self, other):
"""Add timedelta to gpsdatetime."""
crn = datetime.__add__(self.replace(tzinfo=None), other)
return self.copydt(crn, self.tzinfo)
def __add__(self, td):
newdt = datetime.__add__(self, td)
return ApexDatetime.from_iso(newdt.isoformat())
def __add__(self, time):
d = datetime.__add__(self, time)
return date(d.year, d.month, d.day, d.hour, d.minute, d.second, d.microsecond, self.format)
def __add__(self, arg):
if isinstance(arg, int) or isinstance(arg, long) or isinstance(arg, float):
offset = arg
key = {"seconds": offset}
dt = datetime.__add__(self, timedelta(**key))
return self._fromDateTime(dt)
def fromutc(self, dt): # type: (_D) -> _D
# Use the stdlib datetime's add method to avoid infinite recursion
return (datetime.__add__(dt, self._utcoffset)).replace(tzinfo=self)
def __add__(self, other):
"""Add timedelta to gpsdatetime."""
crn = datetime.__add__(self.replace(tzinfo=None), other)
return self.copydt(crn, self.tzinfo)
