#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""Tests for `ged4py.date` module."""

import unittest

from ged4py.calendar import (
    CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate,
    CalendarDateVisitor
)
from ged4py.date import (
    DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated,
    DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod,
    DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes,
    DateValueVisitor
)


class TestDateVisitor(CalendarDateVisitor, DateValueVisitor):

    def visitGregorian(self, date):
        if not isinstance(date, GregorianDate):
            raise TypeError(str(type(date)))
        return ("gregorian", date)

    def visitJulian(self, date):
        if not isinstance(date, JulianDate):
            raise TypeError(str(type(date)))
        return ("julian", date)

    def visitHebrew(self, date):
        if not isinstance(date, HebrewDate):
            raise TypeError(str(type(date)))
        return ("hebrew", date)

    def visitFrench(self, date):
        if not isinstance(date, FrenchDate):
            raise TypeError(str(type(date)))
        return ("french", date)

    def visitSimple(self, date):
        if not isinstance(date, DateValueSimple):
            raise TypeError(str(type(date)))
        return ("simple", date.date)

    def visitPeriod(self, date):
        if not isinstance(date, DateValuePeriod):
            raise TypeError(str(type(date)))
        return ("period", date.date1, date.date2)

    def visitFrom(self, date):
        if not isinstance(date, DateValueFrom):
            raise TypeError(str(type(date)))
        return ("from", date.date)

    def visitTo(self, date):
        if not isinstance(date, DateValueTo):
            raise TypeError(str(type(date)))
        return ("to", date.date)

    def visitRange(self, date):
        if not isinstance(date, DateValueRange):
            raise TypeError(str(type(date)))
        return ("range", date.date1, date.date2)

    def visitBefore(self, date):
        if not isinstance(date, DateValueBefore):
            raise TypeError(str(type(date)))
        return ("before", date.date)

    def visitAfter(self, date):
        if not isinstance(date, DateValueAfter):
            raise TypeError(str(type(date)))
        return ("after", date.date)

    def visitAbout(self, date):
        if not isinstance(date, DateValueAbout):
            raise TypeError(str(type(date)))
        return ("about", date.date)

    def visitCalculated(self, date):
        if not isinstance(date, DateValueCalculated):
            raise TypeError(str(type(date)))
        return ("calculated", date.date)

    def visitEstimated(self, date):
        if not isinstance(date, DateValueEstimated):
            raise TypeError(str(type(date)))
        return ("estimated", date.date)

    def visitInterpreted(self, date):
        if not isinstance(date, DateValueInterpreted):
            raise TypeError(str(type(date)))
        return ("interpreted", date.date, date.phrase)

    def visitPhrase(self, date):
        if not isinstance(date, DateValuePhrase):
            raise TypeError(str(type(date)))
        return ("phrase", date.phrase)


class TestDetailDate(unittest.TestCase):
    """Tests for `ged4py.date` module."""

    def test_001_cal_date(self):
        """Test date.CalendarDate class."""

        date = GregorianDate(2017, "OCT", 9)
        self.assertEqual(date.year, 2017)
        self.assertIsNone(date.dual_year)
        self.assertFalse(date.bc)
        self.assertEqual(date.year_str, "2017")
        self.assertEqual(date.month, "OCT")
        self.assertEqual(date.month_num, 10)
        self.assertEqual(date.day, 9)
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = GregorianDate(2017, "OCT", bc=True)
        self.assertEqual(date.year, 2017)
        self.assertIsNone(date.dual_year)
        self.assertTrue(date.bc)
        self.assertEqual(date.year_str, "2017 B.C.")
        self.assertEqual(date.month, "OCT")
        self.assertEqual(date.month_num, 10)
        self.assertIsNone(date.day)
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = GregorianDate(1699, "FEB", dual_year=1700)
        self.assertEqual(date.year, 1699)
        self.assertEqual(date.dual_year, 1700)
        self.assertFalse(date.bc)
        self.assertEqual(date.year_str, "1699/00")
        self.assertEqual(date.month, "FEB")
        self.assertEqual(date.month_num, 2)
        self.assertIsNone(date.day)
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = HebrewDate(5000)
        self.assertEqual(date.year, 5000)
        self.assertFalse(date.bc)
        self.assertEqual(date.year_str, "5000")
        self.assertIsNone(date.month)
        self.assertIsNone(date.month_num)
        self.assertIsNone(date.day)
        self.assertEqual(date.calendar, CalendarType.HEBREW)

        date = FrenchDate(1, "FRUC", 1)
        self.assertEqual(date.year, 1)
        self.assertFalse(date.bc)
        self.assertEqual(date.year_str, "1")
        self.assertEqual(date.month, "FRUC")
        self.assertEqual(date.month_num, 12)
        self.assertEqual(date.day, 1)
        self.assertEqual(date.calendar, CalendarType.FRENCH_R)

        date = JulianDate(5, "JAN", bc=True)
        self.assertEqual(date.year, 5)
        self.assertTrue(date.bc)
        self.assertEqual(date.year_str, "5 B.C.")
        self.assertEqual(date.month, "JAN")
        self.assertEqual(date.month_num, 1)
        self.assertIsNone(date.day)
        self.assertEqual(date.calendar, CalendarType.JULIAN)

    def test_002_cal_date_key(self):
        """Test date.CalendarDate class."""

        date = GregorianDate(2017, "OCT", 9)
        self.assertEqual(date.key(), (2458035.5, 0))

        date = GregorianDate(1699, "FEB", 1, dual_year=1700)
        self.assertEqual(date.key(), (2342003.5, 0))

        date = FrenchDate(2017, "VENT", bc=True)
        self.assertEqual(date.key(), (1638959.5, 1))

        date = HebrewDate(2017, "TSH", 22)
        self.assertEqual(date.key(), (1084542.5, 0))

        date = JulianDate(1000)
        self.assertEqual(date.key(), (2086672.5, 1))

    def test_003_cal_date_cmp(self):
        """Test date.CalendarDate class."""

        self.assertTrue(GregorianDate(2016, "JAN", 1) < GregorianDate(2017, "JAN", 1))
        self.assertTrue(GregorianDate(2017, "JAN", 1) < GregorianDate(2017, "FEB", 1))
        self.assertTrue(GregorianDate(2017, "JAN", 1) < GregorianDate(2017, "JAN", 2))

        self.assertTrue(GregorianDate(2017, "JAN", 1) <= GregorianDate(2017, "JAN", 2))
        self.assertTrue(GregorianDate(2017, "JAN", 2) > GregorianDate(2017, "JAN", 1))
        self.assertTrue(GregorianDate(2017, "JAN", 2) >= GregorianDate(2017, "JAN", 1))
        self.assertTrue(GregorianDate(2017, "JAN", 1) == GregorianDate(2017, "JAN", 1))
        self.assertTrue(GregorianDate(2017, "JAN", 1) != GregorianDate(2017, "JAN", 2))

        # missing day compares as "past" the last day of month, but before next month
        self.assertTrue(GregorianDate(2017, "JAN") > GregorianDate(2017, "JAN", 31))
        self.assertTrue(GregorianDate(2017, "JAN") < GregorianDate(2017, "FEB", 1))
        # missing month compares as "past" the last day of year, but before next year
        self.assertTrue(GregorianDate(2017) > GregorianDate(2017, "DEC", 31))
        self.assertTrue(GregorianDate(2017) < GregorianDate(2018, "JAN", 1))

        # dual date
        self.assertTrue(GregorianDate(1700, "JAN", 1) == GregorianDate(1699, "JAN", 1, dual_year=1700))

        # compare Gregorian and Julian dates
        self.assertTrue(GregorianDate(1582, "OCT", 15) == JulianDate(1582, "OCT", 5))
        self.assertTrue(GregorianDate(1582, "OCT", 16) > JulianDate(1582, "OCT", 5))
        self.assertTrue(JulianDate(1582, "OCT", 6) > GregorianDate(1582, "OCT", 15))
        self.assertTrue(GregorianDate(2000, "JAN", 14) == JulianDate(2000, "JAN", 1))

        # compare Gregorian and French dates
        self.assertTrue(GregorianDate(1792, "SEP", 22) == FrenchDate(1, "VEND", 1))
        self.assertTrue(GregorianDate(1792, "SEP", 23) > FrenchDate(1, "VEND", 1))
        self.assertTrue(FrenchDate(1, "VEND", 2) > GregorianDate(1792, "SEP", 22))
        self.assertTrue(GregorianDate(2020, "SEP", 21) == FrenchDate(228, "COMP", 5))

        # compare Gregorian and Hebrew dates
        self.assertTrue(GregorianDate(2020, "JAN", 1) == HebrewDate(5780, "SVN", 4))

    def test_004_cal_date_str(self):
        """Test date.CalendarDate class."""
        date = GregorianDate(2017, "OCT", 9)
        self.assertEqual(str(date), "9 OCT 2017")

        date = GregorianDate(2017, "OCT", bc=True)
        self.assertEqual(str(date), "OCT 2017 B.C.")

        date = GregorianDate(1699, "JAN", 1, dual_year=1700)
        self.assertEqual(str(date), "1 JAN 1699/00")

        date = HebrewDate(5000)
        self.assertEqual(str(date), "@#DHEBREW@ 5000")

        date = FrenchDate(1, "VEND", 1)
        self.assertEqual(str(date), "@#DFRENCH R@ 1 VEND 1")

        date = JulianDate(1582, "OCT", 5)
        self.assertEqual(str(date), "@#DJULIAN@ 5 OCT 1582")

    def test_005_cal_date_parse(self):
        """Test date.CalendarDate.parse method."""

        date = CalendarDate.parse("31 MAY 2020")
        self.assertIsInstance(date, GregorianDate)
        self.assertEqual(date.year, 2020)
        self.assertIsNone(date.dual_year)
        self.assertFalse(date.bc)
        self.assertEqual(date.month, "MAY")
        self.assertEqual(date.month_num, 5)
        self.assertEqual(date.day, 31)
        self.assertEqual(date.original, "31 MAY 2020")
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = CalendarDate.parse("@#DGREGORIAN@ 10 MAR 1698/99")
        self.assertIsInstance(date, GregorianDate)
        self.assertEqual(date.year, 1698)
        self.assertEqual(date.dual_year, 1699)
        self.assertFalse(date.bc)
        self.assertEqual(date.month, "MAR")
        self.assertEqual(date.month_num, 3)
        self.assertEqual(date.day, 10)
        self.assertEqual(date.original, "@#DGREGORIAN@ 10 MAR 1698/99")
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = CalendarDate.parse("10 MAR 1699/00")
        self.assertIsInstance(date, GregorianDate)
        self.assertEqual(date.year, 1699)
        self.assertEqual(date.dual_year, 1700)
        self.assertEqual(date.original, "10 MAR 1699/00")
        self.assertEqual(date.calendar, CalendarType.GREGORIAN)

        date = CalendarDate.parse("@#DJULIAN@ 100 B.C.")
        self.assertIsInstance(date, JulianDate)
        self.assertEqual(date.year, 100)
        self.assertTrue(date.bc)
        self.assertIsNone(date.month)
        self.assertIsNone(date.month_num)
        self.assertIsNone(date.day)
        self.assertEqual(date.original, "@#DJULIAN@ 100 B.C.")
        self.assertEqual(date.calendar, CalendarType.JULIAN)

        date = CalendarDate.parse("@#DFRENCH R@ 15 GERM 0001")
        self.assertIsInstance(date, FrenchDate)
        self.assertEqual(date.year, 1)
        self.assertFalse(date.bc)
        self.assertEqual(date.month, "GERM")
        self.assertEqual(date.month_num, 7)
        self.assertEqual(date.day, 15)
        self.assertEqual(date.original, "@#DFRENCH R@ 15 GERM 0001")
        self.assertEqual(date.calendar, CalendarType.FRENCH_R)

        date = CalendarDate.parse("@#DHEBREW@ 7 NSN 5000")
        self.assertIsInstance(date, HebrewDate)
        self.assertEqual(date.year, 5000)
        self.assertFalse(date.bc)
        self.assertEqual(date.month, "NSN")
        self.assertEqual(date.month_num, 8)
        self.assertEqual(date.day, 7)
        self.assertEqual(date.original, "@#DHEBREW@ 7 NSN 5000")
        self.assertEqual(date.calendar, CalendarType.HEBREW)

        # cannot handle ROMAN
        with self.assertRaises(ValueError):
            date = CalendarDate.parse("@#DROMAN@ 2020")

        # cannot handle UNKNOWN
        with self.assertRaises(ValueError):
            date = CalendarDate.parse("@#DUNKNOWN@ 2020")

        # dual year only works for GREGORIAN
        with self.assertRaises(ValueError):
            date = CalendarDate.parse("@#DJULIAN@ 2020/21")

        # cannot parse nonsense
        with self.assertRaises(ValueError):
            date = CalendarDate.parse("start of time")

    def test_006_cal_date_visitor(self):
        """Test date.CalendarDate.accept method."""

        visitor = TestDateVisitor()

        date = GregorianDate(2017, "OCT", 9)
        value = date.accept(visitor)
        self.assertEqual(value, ("gregorian", date))

        date = HebrewDate(5000)
        value = date.accept(visitor)
        self.assertEqual(value, ("hebrew", date))

        date = FrenchDate(1, "VEND", 1)
        value = date.accept(visitor)
        self.assertEqual(value, ("french", date))

        date = JulianDate(1582, "OCT", 5)
        value = date.accept(visitor)
        self.assertEqual(value, ("julian", date))

    def test_007_cal_date_hash(self):
        """Test date.CalendarDate hash."""

        self.assertEqual(hash(GregorianDate(2017, "OCT", 9)),
                         hash(GregorianDate(2017, "OCT", 9)))
        self.assertEqual(hash(GregorianDate(2017, "OCT", 9, bc=True)),
                         hash(GregorianDate(2017, "OCT", 9, bc=True)))
        self.assertEqual(hash(FrenchDate(1, "VEND", 1)),
                         hash(FrenchDate(1, "VEND", 1)))
        self.assertEqual(hash(FrenchDate(1)),
                         hash(FrenchDate(1)))

    def test_010_date_no_date(self):
        """Test date.DateValue class."""

        date = DateValue.parse("not a date")
        self.assertIsInstance(date, DateValuePhrase)
        self.assertEqual(date.kind, DateValueTypes.PHRASE)
        self.assertEqual(date.phrase, "not a date")
        self.assertEqual(str(date), "(not a date)")

    def test_012_date_parse_period(self):
        """Test date.DateValue class."""

        date = DateValue.parse("FROM 1967")
        self.assertIsInstance(date, DateValueFrom)
        self.assertEqual(date.kind, DateValueTypes.FROM)
        self.assertEqual(date.date, GregorianDate(1967))
        self.assertEqual(str(date), "FROM 1967")

        date = DateValue.parse("TO 1 JAN 2017")
        self.assertIsInstance(date, DateValueTo)
        self.assertEqual(date.kind, DateValueTypes.TO)
        self.assertEqual(date.date, GregorianDate(2017, "JAN", 1))
        self.assertEqual(str(date), "TO 1 JAN 2017")

        date = DateValue.parse("FROM 1920 TO 2000")
        self.assertIsInstance(date, DateValuePeriod)
        self.assertEqual(date.kind, DateValueTypes.PERIOD)
        self.assertEqual(date.date1, GregorianDate(1920))
        self.assertEqual(date.date2, GregorianDate(2000))
        self.assertEqual(str(date), "FROM 1920 TO 2000")

        date = DateValue.parse("from mar 1920 to 1 apr 2000")
        self.assertIsInstance(date, DateValuePeriod)
        self.assertEqual(date.kind, DateValueTypes.PERIOD)
        self.assertEqual(date.date1, GregorianDate(1920, "MAR"))
        self.assertEqual(date.date2, GregorianDate(2000, "APR", 1))
        self.assertEqual(str(date), "FROM MAR 1920 TO 1 APR 2000")

    def test_013_date_parse_range(self):
        """Test date.DateValue class."""

        date = DateValue.parse("BEF 1967B.C.")
        self.assertIsInstance(date, DateValueBefore)
        self.assertEqual(date.kind, DateValueTypes.BEFORE)
        self.assertEqual(date.date, GregorianDate(1967, bc=True))
        self.assertEqual(str(date), "BEFORE 1967 B.C.")

        date = DateValue.parse("AFT 1 JAN 2017")
        self.assertIsInstance(date, DateValueAfter)
        self.assertEqual(date.kind, DateValueTypes.AFTER)
        self.assertEqual(date.date, GregorianDate(2017, "JAN", 1))
        self.assertEqual(str(date), "AFTER 1 JAN 2017")

        date = DateValue.parse("BET @#DJULIAN@ 1600 AND 2000")
        self.assertIsInstance(date, DateValueRange)
        self.assertEqual(date.kind, DateValueTypes.RANGE)
        self.assertEqual(date.date1, JulianDate(1600))
        self.assertEqual(date.date2, GregorianDate(2000))
        self.assertEqual(str(date), "BETWEEN @#DJULIAN@ 1600 AND 2000")

        date = DateValue.parse("bet mar 1920 and apr 2000")
        self.assertIsInstance(date, DateValueRange)
        self.assertEqual(date.kind, DateValueTypes.RANGE)
        self.assertEqual(date.date1, GregorianDate(1920, "MAR"))
        self.assertEqual(date.date2, GregorianDate(2000, "APR"))
        self.assertEqual(str(date), "BETWEEN MAR 1920 AND APR 2000")

    def test_014_date_parse_approx(self):
        """Test date.DateValue class."""

        dates = {"500 B.C.": GregorianDate(500, bc=True),
                 "JAN 2017": GregorianDate(2017, "JAN"),
                 "31 JAN 2017": GregorianDate(2017, "JAN", 31)}

        approx = [
            ("ABT", "ABOUT", DateValueAbout, DateValueTypes.ABOUT),
            ("CAL", "CALCULATED", DateValueCalculated, DateValueTypes.CALCULATED),
            ("EST", "ESTIMATED", DateValueEstimated, DateValueTypes.ESTIMATED)
        ]

        for appr, fmt, klass, typeEnum in approx:
            for datestr, value in dates.items():
                date = DateValue.parse(appr + " " + datestr)
                self.assertIsInstance(date, klass)
                self.assertEqual(date.kind, typeEnum)
                self.assertEqual(str(date), fmt + " " + datestr)
                self.assertEqual(date.date, value)

    def test_015_date_parse_phrase(self):
        """Test date.DateValue class."""

        date = DateValue.parse("(some phrase)")
        self.assertIsInstance(date, DateValuePhrase)
        self.assertEqual(date.kind, DateValueTypes.PHRASE)
        self.assertEqual(date.phrase, "some phrase")

        date = DateValue.parse("INT 1967 B.C. (some phrase)")
        self.assertIsInstance(date, DateValueInterpreted)
        self.assertEqual(date.kind, DateValueTypes.INTERPRETED)
        self.assertEqual(date.date, GregorianDate(1967, bc=True))
        self.assertEqual(date.phrase, "some phrase")
        self.assertEqual(str(date), "INTERPRETED 1967 B.C. (some phrase)")

        date = DateValue.parse("INT @#DGREGORIAN@ 1 JAN 2017 (some phrase)")
        self.assertIsInstance(date, DateValueInterpreted)
        self.assertEqual(date.kind, DateValueTypes.INTERPRETED)
        self.assertEqual(date.date, GregorianDate(2017, "JAN", 1))
        self.assertEqual(date.phrase, "some phrase")
        self.assertEqual(str(date), "INTERPRETED 1 JAN 2017 (some phrase)")

    def test_016_date_parse_simple(self):
        """Test date.DateValue class."""

        date = DateValue.parse("1967 B.C.")
        self.assertIsInstance(date, DateValueSimple)
        self.assertEqual(date.kind, DateValueTypes.SIMPLE)
        self.assertEqual(date.date, GregorianDate(1967, bc=True))
        self.assertEqual(str(date), "1967 B.C.")

        date = DateValue.parse("@#DGREGORIAN@ 1 JAN 2017")
        self.assertIsInstance(date, DateValueSimple)
        self.assertEqual(date.kind, DateValueTypes.SIMPLE)
        self.assertEqual(date.date, GregorianDate(2017, "JAN", 1))
        self.assertEqual(str(date), "1 JAN 2017")

    def test_017_date_cmp(self):
        """Test date.Date class."""

        dv = DateValue.parse("2016")
        self.assertIsInstance(dv.key(), tuple)
        self.assertEqual(dv.key(), (GregorianDate(2016), GregorianDate(2016)))

        dv = DateValue.parse("31 DEC 2000")
        self.assertIsInstance(dv.key(), tuple)
        self.assertEqual(dv.key(), (GregorianDate(2000, "DEC", 31), GregorianDate(2000, "DEC", 31)))

        dv = DateValue.parse("BET 31 DEC 2000 AND 1 JAN 2001")
        self.assertIsInstance(dv.key(), tuple)
        self.assertEqual(dv.key(), (GregorianDate(2000, "DEC", 31), GregorianDate(2001, "JAN", 1)))

        # order of dates is messed up
        dv = DateValue.parse("BET 31 DEC 2000 AND 1 JAN 2000")
        self.assertIsInstance(dv.key(), tuple)
        self.assertEqual(dv.key(), (GregorianDate(2000, "DEC", 31), GregorianDate(2000, "JAN", 1)))

        self.assertTrue(DateValue.parse("2016") < DateValue.parse("2017"))
        self.assertTrue(DateValue.parse("2 JAN 2016") > DateValue.parse("1 JAN 2016"))
        self.assertTrue(DateValue.parse("BET 1900 AND 2000") < DateValue.parse("FROM 1920 TO 1999"))

        # comparing simple date with range
        self.assertTrue(DateValue.parse("1 JAN 2000") > DateValue.parse("BET 1 JAN 1999 AND 1 JAN 2000"))
        self.assertNotEqual(DateValue.parse("1 JAN 2000"), DateValue.parse("BET 1 JAN 2000 AND 1 JAN 2001"))
        self.assertTrue(DateValue.parse("1 JAN 2000") < DateValue.parse("BET 1 JAN 2000 AND 1 JAN 2001"))
        self.assertTrue(DateValue.parse("1 JAN 2000") > DateValue.parse("BEF 1 JAN 2000"))
        self.assertTrue(DateValue.parse("1 JAN 2000") > DateValue.parse("TO 1 JAN 2000"))
        self.assertTrue(DateValue.parse("1 JAN 2000") < DateValue.parse("AFT 1 JAN 2000"))
        self.assertTrue(DateValue.parse("1 JAN 2000") < DateValue.parse("FROM 1 JAN 2000"))

        # comparing ranges
        self.assertEqual(DateValue.parse("FROM 1 JAN 2000 TO 1 JAN 2001"),
                         DateValue.parse("BET 1 JAN 2000 AND 1 JAN 2001"))
        self.assertTrue(DateValue.parse("FROM 1 JAN 1999 TO 1 JAN 2001") <
                        DateValue.parse("BET 1 JAN 2000 AND 1 JAN 2001"))
        self.assertTrue(DateValue.parse("FROM 1 JAN 2000 TO 1 JAN 2002") >
                        DateValue.parse("BET 1 JAN 2000 AND 1 JAN 2001"))

        # Less specific date compares later than more specific
        self.assertTrue(DateValue.parse("2000") > DateValue.parse("31 DEC 2000"))
        self.assertTrue(DateValue.parse("DEC 2000") > DateValue.parse("31 DEC 2000"))

        # phrase is always later than any regular date
        self.assertTrue(DateValue.parse("(Could be 1996 or 1998)") > DateValue.parse("2000"))

        # "empty" date is always later than any regular date
        self.assertTrue(DateValue.parse("") > DateValue.parse("2000"))

    def test_018_date_parse_empty(self):
        """Test date.DateValue class."""

        for value in (None, ""):
            date = DateValue.parse(value)
            self.assertIsInstance(date, DateValuePhrase)
            self.assertEqual(date.kind, DateValueTypes.PHRASE)
            self.assertIsNone(date.phrase)
            self.assertEqual(str(date), "")

    def test_019_date_value_visitor(self):
        """Test date.DateValue class."""

        visitor = TestDateVisitor()

        date1 = GregorianDate(2017, "JAN", 1)
        date2 = GregorianDate(2017, "DEC", 31)

        value = DateValueSimple(date1).accept(visitor)
        self.assertEqual(value, ("simple", date1))

        value = DateValueFrom(date1).accept(visitor)
        self.assertEqual(value, ("from", date1))

        value = DateValueTo(date1).accept(visitor)
        self.assertEqual(value, ("to", date1))

        value = DateValuePeriod(date1, date2).accept(visitor)
        self.assertEqual(value, ("period", date1, date2))

        value = DateValueBefore(date1).accept(visitor)
        self.assertEqual(value, ("before", date1))

        value = DateValueAfter(date1).accept(visitor)
        self.assertEqual(value, ("after", date1))

        value = DateValueRange(date1, date2).accept(visitor)
        self.assertEqual(value, ("range", date1, date2))

        value = DateValueAbout(date1).accept(visitor)
        self.assertEqual(value, ("about", date1))

        value = DateValueCalculated(date1).accept(visitor)
        self.assertEqual(value, ("calculated", date1))

        value = DateValueEstimated(date1).accept(visitor)
        self.assertEqual(value, ("estimated", date1))

        value = DateValueInterpreted(date1, "phrase").accept(visitor)
        self.assertEqual(value, ("interpreted", date1, "phrase"))

        value = DateValuePhrase("phrase").accept(visitor)
        self.assertEqual(value, ("phrase", "phrase"))

    def test_020_date_hash(self):
        """Test date.Date hash"""

        dv1 = DateValue.parse("2016")
        dv2 = DateValue.parse("2016")
        self.assertEqual(hash(dv1), hash(dv2))

        dv1 = DateValue.parse("31 DEC 2000")
        dv2 = DateValue.parse("31 DEC 2000")
        self.assertEqual(hash(dv1), hash(dv2))

        dv1 = DateValue.parse("BET 31 DEC 2000 AND 1 JAN 2001")
        dv2 = DateValue.parse("BET 31 DEC 2000 AND 1 JAN 2001")
        self.assertEqual(hash(dv1), hash(dv2))

[((109, 15, 109, 44), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(109, 29, 109, 33): '2017', (109, 35, 109, 40): '"""OCT"""', (109, 42, 109, 43): '9'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((119, 15, 119, 50), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((129, 15, 129, 57), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((139, 15, 139, 31), 'ged4py.calendar.HebrewDate', 'HebrewDate', ({(139, 26, 139, 30): '5000'}, {}), '(5000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((148, 15, 148, 39), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(148, 26, 148, 27): '1', (148, 29, 148, 35): '"""FRUC"""', (148, 37, 148, 38): '1'}, {}), "(1, 'FRUC', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((157, 15, 157, 44), 'ged4py.calendar.JulianDate', 'JulianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((169, 15, 169, 44), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(169, 29, 169, 33): '2017', (169, 35, 169, 40): '"""OCT"""', (169, 42, 169, 43): '9'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((172, 15, 172, 60), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((175, 15, 175, 48), 'ged4py.calendar.FrenchDate', 'FrenchDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((178, 15, 178, 42), 'ged4py.calendar.HebrewDate', 'HebrewDate', ({(178, 26, 178, 30): '2017', (178, 32, 178, 37): '"""TSH"""', (178, 39, 178, 41): '22'}, {}), "(2017, 'TSH', 22)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((181, 15, 181, 31), 'ged4py.calendar.JulianDate', 'JulianDate', ({(181, 26, 181, 30): '1000'}, {}), '(1000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((224, 15, 224, 44), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(224, 29, 224, 33): '2017', (224, 35, 224, 40): '"""OCT"""', (224, 42, 224, 43): '9'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((227, 15, 227, 50), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((230, 15, 230, 60), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((233, 15, 233, 31), 'ged4py.calendar.HebrewDate', 'HebrewDate', ({(233, 26, 233, 30): '5000'}, {}), '(5000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((236, 15, 236, 39), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(236, 26, 236, 27): '1', (236, 29, 236, 35): '"""VEND"""', (236, 37, 236, 38): '1'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((239, 15, 239, 41), 'ged4py.calendar.JulianDate', 'JulianDate', ({(239, 26, 239, 30): '1582', (239, 32, 239, 37): '"""OCT"""', (239, 39, 239, 40): '5'}, {}), "(1582, 'OCT', 5)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((245, 15, 245, 48), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(245, 34, 245, 47): '"""31 MAY 2020"""'}, {}), "('31 MAY 2020')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((256, 15, 256, 65), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(256, 34, 256, 64): '"""@#DGREGORIAN@ 10 MAR 1698/99"""'}, {}), "('@#DGREGORIAN@ 10 MAR 1698/99')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((267, 15, 267, 51), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(267, 34, 267, 50): '"""10 MAR 1699/00"""'}, {}), "('10 MAR 1699/00')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((274, 15, 274, 56), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(274, 34, 274, 55): '"""@#DJULIAN@ 100 B.C."""'}, {}), "('@#DJULIAN@ 100 B.C.')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((284, 15, 284, 62), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(284, 34, 284, 61): '"""@#DFRENCH R@ 15 GERM 0001"""'}, {}), "('@#DFRENCH R@ 15 GERM 0001')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((294, 15, 294, 58), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(294, 34, 294, 57): '"""@#DHEBREW@ 7 NSN 5000"""'}, {}), "('@#DHEBREW@ 7 NSN 5000')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((325, 15, 325, 44), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(325, 29, 325, 33): '2017', (325, 35, 325, 40): '"""OCT"""', (325, 42, 325, 43): '9'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((329, 15, 329, 31), 'ged4py.calendar.HebrewDate', 'HebrewDate', ({(329, 26, 329, 30): '5000'}, {}), '(5000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((333, 15, 333, 39), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(333, 26, 333, 27): '1', (333, 29, 333, 35): '"""VEND"""', (333, 37, 333, 38): '1'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((337, 15, 337, 41), 'ged4py.calendar.JulianDate', 'JulianDate', ({(337, 26, 337, 30): '1582', (337, 32, 337, 37): '"""OCT"""', (337, 39, 337, 40): '5'}, {}), "(1582, 'OCT', 5)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((356, 15, 356, 44), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(356, 31, 356, 43): '"""not a date"""'}, {}), "('not a date')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((365, 15, 365, 43), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(365, 31, 365, 42): '"""FROM 1967"""'}, {}), "('FROM 1967')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((371, 15, 371, 47), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(371, 31, 371, 46): '"""TO 1 JAN 2017"""'}, {}), "('TO 1 JAN 2017')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((377, 15, 377, 51), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(377, 31, 377, 50): '"""FROM 1920 TO 2000"""'}, {}), "('FROM 1920 TO 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((384, 15, 384, 61), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(384, 31, 384, 60): '"""from mar 1920 to 1 apr 2000"""'}, {}), "('from mar 1920 to 1 apr 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((394, 15, 394, 46), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(394, 31, 394, 45): '"""BEF 1967B.C."""'}, {}), "('BEF 1967B.C.')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((400, 15, 400, 48), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(400, 31, 400, 47): '"""AFT 1 JAN 2017"""'}, {}), "('AFT 1 JAN 2017')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((406, 15, 406, 62), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(406, 31, 406, 61): '"""BET @#DJULIAN@ 1600 AND 2000"""'}, {}), "('BET @#DJULIAN@ 1600 AND 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((413, 15, 413, 59), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(413, 31, 413, 58): '"""bet mar 1920 and apr 2000"""'}, {}), "('bet mar 1920 and apr 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((444, 15, 444, 47), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(444, 31, 444, 46): '"""(some phrase)"""'}, {}), "('(some phrase)')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((449, 15, 449, 61), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(449, 31, 449, 60): '"""INT 1967 B.C. (some phrase)"""'}, {}), "('INT 1967 B.C. (some phrase)')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((456, 15, 456, 76), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(456, 31, 456, 75): '"""INT @#DGREGORIAN@ 1 JAN 2017 (some phrase)"""'}, {}), "('INT @#DGREGORIAN@ 1 JAN 2017 (some phrase)')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((466, 15, 466, 43), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(466, 31, 466, 42): '"""1967 B.C."""'}, {}), "('1967 B.C.')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((472, 15, 472, 58), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(472, 31, 472, 57): '"""@#DGREGORIAN@ 1 JAN 2017"""'}, {}), "('@#DGREGORIAN@ 1 JAN 2017')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((481, 13, 481, 36), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(481, 29, 481, 35): '"""2016"""'}, {}), "('2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((485, 13, 485, 43), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(485, 29, 485, 42): '"""31 DEC 2000"""'}, {}), "('31 DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((489, 13, 489, 62), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(489, 29, 489, 61): '"""BET 31 DEC 2000 AND 1 JAN 2001"""'}, {}), "('BET 31 DEC 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((494, 13, 494, 62), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(494, 29, 494, 61): '"""BET 31 DEC 2000 AND 1 JAN 2000"""'}, {}), "('BET 31 DEC 2000 AND 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((544, 16, 544, 45), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(544, 30, 544, 34): '2017', (544, 36, 544, 41): '"""JAN"""', (544, 43, 544, 44): '1'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((545, 16, 545, 46), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(545, 30, 545, 34): '2017', (545, 36, 545, 41): '"""DEC"""', (545, 43, 545, 45): '31'}, {}), "(2017, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((586, 14, 586, 37), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(586, 30, 586, 36): '"""2016"""'}, {}), "('2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((587, 14, 587, 37), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(587, 30, 587, 36): '"""2016"""'}, {}), "('2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((590, 14, 590, 44), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(590, 30, 590, 43): '"""31 DEC 2000"""'}, {}), "('31 DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((591, 14, 591, 44), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(591, 30, 591, 43): '"""31 DEC 2000"""'}, {}), "('31 DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((594, 14, 594, 63), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(594, 30, 594, 62): '"""BET 31 DEC 2000 AND 1 JAN 2001"""'}, {}), "('BET 31 DEC 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((595, 14, 595, 63), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(595, 30, 595, 62): '"""BET 31 DEC 2000 AND 1 JAN 2001"""'}, {}), "('BET 31 DEC 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((306, 19, 306, 55), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(306, 38, 306, 54): '"""@#DROMAN@ 2020"""'}, {}), "('@#DROMAN@ 2020')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((310, 19, 310, 57), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(310, 38, 310, 56): '"""@#DUNKNOWN@ 2020"""'}, {}), "('@#DUNKNOWN@ 2020')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((314, 19, 314, 59), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(314, 38, 314, 58): '"""@#DJULIAN@ 2020/21"""'}, {}), "('@#DJULIAN@ 2020/21')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((318, 19, 318, 54), 'ged4py.calendar.CalendarDate.parse', 'CalendarDate.parse', ({(318, 38, 318, 53): '"""start of time"""'}, {}), "('start of time')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((368, 36, 368, 55), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(368, 50, 368, 54): '(1967)'}, {}), '(1967)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((374, 36, 374, 65), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(374, 50, 374, 54): '(2017)', (374, 56, 374, 61): '"""JAN"""', (374, 63, 374, 64): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((380, 37, 380, 56), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(380, 51, 380, 55): '(1920)'}, {}), '(1920)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((381, 37, 381, 56), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(381, 51, 381, 55): '(2000)'}, {}), '(2000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((387, 37, 387, 63), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(387, 51, 387, 55): '(1920)', (387, 57, 387, 62): '"""MAR"""'}, {}), "(1920, 'MAR')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((388, 37, 388, 66), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(388, 51, 388, 55): '(2000)', (388, 57, 388, 62): '"""APR"""', (388, 64, 388, 65): '(1)'}, {}), "(2000, 'APR', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((397, 36, 397, 64), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((403, 36, 403, 65), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(403, 50, 403, 54): '(2017)', (403, 56, 403, 61): '"""JAN"""', (403, 63, 403, 64): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((409, 37, 409, 53), 'ged4py.calendar.JulianDate', 'JulianDate', ({(409, 48, 409, 52): '(1600)'}, {}), '(1600)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((410, 37, 410, 56), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(410, 51, 410, 55): '(2000)'}, {}), '(2000)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((416, 37, 416, 63), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(416, 51, 416, 55): '(1920)', (416, 57, 416, 62): '"""MAR"""'}, {}), "(1920, 'MAR')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((417, 37, 417, 63), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(417, 51, 417, 55): '(2000)', (417, 57, 417, 62): '"""APR"""'}, {}), "(2000, 'APR')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((423, 29, 423, 56), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((424, 29, 424, 55), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(424, 43, 424, 47): '(2017)', (424, 49, 424, 54): '"""JAN"""'}, {}), "(2017, 'JAN')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((425, 32, 425, 62), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(425, 46, 425, 50): '(2017)', (425, 52, 425, 57): '"""JAN"""', (425, 59, 425, 61): '(31)'}, {}), "(2017, 'JAN', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((452, 36, 452, 64), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((459, 36, 459, 65), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(459, 50, 459, 54): '(2017)', (459, 56, 459, 61): '"""JAN"""', (459, 63, 459, 64): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((469, 36, 469, 64), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((475, 36, 475, 65), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(475, 50, 475, 54): '(2017)', (475, 56, 475, 61): '"""JAN"""', (475, 63, 475, 64): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((504, 28, 504, 57), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(504, 44, 504, 56): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((504, 59, 504, 107), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(504, 75, 504, 106): '"""BET 1 JAN 2000 AND 1 JAN 2001"""'}, {}), "('BET 1 JAN 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((512, 25, 512, 73), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(512, 41, 512, 72): '"""FROM 1 JAN 2000 TO 1 JAN 2001"""'}, {}), "('FROM 1 JAN 2000 TO 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((513, 25, 513, 73), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(513, 41, 513, 72): '"""BET 1 JAN 2000 AND 1 JAN 2001"""'}, {}), "('BET 1 JAN 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((533, 19, 533, 41), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(533, 35, 533, 40): 'value'}, {}), '(value)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((187, 24, 187, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(187, 38, 187, 42): '(2016)', (187, 44, 187, 49): '"""JAN"""', (187, 51, 187, 52): '(1)'}, {}), "(2016, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((187, 56, 187, 85), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(187, 70, 187, 74): '(2017)', (187, 76, 187, 81): '"""JAN"""', (187, 83, 187, 84): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((188, 24, 188, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(188, 38, 188, 42): '(2017)', (188, 44, 188, 49): '"""JAN"""', (188, 51, 188, 52): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((188, 56, 188, 85), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(188, 70, 188, 74): '(2017)', (188, 76, 188, 81): '"""FEB"""', (188, 83, 188, 84): '(1)'}, {}), "(2017, 'FEB', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((189, 24, 189, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(189, 38, 189, 42): '(2017)', (189, 44, 189, 49): '"""JAN"""', (189, 51, 189, 52): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((189, 56, 189, 85), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(189, 70, 189, 74): '(2017)', (189, 76, 189, 81): '"""JAN"""', (189, 83, 189, 84): '(2)'}, {}), "(2017, 'JAN', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((191, 24, 191, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(191, 38, 191, 42): '(2017)', (191, 44, 191, 49): '"""JAN"""', (191, 51, 191, 52): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((191, 57, 191, 86), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(191, 71, 191, 75): '(2017)', (191, 77, 191, 82): '"""JAN"""', (191, 84, 191, 85): '(2)'}, {}), "(2017, 'JAN', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((192, 24, 192, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(192, 38, 192, 42): '(2017)', (192, 44, 192, 49): '"""JAN"""', (192, 51, 192, 52): '(2)'}, {}), "(2017, 'JAN', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((192, 56, 192, 85), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(192, 70, 192, 74): '(2017)', (192, 76, 192, 81): '"""JAN"""', (192, 83, 192, 84): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((193, 24, 193, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(193, 38, 193, 42): '(2017)', (193, 44, 193, 49): '"""JAN"""', (193, 51, 193, 52): '(2)'}, {}), "(2017, 'JAN', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((193, 57, 193, 86), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(193, 71, 193, 75): '(2017)', (193, 77, 193, 82): '"""JAN"""', (193, 84, 193, 85): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((194, 24, 194, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(194, 38, 194, 42): '(2017)', (194, 44, 194, 49): '"""JAN"""', (194, 51, 194, 52): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((194, 57, 194, 86), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(194, 71, 194, 75): '(2017)', (194, 77, 194, 82): '"""JAN"""', (194, 84, 194, 85): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((195, 24, 195, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(195, 38, 195, 42): '(2017)', (195, 44, 195, 49): '"""JAN"""', (195, 51, 195, 52): '(1)'}, {}), "(2017, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((195, 57, 195, 86), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(195, 71, 195, 75): '(2017)', (195, 77, 195, 82): '"""JAN"""', (195, 84, 195, 85): '(2)'}, {}), "(2017, 'JAN', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((198, 24, 198, 50), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(198, 38, 198, 42): '(2017)', (198, 44, 198, 49): '"""JAN"""'}, {}), "(2017, 'JAN')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((198, 53, 198, 83), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(198, 67, 198, 71): '(2017)', (198, 73, 198, 78): '"""JAN"""', (198, 80, 198, 82): '(31)'}, {}), "(2017, 'JAN', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((199, 24, 199, 50), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(199, 38, 199, 42): '(2017)', (199, 44, 199, 49): '"""JAN"""'}, {}), "(2017, 'JAN')", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((199, 53, 199, 82), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(199, 67, 199, 71): '(2017)', (199, 73, 199, 78): '"""FEB"""', (199, 80, 199, 81): '(1)'}, {}), "(2017, 'FEB', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((201, 24, 201, 43), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(201, 38, 201, 42): '(2017)'}, {}), '(2017)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((201, 46, 201, 76), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(201, 60, 201, 64): '(2017)', (201, 66, 201, 71): '"""DEC"""', (201, 73, 201, 75): '(31)'}, {}), "(2017, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((202, 24, 202, 43), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(202, 38, 202, 42): '(2017)'}, {}), '(2017)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((202, 46, 202, 75), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(202, 60, 202, 64): '(2018)', (202, 66, 202, 71): '"""JAN"""', (202, 73, 202, 74): '(1)'}, {}), "(2018, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((205, 24, 205, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(205, 38, 205, 42): '(1700)', (205, 44, 205, 49): '"""JAN"""', (205, 51, 205, 52): '(1)'}, {}), "(1700, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((205, 57, 205, 102), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((208, 24, 208, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(208, 38, 208, 42): '(1582)', (208, 44, 208, 49): '"""OCT"""', (208, 51, 208, 53): '(15)'}, {}), "(1582, 'OCT', 15)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((208, 58, 208, 84), 'ged4py.calendar.JulianDate', 'JulianDate', ({(208, 69, 208, 73): '(1582)', (208, 75, 208, 80): '"""OCT"""', (208, 82, 208, 83): '(5)'}, {}), "(1582, 'OCT', 5)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((209, 24, 209, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(209, 38, 209, 42): '(1582)', (209, 44, 209, 49): '"""OCT"""', (209, 51, 209, 53): '(16)'}, {}), "(1582, 'OCT', 16)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((209, 57, 209, 83), 'ged4py.calendar.JulianDate', 'JulianDate', ({(209, 68, 209, 72): '(1582)', (209, 74, 209, 79): '"""OCT"""', (209, 81, 209, 82): '(5)'}, {}), "(1582, 'OCT', 5)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((210, 24, 210, 50), 'ged4py.calendar.JulianDate', 'JulianDate', ({(210, 35, 210, 39): '(1582)', (210, 41, 210, 46): '"""OCT"""', (210, 48, 210, 49): '(6)'}, {}), "(1582, 'OCT', 6)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((210, 53, 210, 83), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(210, 67, 210, 71): '(1582)', (210, 73, 210, 78): '"""OCT"""', (210, 80, 210, 82): '(15)'}, {}), "(1582, 'OCT', 15)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((211, 24, 211, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(211, 38, 211, 42): '(2000)', (211, 44, 211, 49): '"""JAN"""', (211, 51, 211, 53): '(14)'}, {}), "(2000, 'JAN', 14)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((211, 58, 211, 84), 'ged4py.calendar.JulianDate', 'JulianDate', ({(211, 69, 211, 73): '(2000)', (211, 75, 211, 80): '"""JAN"""', (211, 82, 211, 83): '(1)'}, {}), "(2000, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((214, 24, 214, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(214, 38, 214, 42): '(1792)', (214, 44, 214, 49): '"""SEP"""', (214, 51, 214, 53): '(22)'}, {}), "(1792, 'SEP', 22)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((214, 58, 214, 82), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(214, 69, 214, 70): '(1)', (214, 72, 214, 78): '"""VEND"""', (214, 80, 214, 81): '(1)'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((215, 24, 215, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(215, 38, 215, 42): '(1792)', (215, 44, 215, 49): '"""SEP"""', (215, 51, 215, 53): '(23)'}, {}), "(1792, 'SEP', 23)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((215, 57, 215, 81), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(215, 68, 215, 69): '(1)', (215, 71, 215, 77): '"""VEND"""', (215, 79, 215, 80): '(1)'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((216, 24, 216, 48), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(216, 35, 216, 36): '(1)', (216, 38, 216, 44): '"""VEND"""', (216, 46, 216, 47): '(2)'}, {}), "(1, 'VEND', 2)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((216, 51, 216, 81), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(216, 65, 216, 69): '(1792)', (216, 71, 216, 76): '"""SEP"""', (216, 78, 216, 80): '(22)'}, {}), "(1792, 'SEP', 22)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((217, 24, 217, 54), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(217, 38, 217, 42): '(2020)', (217, 44, 217, 49): '"""SEP"""', (217, 51, 217, 53): '(21)'}, {}), "(2020, 'SEP', 21)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((217, 58, 217, 84), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(217, 69, 217, 72): '(228)', (217, 74, 217, 80): '"""COMP"""', (217, 82, 217, 83): '(5)'}, {}), "(228, 'COMP', 5)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((220, 24, 220, 53), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(220, 38, 220, 42): '(2020)', (220, 44, 220, 49): '"""JAN"""', (220, 51, 220, 52): '(1)'}, {}), "(2020, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((220, 57, 220, 83), 'ged4py.calendar.HebrewDate', 'HebrewDate', ({(220, 68, 220, 72): '(5780)', (220, 74, 220, 79): '"""SVN"""', (220, 81, 220, 82): '(4)'}, {}), "(5780, 'SVN', 4)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((344, 30, 344, 59), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(344, 44, 344, 48): '(2017)', (344, 50, 344, 55): '"""OCT"""', (344, 57, 344, 58): '(9)'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((345, 30, 345, 59), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(345, 44, 345, 48): '(2017)', (345, 50, 345, 55): '"""OCT"""', (345, 57, 345, 58): '(9)'}, {}), "(2017, 'OCT', 9)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((346, 30, 346, 68), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((347, 30, 347, 68), 'ged4py.calendar.GregorianDate', 'GregorianDate', (), '', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((348, 30, 348, 54), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(348, 41, 348, 42): '(1)', (348, 44, 348, 50): '"""VEND"""', (348, 52, 348, 53): '(1)'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((349, 30, 349, 54), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(349, 41, 349, 42): '(1)', (349, 44, 349, 50): '"""VEND"""', (349, 52, 349, 53): '(1)'}, {}), "(1, 'VEND', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((350, 30, 350, 43), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(350, 41, 350, 42): '(1)'}, {}), '(1)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((351, 30, 351, 43), 'ged4py.calendar.FrenchDate', 'FrenchDate', ({(351, 41, 351, 42): '(1)'}, {}), '(1)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((435, 23, 435, 60), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(435, 39, 435, 59): "appr + ' ' + datestr"}, {}), "(appr + ' ' + datestr)", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((483, 36, 483, 55), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(483, 50, 483, 54): '(2016)'}, {}), '(2016)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((483, 57, 483, 76), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(483, 71, 483, 75): '(2016)'}, {}), '(2016)', False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((487, 36, 487, 66), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(487, 50, 487, 54): '(2000)', (487, 56, 487, 61): '"""DEC"""', (487, 63, 487, 65): '(31)'}, {}), "(2000, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((487, 68, 487, 98), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(487, 82, 487, 86): '(2000)', (487, 88, 487, 93): '"""DEC"""', (487, 95, 487, 97): '(31)'}, {}), "(2000, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((491, 36, 491, 66), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(491, 50, 491, 54): '(2000)', (491, 56, 491, 61): '"""DEC"""', (491, 63, 491, 65): '(31)'}, {}), "(2000, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((491, 68, 491, 97), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(491, 82, 491, 86): '(2001)', (491, 88, 491, 93): '"""JAN"""', (491, 95, 491, 96): '(1)'}, {}), "(2001, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((496, 36, 496, 66), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(496, 50, 496, 54): '(2000)', (496, 56, 496, 61): '"""DEC"""', (496, 63, 496, 65): '(31)'}, {}), "(2000, 'DEC', 31)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((496, 68, 496, 97), 'ged4py.calendar.GregorianDate', 'GregorianDate', ({(496, 82, 496, 86): '(2000)', (496, 88, 496, 93): '"""JAN"""', (496, 95, 496, 96): '(1)'}, {}), "(2000, 'JAN', 1)", False, 'from ged4py.calendar import CalendarType, CalendarDate, FrenchDate, GregorianDate, HebrewDate, JulianDate, CalendarDateVisitor\n'), ((498, 24, 498, 47), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(498, 40, 498, 46): '"""2016"""'}, {}), "('2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((498, 50, 498, 73), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(498, 66, 498, 72): '"""2017"""'}, {}), "('2017')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((499, 24, 499, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(499, 40, 499, 52): '"""2 JAN 2016"""'}, {}), "('2 JAN 2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((499, 56, 499, 85), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(499, 72, 499, 84): '"""1 JAN 2016"""'}, {}), "('1 JAN 2016')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((500, 24, 500, 60), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(500, 40, 500, 59): '"""BET 1900 AND 2000"""'}, {}), "('BET 1900 AND 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((500, 63, 500, 99), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(500, 79, 500, 98): '"""FROM 1920 TO 1999"""'}, {}), "('FROM 1920 TO 1999')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((503, 24, 503, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(503, 40, 503, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((503, 56, 503, 104), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(503, 72, 503, 103): '"""BET 1 JAN 1999 AND 1 JAN 2000"""'}, {}), "('BET 1 JAN 1999 AND 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((505, 24, 505, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(505, 40, 505, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((505, 56, 505, 104), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(505, 72, 505, 103): '"""BET 1 JAN 2000 AND 1 JAN 2001"""'}, {}), "('BET 1 JAN 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((506, 24, 506, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(506, 40, 506, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((506, 56, 506, 89), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(506, 72, 506, 88): '"""BEF 1 JAN 2000"""'}, {}), "('BEF 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((507, 24, 507, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(507, 40, 507, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((507, 56, 507, 88), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(507, 72, 507, 87): '"""TO 1 JAN 2000"""'}, {}), "('TO 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((508, 24, 508, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(508, 40, 508, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((508, 56, 508, 89), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(508, 72, 508, 88): '"""AFT 1 JAN 2000"""'}, {}), "('AFT 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((509, 24, 509, 53), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(509, 40, 509, 52): '"""1 JAN 2000"""'}, {}), "('1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((509, 56, 509, 90), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(509, 72, 509, 89): '"""FROM 1 JAN 2000"""'}, {}), "('FROM 1 JAN 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((514, 24, 514, 72), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(514, 40, 514, 71): '"""FROM 1 JAN 1999 TO 1 JAN 2001"""'}, {}), "('FROM 1 JAN 1999 TO 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((515, 24, 515, 72), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(515, 40, 515, 71): '"""BET 1 JAN 2000 AND 1 JAN 2001"""'}, {}), "('BET 1 JAN 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((516, 24, 516, 72), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(516, 40, 516, 71): '"""FROM 1 JAN 2000 TO 1 JAN 2002"""'}, {}), "('FROM 1 JAN 2000 TO 1 JAN 2002')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((517, 24, 517, 72), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(517, 40, 517, 71): '"""BET 1 JAN 2000 AND 1 JAN 2001"""'}, {}), "('BET 1 JAN 2000 AND 1 JAN 2001')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((520, 24, 520, 47), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(520, 40, 520, 46): '"""2000"""'}, {}), "('2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((520, 50, 520, 80), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(520, 66, 520, 79): '"""31 DEC 2000"""'}, {}), "('31 DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((521, 24, 521, 51), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(521, 40, 521, 50): '"""DEC 2000"""'}, {}), "('DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((521, 54, 521, 84), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(521, 70, 521, 83): '"""31 DEC 2000"""'}, {}), "('31 DEC 2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((524, 24, 524, 66), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(524, 40, 524, 65): '"""(Could be 1996 or 1998)"""'}, {}), "('(Could be 1996 or 1998)')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((524, 69, 524, 92), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(524, 85, 524, 91): '"""2000"""'}, {}), "('2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((527, 24, 527, 43), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(527, 40, 527, 42): '""""""'}, {}), "('')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((527, 46, 527, 69), 'ged4py.date.DateValue.parse', 'DateValue.parse', ({(527, 62, 527, 68): '"""2000"""'}, {}), "('2000')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((547, 16, 547, 38), 'ged4py.date.DateValueSimple', 'DateValueSimple', ({(547, 32, 547, 37): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((550, 16, 550, 36), 'ged4py.date.DateValueFrom', 'DateValueFrom', ({(550, 30, 550, 35): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((553, 16, 553, 34), 'ged4py.date.DateValueTo', 'DateValueTo', ({(553, 28, 553, 33): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((556, 16, 556, 45), 'ged4py.date.DateValuePeriod', 'DateValuePeriod', ({(556, 32, 556, 37): 'date1', (556, 39, 556, 44): 'date2'}, {}), '(date1, date2)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((559, 16, 559, 38), 'ged4py.date.DateValueBefore', 'DateValueBefore', ({(559, 32, 559, 37): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((562, 16, 562, 37), 'ged4py.date.DateValueAfter', 'DateValueAfter', ({(562, 31, 562, 36): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((565, 16, 565, 44), 'ged4py.date.DateValueRange', 'DateValueRange', ({(565, 31, 565, 36): 'date1', (565, 38, 565, 43): 'date2'}, {}), '(date1, date2)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((568, 16, 568, 37), 'ged4py.date.DateValueAbout', 'DateValueAbout', ({(568, 31, 568, 36): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((571, 16, 571, 42), 'ged4py.date.DateValueCalculated', 'DateValueCalculated', ({(571, 36, 571, 41): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((574, 16, 574, 41), 'ged4py.date.DateValueEstimated', 'DateValueEstimated', ({(574, 35, 574, 40): 'date1'}, {}), '(date1)', False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((577, 16, 577, 53), 'ged4py.date.DateValueInterpreted', 'DateValueInterpreted', ({(577, 37, 577, 42): 'date1', (577, 44, 577, 52): '"""phrase"""'}, {}), "(date1, 'phrase')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n'), ((580, 16, 580, 41), 'ged4py.date.DateValuePhrase', 'DateValuePhrase', ({(580, 32, 580, 40): '"""phrase"""'}, {}), "('phrase')", False, 'from ged4py.date import DateValue, DateValueAbout, DateValueAfter, DateValueBefore, DateValueCalculated, DateValueEstimated, DateValueFrom, DateValueInterpreted, DateValuePeriod, DateValuePhrase, DateValueRange, DateValueSimple, DateValueTo, DateValueTypes, DateValueVisitor\n')]