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