def _sub_distant_date(self, other): if self.year == other.year: if self.month == other.month: return timedelta(days=self.day - other.day) offset = ((self.year - 1600) // 400) * 400 offset_self = vanilla_date(self.year - offset, self.month, self.day) offset_other = vanilla_date(other.year - offset, other.month, other.day) return offset_self - offset_other
def _number_of_extra_leap_days(end, start=vanilla_date(200, 3, 1)): count = 0 for x in range(start.year, end.year + 1, 100): if not JulianCalendar._is_gregorian_leap_year(x): leap_day = vanilla_date(x, 2, 28) if start < leap_day and end > leap_day: count = count + 1 return count
def julian_to_gregorian(year, month, day): if day == 29 and month == 2 and is_julian_leap_year(year): d = vanilla_date(year, 2, 28) offset = _number_of_extra_leap_days(d) + 1 else: d = vanilla_date(year, month, day) offset = _number_of_extra_leap_days(d) d = d + timedelta(days=offset) return d
def date(self, year, month, day): self._check_year(year) if day == 29 and month == 2 and self._is_julian_leap_year(year): d = vanilla_date(year, 2, 28) offset = self._number_of_extra_leap_days(d) + 1 else: try: d = vanilla_date(year, month, day) except: d = DistantDate(year, month, day) offset = self._number_of_extra_leap_days(d) d = d + timedelta(days=offset) return self.from_date(d)
def iso_to_gregorian(year, week, weekday): _check_week(week) jan_8 = vanilla_date(year, 1, 8).isocalendar() offset = (week - jan_8[1]) * 7 + (weekday - jan_8[2]) try: d = vanilla_date(year, 1, 8) + timedelta(days=offset) except: d = OverflowDate(isocalendar=(year, week, weekday)) if d.isocalendar()[0] != year: raise ValueError( "Week number %d is invalid for ISO year %d." % (week, year) ) return d
def test_conversion_2(self): calendar = ProlepticJulianCalendar() d = calendar.date(9999, 9, 19) converted = d.convert_to(JulianDayNumber()) self.assertIsNotNone(converted) expected = DateWithCalendar(JulianDayNumber, vanilla_date(9999, 12, 1)) self.assertEqual(converted, expected)
def _bce_representation(n): count = 0 - n n_4_yr_periods = count // (365 * 4 + 1) remainder = count % (365 * 4 + 1) td = vanilla_date(8, 1, 1) - timedelta(days=remainder) year = td.year - 8 - 4 * n_4_yr_periods return (year, td.month, td.day)
def __add__(self, other): try: n = other.days td = other except: n = other td = timedelta(days=other) if n > number_of_days_in_400_gregorian_years: shifted_date = DistantDate(self.year + 400, self.month, self.day) shift = n - number_of_days_in_400_gregorian_years return shifted_date + shift offset = ((self.year - 1600) // 400) * 400 offset_self = vanilla_date(self.year - offset, self.month, self.day) offset_sum = offset_self + td return DistantDate(offset_sum.year + offset, offset_sum.month, offset_sum.day)
def month_string(n): d = vanilla_date(1995, n, 1) return d.strftime("%B")
def date(self, year, month, day): try: d = vanilla_date(year, month, day) except ValueError as e: raise InvalidDate(e) return self.from_date(d)
def _sub_vanilla_date(self, other): a = self - DistantDate(10000, 1, 1) b = vanilla_date(9999, 12, 31) - other x = a.days + b.days + 1 return timedelta(days=x)
def compare_date_and_number(self, year, month, day, number): vd = vanilla_date(year, month, day) d = self.calendar.from_date(vd) self.assertEqual(d.native_representation(), {'day_number': number})
def test_first_date(self): vd = vanilla_date(1, 1, 1) d = self.calendar.from_date(vd) self.assertEqual(str(d), 'Day 1721423 (Julian Day Number)')
def test_make_date(self): vd = vanilla_date(2010, 8, 1) d = self.calendar.from_date(vd) self.assertIsNotNone(d)
def test_round_trip_from_date_compare_vanilla_dates(self, dt): vd = dt.date() (y, m, d) = (vd.year, vd.month, vd.day) jdn = julian_to_julian_day_number(y, m, d) result = julian_day_number_to_julian(jdn) self.assertEqual(vd, vanilla_date(*result))
def get_calexicon_number(year, month, day): vd = vanilla_date(year, month, day) d = JulianDayNumber().from_date(vd) return d.native_representation()['day_number']
return d.native_representation()['day_number'] def compare(vd): year = vd.year month = vd.month day = vd.day navy_number = get_navy_day_number(year, month, day) calexicon_number = get_calexicon_number(year, month, day) logging.info("Navy: %d, Calexicon: %d." % (navy_number, calexicon_number)) if get_navy_day_number(year, month, day) != get_calexicon_number(year, month, day): return False else: return True def binary_search(start, end): logging.info("Searching for anomalies between %s and %s" % (start, end)) delta = (end - start).days half = int(delta / 2) if half == 0: return start, end mid = start + timedelta(days=half) if compare(mid) != compare(start): return binary_search(start, mid) elif compare(mid) != compare(end): return binary_search(mid, end) else: raise Exception("Couldn't properly subdivide the interval.") print binary_search(vanilla_date(1, 1, 1), vanilla_date(2013, 1, 1))