From ef24bc71dbd5d9d8edae57f0cc1aea182c88f12a Mon Sep 17 00:00:00 2001 From: Cole Crawford <16374762+ColeDCrawford@users.noreply.github.com> Date: Mon, 27 May 2024 21:32:43 -0400 Subject: [PATCH 1/3] Handle unspecified and qualified ("16XX~") Unspecified dates previously could not handle qualification. Unspecified dates also couldn't handle dates with 3 unspecified digits ("1XXX"). This commit adds both those features and tests for those use cases. --- edtf/appsettings.py | 7 +++ edtf/parser/grammar.py | 8 ++-- edtf/parser/parser_classes.py | 84 ++++++++++++++++++++++++++++++++++- edtf/parser/tests.py | 7 +++ 4 files changed, 102 insertions(+), 4 deletions(-) diff --git a/edtf/appsettings.py b/edtf/appsettings.py index e1bc821..e00a223 100644 --- a/edtf/appsettings.py +++ b/edtf/appsettings.py @@ -87,6 +87,13 @@ PADDING_MONTH_PRECISION = EDTF.get("PADDING_MONTH_PRECISION", relativedelta(months=1)) PADDING_YEAR_PRECISION = EDTF.get("PADDING_YEAR_PRECISION", relativedelta(years=1)) PADDING_SEASON_PRECISION = EDTF.get("PADDING_SEASON_PRECISION", relativedelta(weeks=12)) +PADDING_DECADE_PRECISION = EDTF.get("PADDING_DECADE_PRECISION", relativedelta(years=10)) +PADDING_CENTURY_PRECISION = EDTF.get( + "PADDING_CENTURY_PRECISION", relativedelta(years=100) +) +PADDING_MILLENNIUM_PRECISION = EDTF.get( + "PADDING_MILLENNIUM_PRECISION", relativedelta(years=1000) +) MULTIPLIER_IF_UNCERTAIN = EDTF.get("MULTIPLIER_IF_UNCERTAIN", 1.0) MULTIPLIER_IF_APPROXIMATE = EDTF.get("MULTIPLIER_IF_APPROXIMATE", 1.0) MULTIPLIER_IF_BOTH = EDTF.get("MULTIPLIER_IF_BOTH", 2.0) diff --git a/edtf/parser/grammar.py b/edtf/parser/grammar.py index dc0f66d..ae03251 100644 --- a/edtf/parser/grammar.py +++ b/edtf/parser/grammar.py @@ -161,17 +161,19 @@ def f(toks): Level1Interval.set_parser(level1Interval) # (* *** unspecified *** *) -yearWithOneOrTwoUnspecifedDigits = Combine(digit + digit + (digit ^ "X") + "X")("year") +yearWithOneOrTwoOrThreeUnspecifedDigits = Combine( + digit + (digit ^ "X") + (digit ^ "X") + "X" +)("year") monthUnspecified = year + "-" + L("XX")("month") dayUnspecified = yearMonth + "-" + L("XX")("day") dayAndMonthUnspecified = year + "-" + L("XX")("month") + "-" + L("XX")("day") unspecified = ( - yearWithOneOrTwoUnspecifedDigits + yearWithOneOrTwoOrThreeUnspecifedDigits ^ monthUnspecified ^ dayUnspecified ^ dayAndMonthUnspecified -) +) + Optional(UASymbol)("ua") Unspecified.set_parser(unspecified) # (* *** uncertainOrApproxDate *** *) diff --git a/edtf/parser/parser_classes.py b/edtf/parser/parser_classes.py index e12ecbd..0bbf855 100644 --- a/edtf/parser/parser_classes.py +++ b/edtf/parser/parser_classes.py @@ -541,7 +541,89 @@ def precision(self): class Unspecified(Date): - pass + def __init__( + self, + year=None, + month=None, + day=None, + significant_digits=None, + ua=None, + **kwargs, + ): + for param in ("date", "lower", "upper"): + if param in kwargs: + self.__init__(**kwargs[param]) + return + self.year = year # Year is required, but sometimes passed in as a 'date' dict. + self.month = month + self.day = day + self.significant_digits = ( + int(significant_digits) if significant_digits else None + ) + self.ua = ua if ua else None + + def __str__(self): + r = self.year + if self.month: + r += f"-{self.month}" + if self.day: + r += f"-{self.day}" + if self.ua: + r += str(self.ua) + return r + + def _get_fuzzy_padding(self, lean): + if not self.ua: + return relativedelta() + multiplier = self.ua._get_multiplier() + padding = relativedelta() + + if self.year: + if self.precision == PRECISION_MILLENIUM: + padding += relativedelta( + years=int( + multiplier * appsettings.PADDING_MILLENNIUM_PRECISION.years + ) + ) + elif self.precision == PRECISION_CENTURY: + padding += relativedelta( + years=int(multiplier * appsettings.PADDING_CENTURY_PRECISION.years) + ) + elif self.precision == PRECISION_DECADE: + padding += relativedelta( + years=int(multiplier * appsettings.PADDING_DECADE_PRECISION.years) + ) + else: + padding += relativedelta( + years=int(multiplier * appsettings.PADDING_YEAR_PRECISION.years) + ) + if self.month: + padding += relativedelta( + months=int(multiplier * appsettings.PADDING_MONTH_PRECISION.months) + ) + if self.day: + padding += relativedelta( + days=int(multiplier * appsettings.PADDING_DAY_PRECISION.days) + ) + + return padding + + @property + def precision(self): + if self.day: + return PRECISION_DAY + if self.month: + return PRECISION_MONTH + if self.year: + if self.year.isdigit(): + return PRECISION_YEAR + if len(self.year) == 4 and self.year.endswith("XXX"): + return PRECISION_MILLENIUM + if len(self.year) == 4 and self.year.endswith("XX"): + return PRECISION_CENTURY + if len(self.year) == 4 and self.year.endswith("X"): + return PRECISION_DECADE + raise ValueError(f"Unspecified date {self} has no precision") class Level1Interval(Interval): diff --git a/edtf/parser/tests.py b/edtf/parser/tests.py index 4932e95..464aca3 100644 --- a/edtf/parser/tests.py +++ b/edtf/parser/tests.py @@ -85,6 +85,13 @@ ("-0275~", ("-0275-01-01", "-0275-12-31", "-0276-01-01", "-0274-12-31")), ("-0001~", ("-0001-01-01", "-0001-12-31", "-0002-01-01", "0000-12-31")), ("0000~", ("0000-01-01", "0000-12-31", "-0001-01-01", "0001-12-31")), + # Unspecified and qualified + # "circa 17th century" + ("16XX~", ("1600-01-01", "1699-12-31", "1500-01-01", "1799-12-31")), + ("16XX%", ("1600-01-01", "1699-12-31", "1400-01-01", "1899-12-31")), + ("1XXX", ("1000-01-01", "1999-12-31")), + ("1XXX~", ("1000-01-01", "1999-12-31", "0000-01-01", "2999-12-31")), + ("156X~", ("1560-01-01", "1569-12-31", "1550-01-01", "1579-12-31")), # L1 Extended Interval # beginning unknown, end 2006 # for intervals with an unknown beginning or end, the unknown bound is calculated with the constant DELTA_IF_UNKNOWN (10 years) From b53df4a599fef6d25ecef43da0601f352505b48c Mon Sep 17 00:00:00 2001 From: Cole Crawford <16374762+ColeDCrawford@users.noreply.github.com> Date: Tue, 28 May 2024 13:08:57 -0400 Subject: [PATCH 2/3] Handle negative unspecified and negative unspecified + qualified Requires quite a few overrides of lower_ and upper_ range methods to properly handle dates due to padding working in the opposite direction for negative dates, esp when combined with month/day padding. --- edtf/parser/grammar.py | 2 +- edtf/parser/parser_classes.py | 226 +++++++++++++++++++++++++++++----- edtf/parser/tests.py | 3 + 3 files changed, 201 insertions(+), 30 deletions(-) diff --git a/edtf/parser/grammar.py b/edtf/parser/grammar.py index ae03251..f458b2b 100644 --- a/edtf/parser/grammar.py +++ b/edtf/parser/grammar.py @@ -162,7 +162,7 @@ def f(toks): # (* *** unspecified *** *) yearWithOneOrTwoOrThreeUnspecifedDigits = Combine( - digit + (digit ^ "X") + (digit ^ "X") + "X" + Optional("-") + digit + (digit ^ "X") + (digit ^ "X") + "X" )("year") monthUnspecified = year + "-" + L("XX")("month") dayUnspecified = yearMonth + "-" + L("XX")("day") diff --git a/edtf/parser/parser_classes.py b/edtf/parser/parser_classes.py index 0bbf855..43f4a9c 100644 --- a/edtf/parser/parser_classes.py +++ b/edtf/parser/parser_classes.py @@ -561,16 +561,13 @@ def __init__( int(significant_digits) if significant_digits else None ) self.ua = ua if ua else None + self.negative = self.year.startswith("-") def __str__(self): - r = self.year - if self.month: - r += f"-{self.month}" - if self.day: - r += f"-{self.day}" + base = super().__str__() if self.ua: - r += str(self.ua) - return r + base += str(self.ua) + return base def _get_fuzzy_padding(self, lean): if not self.ua: @@ -579,24 +576,16 @@ def _get_fuzzy_padding(self, lean): padding = relativedelta() if self.year: - if self.precision == PRECISION_MILLENIUM: - padding += relativedelta( - years=int( - multiplier * appsettings.PADDING_MILLENNIUM_PRECISION.years - ) - ) - elif self.precision == PRECISION_CENTURY: - padding += relativedelta( - years=int(multiplier * appsettings.PADDING_CENTURY_PRECISION.years) - ) - elif self.precision == PRECISION_DECADE: - padding += relativedelta( - years=int(multiplier * appsettings.PADDING_DECADE_PRECISION.years) - ) - else: - padding += relativedelta( - years=int(multiplier * appsettings.PADDING_YEAR_PRECISION.years) - ) + year_no_symbol = self.year.lstrip("-") + years_padding = self._calculate_years_padding(multiplier, year_no_symbol) + # Reverse the padding for negative years and earliest calculations + # if self.negative: + # years_padding = -years_padding if lean == EARLIEST else years_padding + # else: + # years_padding = years_padding if lean == EARLIEST else -years_padding + + padding += years_padding + if self.month: padding += relativedelta( months=int(multiplier * appsettings.PADDING_MONTH_PRECISION.months) @@ -608,6 +597,184 @@ def _get_fuzzy_padding(self, lean): return padding + def _calculate_years_padding(self, multiplier, year_no_symbol): + if self.precision == PRECISION_MILLENIUM: + return relativedelta( + years=int(multiplier * appsettings.PADDING_MILLENNIUM_PRECISION.years) + ) + elif self.precision == PRECISION_CENTURY: + return relativedelta( + years=int(multiplier * appsettings.PADDING_CENTURY_PRECISION.years) + ) + elif self.precision == PRECISION_DECADE: + return relativedelta( + years=int(multiplier * appsettings.PADDING_DECADE_PRECISION.years) + ) + else: + return relativedelta( + years=int(multiplier * appsettings.PADDING_YEAR_PRECISION.years) + ) + + def lower_fuzzy(self): + time_empty_time_tuple = tuple(TIME_EMPTY_TIME) + time_empty_extras_tuple = tuple(TIME_EMPTY_EXTRAS) + strict_val = ( + self.lower_strict() + ) # negative handled in the lower_strict() override + + if self.negative: + adjusted = apply_delta(sub, strict_val, self._get_fuzzy_padding(LATEST)) + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + adjusted = struct_time( + (adjusted.tm_year, 1, 1) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + elif self.precision == PRECISION_MONTH: + adjusted = struct_time( + (adjusted.tm_year, adjusted.tm_mon, 1) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + else: + adjusted = apply_delta(sub, strict_val, self._get_fuzzy_padding(EARLIEST)) + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + adjusted = struct_time( + (adjusted.tm_year, 1, 1) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + elif self.precision == PRECISION_MONTH: + days_in_month = calendar.monthrange(adjusted.tm_year, adjusted.tm_mon)[ + 1 + ] + adjusted = struct_time( + (adjusted.tm_year, adjusted.tm_mon, days_in_month) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + + return adjusted + + def upper_fuzzy(self): + time_empty_time_tuple = tuple(TIME_EMPTY_TIME) + time_empty_extras_tuple = tuple(TIME_EMPTY_EXTRAS) + strict_val = ( + self.upper_strict() + ) # negative handled in the upper_strict() override + + if self.negative: + adjusted = apply_delta(add, strict_val, self._get_fuzzy_padding(LATEST)) + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + adjusted = struct_time( + (adjusted.tm_year, 12, 31) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + elif self.precision == PRECISION_MONTH: + days_in_month = calendar.monthrange(adjusted.tm_year, adjusted.tm_mon)[ + 1 + ] + adjusted = struct_time( + (adjusted.tm_year, adjusted.tm_mon, days_in_month) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + else: + adjusted = apply_delta(add, strict_val, self._get_fuzzy_padding(LATEST)) + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + adjusted = struct_time( + (adjusted.tm_year, 12, 31) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + elif self.precision == PRECISION_MONTH: + adjusted = struct_time( + (adjusted.tm_year, adjusted.tm_mon, 1) + + time_empty_time_tuple + + time_empty_extras_tuple + ) + + return adjusted + + def lower_strict(self): + if self.negative: + strict_val = self._strict_date( + lean=LATEST + ) # gets the year right, but need to adjust day and month + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + return struct_time( + (strict_val.tm_year, 1, 1) + + tuple(TIME_EMPTY_TIME) + + tuple(TIME_EMPTY_EXTRAS) + ) + elif self.precision == PRECISION_MONTH: + days_in_month = calendar.monthrange( + strict_val.tm_year, strict_val.tm_mon + )[1] + return struct_time( + (strict_val.tm_year, strict_val.tm_mon, days_in_month) + + tuple(TIME_EMPTY_TIME) + + tuple(TIME_EMPTY_EXTRAS) + ) + else: + return strict_val + else: + return self._strict_date(lean=EARLIEST) + + def upper_strict(self): + if self.negative: + strict_val = self._strict_date(lean=EARLIEST) + if ( + self.precision == PRECISION_YEAR + or self.precision == PRECISION_DECADE + or self.precision == PRECISION_CENTURY + or self.precision == PRECISION_MILLENIUM + ): + return struct_time( + (strict_val.tm_year, 12, 31) + + tuple(TIME_EMPTY_TIME) + + tuple(TIME_EMPTY_EXTRAS) + ) + elif self.precision == PRECISION_MONTH: + days_in_month = calendar.monthrange( + strict_val.tm_year, strict_val.tm_mon + )[1] + return struct_time( + (strict_val.tm_year, strict_val.tm_mon, days_in_month) + + tuple(TIME_EMPTY_TIME) + + tuple(TIME_EMPTY_EXTRAS) + ) + else: + return strict_val + else: + return self._strict_date(lean=LATEST) + @property def precision(self): if self.day: @@ -615,13 +782,14 @@ def precision(self): if self.month: return PRECISION_MONTH if self.year: - if self.year.isdigit(): + year_no_symbol = self.year.lstrip("-") + if year_no_symbol.isdigit(): return PRECISION_YEAR - if len(self.year) == 4 and self.year.endswith("XXX"): + if len(year_no_symbol) == 4 and year_no_symbol.endswith("XXX"): return PRECISION_MILLENIUM - if len(self.year) == 4 and self.year.endswith("XX"): + if len(year_no_symbol) == 4 and year_no_symbol.endswith("XX"): return PRECISION_CENTURY - if len(self.year) == 4 and self.year.endswith("X"): + if len(year_no_symbol) == 4 and year_no_symbol.endswith("X"): return PRECISION_DECADE raise ValueError(f"Unspecified date {self} has no precision") diff --git a/edtf/parser/tests.py b/edtf/parser/tests.py index 464aca3..c89b3b8 100644 --- a/edtf/parser/tests.py +++ b/edtf/parser/tests.py @@ -81,6 +81,8 @@ ("1999-01-XX", ("1999-01-01", "1999-01-31")), # some day in 1999 ("1999-XX-XX", ("1999-01-01", "1999-12-31")), + # negative unspecified year + ("-01XX", ("-0199-01-01", "-0100-12-31")), # Uncertain/Approximate lower boundary dates (BCE) ("-0275~", ("-0275-01-01", "-0275-12-31", "-0276-01-01", "-0274-12-31")), ("-0001~", ("-0001-01-01", "-0001-12-31", "-0002-01-01", "0000-12-31")), @@ -92,6 +94,7 @@ ("1XXX", ("1000-01-01", "1999-12-31")), ("1XXX~", ("1000-01-01", "1999-12-31", "0000-01-01", "2999-12-31")), ("156X~", ("1560-01-01", "1569-12-31", "1550-01-01", "1579-12-31")), + ("-01XX~", ("-0199-01-01", "-0100-12-31", "-0299-01-01", "-0000-12-31")), # L1 Extended Interval # beginning unknown, end 2006 # for intervals with an unknown beginning or end, the unknown bound is calculated with the constant DELTA_IF_UNKNOWN (10 years) From c14a57b63846c5b94a00ae87c7ad16c37717ba6b Mon Sep 17 00:00:00 2001 From: Cole Crawford <16374762+ColeDCrawford@users.noreply.github.com> Date: Tue, 28 May 2024 13:51:47 -0400 Subject: [PATCH 3/3] Cleanup --- edtf/parser/parser_classes.py | 171 ++++++---------------------------- edtf/parser/tests.py | 2 +- 2 files changed, 32 insertions(+), 141 deletions(-) diff --git a/edtf/parser/parser_classes.py b/edtf/parser/parser_classes.py index 43f4a9c..a15cbf1 100644 --- a/edtf/parser/parser_classes.py +++ b/edtf/parser/parser_classes.py @@ -550,17 +550,14 @@ def __init__( ua=None, **kwargs, ): - for param in ("date", "lower", "upper"): - if param in kwargs: - self.__init__(**kwargs[param]) - return - self.year = year # Year is required, but sometimes passed in as a 'date' dict. - self.month = month - self.day = day - self.significant_digits = ( - int(significant_digits) if significant_digits else None + super().__init__( + year=year, + month=month, + day=day, + significant_digits=significant_digits, + **kwargs, ) - self.ua = ua if ua else None + self.ua = ua self.negative = self.year.startswith("-") def __str__(self): @@ -576,16 +573,8 @@ def _get_fuzzy_padding(self, lean): padding = relativedelta() if self.year: - year_no_symbol = self.year.lstrip("-") - years_padding = self._calculate_years_padding(multiplier, year_no_symbol) - # Reverse the padding for negative years and earliest calculations - # if self.negative: - # years_padding = -years_padding if lean == EARLIEST else years_padding - # else: - # years_padding = years_padding if lean == EARLIEST else -years_padding - + years_padding = self._years_padding(multiplier) padding += years_padding - if self.month: padding += relativedelta( months=int(multiplier * appsettings.PADDING_MONTH_PRECISION.months) @@ -594,127 +583,32 @@ def _get_fuzzy_padding(self, lean): padding += relativedelta( days=int(multiplier * appsettings.PADDING_DAY_PRECISION.days) ) - return padding - def _calculate_years_padding(self, multiplier, year_no_symbol): - if self.precision == PRECISION_MILLENIUM: - return relativedelta( - years=int(multiplier * appsettings.PADDING_MILLENNIUM_PRECISION.years) - ) - elif self.precision == PRECISION_CENTURY: - return relativedelta( - years=int(multiplier * appsettings.PADDING_CENTURY_PRECISION.years) - ) - elif self.precision == PRECISION_DECADE: - return relativedelta( - years=int(multiplier * appsettings.PADDING_DECADE_PRECISION.years) - ) - else: - return relativedelta( - years=int(multiplier * appsettings.PADDING_YEAR_PRECISION.years) - ) + def _years_padding(self, multiplier): + """Calculate year padding based on the precision.""" + precision_settings = { + PRECISION_MILLENIUM: appsettings.PADDING_MILLENNIUM_PRECISION.years, + PRECISION_CENTURY: appsettings.PADDING_CENTURY_PRECISION.years, + PRECISION_DECADE: appsettings.PADDING_DECADE_PRECISION.years, + PRECISION_YEAR: appsettings.PADDING_YEAR_PRECISION.years, + } + years = precision_settings.get(self.precision, 0) + return relativedelta(years=int(multiplier * years)) def lower_fuzzy(self): - time_empty_time_tuple = tuple(TIME_EMPTY_TIME) - time_empty_extras_tuple = tuple(TIME_EMPTY_EXTRAS) strict_val = ( self.lower_strict() ) # negative handled in the lower_strict() override - - if self.negative: - adjusted = apply_delta(sub, strict_val, self._get_fuzzy_padding(LATEST)) - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM - ): - adjusted = struct_time( - (adjusted.tm_year, 1, 1) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - elif self.precision == PRECISION_MONTH: - adjusted = struct_time( - (adjusted.tm_year, adjusted.tm_mon, 1) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - else: - adjusted = apply_delta(sub, strict_val, self._get_fuzzy_padding(EARLIEST)) - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM - ): - adjusted = struct_time( - (adjusted.tm_year, 1, 1) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - elif self.precision == PRECISION_MONTH: - days_in_month = calendar.monthrange(adjusted.tm_year, adjusted.tm_mon)[ - 1 - ] - adjusted = struct_time( - (adjusted.tm_year, adjusted.tm_mon, days_in_month) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - + adjusted = apply_delta(sub, strict_val, self._get_fuzzy_padding(EARLIEST)) return adjusted def upper_fuzzy(self): - time_empty_time_tuple = tuple(TIME_EMPTY_TIME) - time_empty_extras_tuple = tuple(TIME_EMPTY_EXTRAS) strict_val = ( self.upper_strict() ) # negative handled in the upper_strict() override - if self.negative: - adjusted = apply_delta(add, strict_val, self._get_fuzzy_padding(LATEST)) - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM - ): - adjusted = struct_time( - (adjusted.tm_year, 12, 31) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - elif self.precision == PRECISION_MONTH: - days_in_month = calendar.monthrange(adjusted.tm_year, adjusted.tm_mon)[ - 1 - ] - adjusted = struct_time( - (adjusted.tm_year, adjusted.tm_mon, days_in_month) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - else: - adjusted = apply_delta(add, strict_val, self._get_fuzzy_padding(LATEST)) - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM - ): - adjusted = struct_time( - (adjusted.tm_year, 12, 31) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - elif self.precision == PRECISION_MONTH: - adjusted = struct_time( - (adjusted.tm_year, adjusted.tm_mon, 1) - + time_empty_time_tuple - + time_empty_extras_tuple - ) - + adjusted = apply_delta(add, strict_val, self._get_fuzzy_padding(LATEST)) return adjusted def lower_strict(self): @@ -722,11 +616,11 @@ def lower_strict(self): strict_val = self._strict_date( lean=LATEST ) # gets the year right, but need to adjust day and month - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM + if self.precision in ( + PRECISION_YEAR, + PRECISION_DECADE, + PRECISION_CENTURY, + PRECISION_MILLENIUM, ): return struct_time( (strict_val.tm_year, 1, 1) @@ -734,11 +628,8 @@ def lower_strict(self): + tuple(TIME_EMPTY_EXTRAS) ) elif self.precision == PRECISION_MONTH: - days_in_month = calendar.monthrange( - strict_val.tm_year, strict_val.tm_mon - )[1] return struct_time( - (strict_val.tm_year, strict_val.tm_mon, days_in_month) + (strict_val.tm_year, strict_val.tm_mon, 1) + tuple(TIME_EMPTY_TIME) + tuple(TIME_EMPTY_EXTRAS) ) @@ -750,11 +641,11 @@ def lower_strict(self): def upper_strict(self): if self.negative: strict_val = self._strict_date(lean=EARLIEST) - if ( - self.precision == PRECISION_YEAR - or self.precision == PRECISION_DECADE - or self.precision == PRECISION_CENTURY - or self.precision == PRECISION_MILLENIUM + if self.precision in ( + PRECISION_YEAR, + PRECISION_DECADE, + PRECISION_CENTURY, + PRECISION_MILLENIUM, ): return struct_time( (strict_val.tm_year, 12, 31) diff --git a/edtf/parser/tests.py b/edtf/parser/tests.py index c89b3b8..199f245 100644 --- a/edtf/parser/tests.py +++ b/edtf/parser/tests.py @@ -94,7 +94,7 @@ ("1XXX", ("1000-01-01", "1999-12-31")), ("1XXX~", ("1000-01-01", "1999-12-31", "0000-01-01", "2999-12-31")), ("156X~", ("1560-01-01", "1569-12-31", "1550-01-01", "1579-12-31")), - ("-01XX~", ("-0199-01-01", "-0100-12-31", "-0299-01-01", "-0000-12-31")), + ("-01XX~", ("-0199-01-01", "-0100-12-31", "-0299-01-01", "0000-12-31")), # L1 Extended Interval # beginning unknown, end 2006 # for intervals with an unknown beginning or end, the unknown bound is calculated with the constant DELTA_IF_UNKNOWN (10 years)