def _strict_date(self, lean): if lean == EARLIEST: try: r = self.lower._strict_date(lean) if r is None: raise AttributeError return r except AttributeError: # it's a string, or no date. Result depends on the upper date upper = self.upper._strict_date(LATEST) return apply_delta(sub, upper, appsettings.DELTA_IF_UNKNOWN) else: try: r = self.upper._strict_date(lean) if r is None: raise AttributeError return r except AttributeError: # an 'unknown' or 'open' string - depends on the lower date if self.upper and (self.upper == "open" or self.upper.date == "open"): return dt_to_struct_time( date.today()) # it's still happening else: lower = self.lower._strict_date(EARLIEST) return apply_delta(add, lower, appsettings.DELTA_IF_UNKNOWN)
def test_dt_to_struct_time_for_datetime(self): now = datetime.now() st = convert.dt_to_struct_time(now) # Check equal year, month, day, hours, minutes, seconds self.assertEqual(st[:6], now.timetuple()[:6]) # Confirm 'extra' fields are set to defaults self.assertEqual(st[6:], (0, 0, -1))
def test_dt_to_struct_time_for_datetime(self): now = datetime.now() st = convert.dt_to_struct_time(now) # Check equal year, month, day, hours, minutes, seconds self.assertEqual(st[:6], now.timetuple()[:6]) # Confirm 'extra' fields are set to defaults self.assertEqual(st[6:], (0, 0, -1))
def __le__(self, other): if isinstance(other, EDTFObject): return self.lower_strict() <= other.lower_strict() elif isinstance(other, date): return self.lower_strict() <= dt_to_struct_time(other) elif isinstance(other, struct_time): return self.lower_strict() <= trim_struct_time(other) raise TypeError("can't compare %s with %s" % (type(self).__name__, type(other).__name__))
def __le__(self, other): if isinstance(other, EDTFObject): return self.lower_strict() <= other.lower_strict() elif isinstance(other, date): return self.lower_strict() <= dt_to_struct_time(other) elif isinstance(other, struct_time): return self.lower_strict() <= trim_struct_time(other) raise TypeError("can't compare %s with %s" % (type(self).__name__, type(other).__name__))
def test_dt_to_struct_time_for_date(self): today = date.today() st = convert.dt_to_struct_time(today) # Check equal year, month, day self.assertEqual(st[:3], today.timetuple()[:3]) # Confirm time fields are zeroed self.assertEqual(st[3:6], (0, 0, 0)) # Confirm 'extra' fields are set to defaults self.assertEqual(st[6:], (0, 0, -1))
def test_dt_to_struct_time_for_date(self): today = date.today() st = convert.dt_to_struct_time(today) # Check equal year, month, day self.assertEqual(st[:3], today.timetuple()[:3]) # Confirm time fields are zeroed self.assertEqual(st[3:6], (0, 0, 0)) # Confirm 'extra' fields are set to defaults self.assertEqual(st[6:], (0, 0, -1))
def _strict_date(self, lean): if lean == EARLIEST: try: r = self.lower._strict_date(lean) if r is None: raise AttributeError return r except AttributeError: # it's a string, or no date. Result depends on the upper date upper = self.upper._strict_date(LATEST) return apply_delta(sub, upper, appsettings.DELTA_IF_UNKNOWN) else: try: r = self.upper._strict_date(lean) if r is None: raise AttributeError return r except AttributeError: # an 'unknown' or 'open' string - depends on the lower date if self.upper and (self.upper == "open" or self.upper.date == "open"): return dt_to_struct_time(date.today()) # it's still happening else: lower = self.lower._strict_date(EARLIEST) return apply_delta(add, lower, appsettings.DELTA_IF_UNKNOWN)
def apply_delta(op, time_struct, delta): """ Apply a `relativedelta` to a `struct_time` data structure. `op` is an operator function, probably always `add` or `sub`tract to correspond to `a_date + a_delta` and `a_date - a_delta`. This function is required because we cannot use standard `datetime` module objects for conversion when the date/time is, or will become, outside the boundary years 1 AD to 9999 AD. """ if not delta: return time_struct # No work to do try: dt_result = op(datetime(*time_struct[:6]), delta) return dt_to_struct_time(dt_result) except (OverflowError, ValueError): # Year is not within supported 1 to 9999 AD range pass # Here we fake the year to one in the acceptable range to avoid having to # write our own date rolling logic # Adjust the year to be close to the 2000 millenium in 1,000 year # increments to try and retain accurate relative leap years actual_year = time_struct.tm_year millenium = int(float(actual_year) / 1000) millenium_diff = (2 - millenium) * 1000 adjusted_year = actual_year + millenium_diff # Apply delta to the date/time with adjusted year dt = datetime(*(adjusted_year,) + time_struct[1:6]) dt_result = op(dt, delta) # Convert result year back to its original millenium final_year = dt_result.year - millenium_diff return struct_time( (final_year,) + dt_result.timetuple()[1:6] + tuple(TIME_EMPTY_EXTRAS))
def apply_delta(op, time_struct, delta): """ Apply a `relativedelta` to a `struct_time` data structure. `op` is an operator function, probably always `add` or `sub`tract to correspond to `a_date + a_delta` and `a_date - a_delta`. This function is required because we cannot use standard `datetime` module objects for conversion when the date/time is, or will become, outside the boundary years 1 AD to 9999 AD. """ if not delta: return time_struct # No work to do try: dt_result = op(datetime(*time_struct[:6]), delta) return dt_to_struct_time(dt_result) except (OverflowError, ValueError): # Year is not within supported 1 to 9999 AD range pass # Here we fake the year to one in the acceptable range to avoid having to # write our own date rolling logic # Adjust the year to be close to the 2000 millenium in 1,000 year # increments to try and retain accurate relative leap years actual_year = time_struct.tm_year millenium = int(float(actual_year) / 1000) millenium_diff = (2 - millenium) * 1000 adjusted_year = actual_year + millenium_diff # Apply delta to the date/time with adjusted year dt = datetime(*(adjusted_year, ) + time_struct[1:6]) dt_result = op(dt, delta) # Convert result year back to its original millenium final_year = dt_result.year - millenium_diff return struct_time((final_year, ) + dt_result.timetuple()[1:6] + tuple(TIME_EMPTY_EXTRAS))
def _strict_date(self, lean): if self.date == "open": return dt_to_struct_time(date.today()) if self.date =="unknown": return None # depends on the other date return self.date._strict_date(lean)
def _strict_date(self, lean): if self.date == "open": return dt_to_struct_time(date.today()) if self.date == "unknown": return None # depends on the other date return self.date._strict_date(lean)