From f0f9102771e261a01697c7afd681655135e2e40b Mon Sep 17 00:00:00 2001 From: Serhii A Date: Fri, 23 Jan 2026 14:08:35 +0100 Subject: [PATCH 001/107] Add tests to cover Finnish dates with 'klo' (#1301) * Add tests to cover Finnish dates with 'klo' * Add Finnish "klo" (o'clock) to skip tokens and add translation test - Add "klo" to skip tokens in Finnish language data files - Modified: dateparser/data/date_translation_data/fi.py - Modified: dateparser_data/supplementary_language_data/date_translation_data/fi.yaml - Add translation test case for Finnish dates with "klo" - Modified: tests/test_languages.py This fixes parsing of Finnish dates like "28 maalis klo 9:37" (March 28 at 9:37). The word "klo" (abbreviation for "kello", meaning "o'clock") is now properly skipped during tokenization, allowing correct date parsing. --- dateparser/data/date_translation_data/fi.py | 1 + .../date_translation_data/fi.yaml | 2 +- tests/test_date_parser.py | 5 +++++ tests/test_languages.py | 1 + 4 files changed, 8 insertions(+), 1 deletion(-) diff --git a/dateparser/data/date_translation_data/fi.py b/dateparser/data/date_translation_data/fi.py index 3b8f7646e..ecc6762f1 100644 --- a/dateparser/data/date_translation_data/fi.py +++ b/dateparser/data/date_translation_data/fi.py @@ -316,6 +316,7 @@ "locale_specific": {}, "skip": [ ":n", + "klo", " ", "'", ",", diff --git a/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml b/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml index 71e5fd24f..377aeef97 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml @@ -1,4 +1,4 @@ -skip: [":n"] +skip: [":n", "klo"] sentence_splitter_group : 1 diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 654d37777..d343e647e 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -214,6 +214,11 @@ def setUp(self): # Finnish dates param("5.7.2018 5.45 ip.", datetime(2018, 7, 5, 17, 45)), param("5 .7 .2018 5.45 ip.", datetime(2018, 7, 5, 17, 45)), + param("28 maalis klo 9:37", datetime(2012, 3, 28, 9, 37)), + param("28 maalis 9:37", datetime(2012, 3, 28, 9, 37)), + param("15 tammi klo 14:30", datetime(2012, 1, 15, 14, 30)), + param("5 kesä klo 18:00", datetime(2012, 6, 5, 18, 0)), + param("12.5.2020 klo 16:45", datetime(2020, 5, 12, 16, 45)), # Croatian dates param("06. travnja 2021.", datetime(2021, 4, 6, 0, 0)), param("13. svibanj 2022.", datetime(2022, 5, 13, 0, 0)), diff --git a/tests/test_languages.py b/tests/test_languages.py index 111ef266b..1ba280794 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -214,6 +214,7 @@ def setUp(self): param("fi", "su joulu 16, 2015", "sunday december 16 2015"), param("fi", "1. tammikuuta, 2016", "1. january 2016"), param("fi", "tiistaina, 27. lokakuuta 2015", "tuesday 27. october 2015"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), # Japanese param("ja", "午後3時", "pm 3:00"), param("ja", "2時", "2:00"), From d2e236f0b4c465e285422e86704b9b7c659840cf Mon Sep 17 00:00:00 2001 From: Serhii A Date: Sat, 31 Jan 2026 16:11:00 +0100 Subject: [PATCH 002/107] Fix explicit +/- signs in relative date offsets (#1303) * Add tests for relative date time offset parsing * Fix explicit +/- signs in relative date offsets * Update tests/test_date_parser.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- dateparser/freshness_date_parser.py | 44 +++++++++--- tests/test_date_parser.py | 107 ++++++++++++++++++++++++++++ 2 files changed, 142 insertions(+), 9 deletions(-) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 024fe023e..8dc8f489e 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -10,7 +10,7 @@ from .timezone_parser import pop_tz_offset_from_string _UNITS = r"decade|year|month|week|day|hour|minute|second" -PATTERN = re.compile(r"(\d+[.,]?\d*)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) +PATTERN = re.compile(r"([+-]?\d+[.,]?\d*)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) class FreshnessDateDataParser: @@ -112,7 +112,13 @@ def _parse_date(self, date_string, now, prefer_dates_from): if not self._are_all_words_units(date_string): return None, None - kwargs = self.get_kwargs(date_string) + result = self.get_kwargs(date_string) + if isinstance(result, tuple): + kwargs, explicit_signs = result + else: + kwargs = result + explicit_signs = {} + if not kwargs: return None, None period = "day" @@ -121,16 +127,27 @@ def _parse_date(self, date_string, now, prefer_dates_from): if k in kwargs: period = k[:-1] break - td = relativedelta(**kwargs) - if ( + going_forward = ( re.search(r"\bin\b", date_string) or re.search(r"\bfuture\b", prefer_dates_from) and not re.search(r"\bago\b", date_string) - ): - date = now + td - else: - date = now - td + ) + + adjusted_kwargs = {} + for key, value in kwargs.items(): + if explicit_signs.get(key, False): + adjusted_kwargs[key] = value + else: + if going_forward: + adjusted_kwargs[key] = value + else: + adjusted_kwargs[key] = -value + + td = relativedelta(**adjusted_kwargs) + + date = now + td + return date, period def get_kwargs(self, date_string): @@ -139,12 +156,21 @@ def get_kwargs(self, date_string): return {} kwargs = {} + explicit_signs = {} + for num, unit in m: + has_explicit_sign = num.startswith("+") or num.startswith("-") + explicit_signs[unit + "s"] = has_explicit_sign kwargs[unit + "s"] = float(num.replace(",", ".")) + if "decades" in kwargs: kwargs["years"] = 10 * kwargs["decades"] + kwargs.get("years", 0) + if "decades" in explicit_signs: + explicit_signs["years"] = explicit_signs["decades"] del kwargs["decades"] - return kwargs + explicit_signs.pop("decades", None) + + return kwargs, explicit_signs def get_date_data(self, date_string, settings=None): from dateparser.date import DateData diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index d343e647e..c461d1f4a 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -6,6 +6,7 @@ from parameterized import param, parameterized import dateparser.timezone_parser +from dateparser import parse from dateparser.date import DateDataParser, date_parser from dateparser.date_parser import DateParser from dateparser.parser import _parse_absolute @@ -1345,6 +1346,82 @@ def test_dates_with_no_day_or_month( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) + @parameterized.expand( + [ + param( + "yesterday +1h", + lambda base: base - timedelta(days=1) + timedelta(hours=1), + "Yesterday plus 1 hour", + ), + param( + "yesterday +2h", + lambda base: base - timedelta(days=1) + timedelta(hours=2), + "Yesterday plus 2 hours", + ), + param( + "yesterday +30m", + lambda base: base - timedelta(days=1) + timedelta(minutes=30), + "Yesterday plus 30 minutes", + ), + param( + "yesterday -1h", + lambda base: base - timedelta(days=1) - timedelta(hours=1), + "Yesterday minus 1 hour", + ), + param( + "yesterday -2h", + lambda base: base - timedelta(days=1) - timedelta(hours=2), + "Yesterday minus 2 hours", + ), + param( + "yesterday -30m", + lambda base: base - timedelta(days=1) - timedelta(minutes=30), + "Yesterday minus 30 minutes", + ), + param( + "tomorrow +1h", + lambda base: base + timedelta(days=1) + timedelta(hours=1), + "Tomorrow plus 1 hour", + ), + param( + "tomorrow +3h", + lambda base: base + timedelta(days=1) + timedelta(hours=3), + "Tomorrow plus 3 hours", + ), + param( + "tomorrow -1h", + lambda base: base + timedelta(days=1) - timedelta(hours=1), + "Tomorrow minus 1 hour", + ), + param( + "tomorrow -2h", + lambda base: base + timedelta(days=1) - timedelta(hours=2), + "Tomorrow minus 2 hours", + ), + ] + ) + def test_relative_date_with_time_offset( + self, date_string, offset_calculator, description + ): + """Ensure +/- signs in time offsets are parsed correctly.""" + base_date = datetime(2026, 1, 19, 12, 0, 0) + expected = offset_calculator(base_date) + + result = parse( + date_string, + settings={ + "RELATIVE_BASE": base_date, + "RETURN_AS_TIMEZONE_AWARE": False, + }, + ) + + self.assertIsNotNone(result, f"Failed to parse: {description}") + self.assertEqual( + expected, + result, + f"{description}: Expected {expected}, got {result}", + ) + def given_local_tz_offset(self, offset): self.add_patch( patch.object( @@ -1354,6 +1431,36 @@ def given_local_tz_offset(self, offset): ) ) + def test_yesterday_plus_and_minus_expected_values(self): + """Verify correct time offset calculations for yesterday.""" + # Base: 2026-01-08 21:38:10 + base_date = datetime(2026, 1, 8, 21, 38, 10) + + plus_result = parse( + "yesterday +1h", + settings={"RELATIVE_BASE": base_date, "RETURN_AS_TIMEZONE_AWARE": False}, + ) + minus_result = parse( + "yesterday -1h", + settings={"RELATIVE_BASE": base_date, "RETURN_AS_TIMEZONE_AWARE": False}, + ) + + # Expected: 2026-01-07 22:38:10 (yesterday at same time, plus 1 hour) + expected_plus = datetime(2026, 1, 7, 22, 38, 10) + # Expected: 2026-01-07 20:38:10 (yesterday at same time, minus 1 hour) + expected_minus = datetime(2026, 1, 7, 20, 38, 10) + + self.assertEqual( + expected_plus, + plus_result, + f"'yesterday +1h' should be {expected_plus}, got {plus_result}", + ) + self.assertEqual( + expected_minus, + minus_result, + f"'yesterday -1h' should be {expected_minus}, got {minus_result}", + ) + def given_parser(self, *args, **kwds): def collecting_get_date_data(parse): @wraps(parse) From 0e87891bbcb848c23dac2bf3df6ca6635d5b9eeb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adri=C3=A1n=20Chaves?= Date: Wed, 4 Feb 2026 16:54:55 +0100 Subject: [PATCH 003/107] Release notes for 1.3.0 (#1305) --- HISTORY.rst | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/HISTORY.rst b/HISTORY.rst index 84c405f8e..0b56a98d7 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,6 +3,31 @@ History ======= +1.3.0 (unreleased) +------------------ + +Dropped Python 3.9 support. (#1296) + +New features: + +- ``search_dates()`` can now detect time spans from expressions like “past + month”, “last week”, etc. For details, see the “Time Span Detection” section + and the ``RETURN_TIME_SPAN``, ``DEFAULT_START_OF_WEEK`` and + ``DEFAULT_DAYS_IN_MONTH`` settings in the documentation. (#1284) + +Fixes: + +- Assume the current year if not specified (#1288) +- Support expressions like “yesterday +1h” (#1303) +- English: Support most 2-letter day-of-the-week names (#1214) +- English: Support “in N weeks' time” (#1283) +- Finnish: Support dates with “klo” (#1301) +- Russian: Support compound ordinals (#1280) + +Cleanups and internal improvements: + +- Fixed year expectation issues in tests. (#1294) + 1.2.2 (2025-06-26) ------------------ From c2ff31c648dc1eb4e35f4edf588126861cc54d9c Mon Sep 17 00:00:00 2001 From: Adrian Chaves Date: Wed, 4 Feb 2026 16:55:40 +0100 Subject: [PATCH 004/107] =?UTF-8?q?Bump=20version:=201.2.2=20=E2=86=92=201?= =?UTF-8?q?.3.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- HISTORY.rst | 2 +- dateparser/__init__.py | 2 +- pyproject.toml | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/HISTORY.rst b/HISTORY.rst index 0b56a98d7..992a5d960 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,7 +3,7 @@ History ======= -1.3.0 (unreleased) +1.3.0 (2026-02-04) ------------------ Dropped Python 3.9 support. (#1296) diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 3629ac057..634f2748d 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,4 +1,4 @@ -__version__ = "1.2.2" +__version__ = "1.3.0" from .conf import apply_settings from .date import DateDataParser diff --git a/pyproject.toml b/pyproject.toml index 8b7623422..c1b06db6c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [tool.bumpversion] -current_version = "1.2.2" +current_version = "1.3.0" commit = true tag = true From 24dac43aa8547c30054e99ab19d47bc1282a6704 Mon Sep 17 00:00:00 2001 From: trevor-scale <113459356+trevor-scale@users.noreply.github.com> Date: Wed, 4 Feb 2026 08:37:22 -0800 Subject: [PATCH 005/107] Allow md5hash to function in fips environments (#1267) --- dateparser/conf.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/dateparser/conf.py b/dateparser/conf.py index 73eab5f63..8dab177df 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -52,7 +52,9 @@ def get_key(cls, settings=None): return "default" keys = sorted(["%s-%s" % (key, str(settings[key])) for key in settings]) - return hashlib.md5("".join(keys).encode("utf-8")).hexdigest() + return hashlib.md5( + "".join(keys).encode("utf-8"), usedforsecurity=False + ).hexdigest() @classmethod def _get_settings_from_pyfile(cls): From 35e7f61f72a9e26ab88ef697b2f0caa128aca72a Mon Sep 17 00:00:00 2001 From: Prashant Sharma <31796326+gutsytechster@users.noreply.github.com> Date: Thu, 5 Feb 2026 22:00:52 +0530 Subject: [PATCH 006/107] Use different timezones to run CI tests (#1259) --- .github/workflows/main.yml | 10 +++++++++- tests/test_search.py | 2 +- tox.ini | 1 + 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b17e70667..cb397b116 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -30,6 +30,12 @@ jobs: toxenv: docs - python-version: "3.14" toxenv: twinecheck + - python-version: "3.13" + toxenv: py + timezone: "Pacific/Auckland" + - python-version: "3.13" + toxenv: py + timezone: "Pacific/Fiji" steps: - uses: actions/checkout@v3 - name: 'Set up Python ${{ matrix.python-version }}' @@ -43,7 +49,9 @@ jobs: python -m pip install --upgrade pip pip install tox - name: Run tests - run: tox -e ${{ matrix.toxenv || 'py' }} + run: | + TZ=${{ matrix.timezone || 'UTC' }} echo "Running tests with timezone: $TZ" + TZ=${{ matrix.timezone || 'UTC' }} tox -e ${{ matrix.toxenv || 'py' }} - name: Upload coverage.xml to codecov uses: codecov/codecov-action@v5 with: diff --git a/tests/test_search.py b/tests/test_search.py index 7c3b3322e..47e380cf7 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -11,7 +11,7 @@ from dateparser_data.settings import default_parsers from tests import BaseTestCase -today = datetime.datetime.today() +today = datetime.datetime.now(tz=pytz.timezone("UTC")) class TestTranslateSearch(BaseTestCase): diff --git a/tox.ini b/tox.ini index 05b10493c..ec567268b 100644 --- a/tox.ini +++ b/tox.ini @@ -13,6 +13,7 @@ deps = atheris; python_version < '3.12' commands = pytest --cov=dateparser --cov-report=xml {posargs: tests} +passenv = TZ [testenv:all] basepython = python3.14 From 0f0419944c000f59f214d68f10a3f6488a0ef67e Mon Sep 17 00:00:00 2001 From: branislavroljic <58853003+branislavroljic@users.noreply.github.com> Date: Thu, 5 Feb 2026 17:32:00 +0100 Subject: [PATCH 007/107] Add Bosnian Cyrillic (ijekavica) date translations (#1293) --- .../data/date_translation_data/bs-Cyrl.py | 132 +++++++++++++----- .../date_translation_data/bs-Cyrl.yaml | 113 +++++++++++++++ tests/test_languages.py | 22 +++ 3 files changed, 235 insertions(+), 32 deletions(-) create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml diff --git a/dateparser/data/date_translation_data/bs-Cyrl.py b/dateparser/data/date_translation_data/bs-Cyrl.py index c07a696f8..0b3951a41 100644 --- a/dateparser/data/date_translation_data/bs-Cyrl.py +++ b/dateparser/data/date_translation_data/bs-Cyrl.py @@ -50,7 +50,8 @@ ], "monday": [ "пон", - "понедељак" + "понедељак", + "понедјељак" ], "tuesday": [ "уто", @@ -74,53 +75,77 @@ ], "sunday": [ "нед", - "недеља" + "недеља", + "недјеља" ], "am": [ - "пре подне" + "пре подне", + "пријеподне" ], "pm": [ - "поподне" + "поподне", + "послијеподне" ], "year": [ - "година" + "година", + "г", + "год", + "годинa" ], "month": [ - "месец" + "месец", + "мј", + "мјесец", + "мјесеци", + "мјесеца" ], "week": [ - "недеља" + "недеља", + "сед", + "седмица", + "седмице" ], "day": [ "дан" ], "hour": [ - "час" + "час", + "сат" ], "minute": [ - "минут" + "минут", + "мин", + "минута" ], "second": [ - "секунд" + "секунд", + "с", + "сек", + "секунда" ], "relative-type": { "0 day ago": [ "данас" ], "0 hour ago": [ - "this hour" + "this hour", + "овај сат" ], "0 minute ago": [ - "this minute" + "this minute", + "ова минута" ], "0 month ago": [ - "овог месеца" + "овог месеца", + "овај мјесец" ], "0 second ago": [ - "now" + "now", + "сада" ], "0 week ago": [ - "ове недеље" + "ове недеље", + "ове седмице" ], "0 year ago": [ "ове године" @@ -129,10 +154,12 @@ "јуче" ], "1 month ago": [ - "прошлог месеца" + "прошлог месеца", + "прошли мјесец" ], "1 week ago": [ - "прошле недеље" + "прошле недеље", + "прошле седмице" ], "1 year ago": [ "прошле године" @@ -141,43 +168,68 @@ "сутра" ], "in 1 month": [ - "следећег месеца" + "следећег месеца", + "сљедећи мјесец" ], "in 1 week": [ - "следеће недеље" + "следеће недеље", + "сљедеће седмице" ], "in 1 year": [ - "следеће године" + "следеће године", + "сљедеће године" ] }, "relative-type-regex": { "\\1 day ago": [ "пре (\\d+[.,]?\\d*) дан", - "пре (\\d+[.,]?\\d*) дана" + "пре (\\d+[.,]?\\d*) дана", + "прије (\\d+[.,]?\\d*) дан", + "прије (\\d+[.,]?\\d*) дана" ], "\\1 hour ago": [ "пре (\\d+[.,]?\\d*) сат", - "пре (\\d+[.,]?\\d*) сати" + "пре (\\d+[.,]?\\d*) сати", + "прије (\\d+[.,]?\\d*) сат", + "прије (\\d+[.,]?\\d*) сати" ], "\\1 minute ago": [ "пре (\\d+[.,]?\\d*) минут", - "пре (\\d+[.,]?\\d*) минута" + "пре (\\d+[.,]?\\d*) минута", + "прије (\\d+[.,]?\\d*) мин", + "прије (\\d+[.,]?\\d*) минута", + "прије (\\d+[.,]?\\d*) минуту" ], "\\1 month ago": [ "пре (\\d+[.,]?\\d*) месец", - "пре (\\d+[.,]?\\d*) месеци" + "пре (\\d+[.,]?\\d*) месеци", + "прије (\\d+[.,]?\\d*) мј", + "прије (\\d+[.,]?\\d*) мјесец", + "прије (\\d+[.,]?\\d*) мјесеца", + "прије (\\d+[.,]?\\d*) мјесеци" ], "\\1 second ago": [ "пре (\\d+[.,]?\\d*) секунд", - "пре (\\d+[.,]?\\d*) секунди" + "пре (\\d+[.,]?\\d*) секунди", + "прије (\\d+[.,]?\\d*) сек", + "прије (\\d+[.,]?\\d*) секунда", + "прије (\\d+[.,]?\\d*) секунду" ], "\\1 week ago": [ "пре (\\d+[.,]?\\d*) недеља", - "пре (\\d+[.,]?\\d*) недељу" + "пре (\\d+[.,]?\\d*) недељу", + "прије (\\d+[.,]?\\d*) сед", + "прије (\\d+[.,]?\\d*) седмица", + "прије (\\d+[.,]?\\d*) седмице", + "прије (\\d+[.,]?\\d*) седмицу" ], "\\1 year ago": [ "пре (\\d+[.,]?\\d*) година", - "пре (\\d+[.,]?\\d*) годину" + "пре (\\d+[.,]?\\d*) годину", + "прије (\\d+[.,]?\\d*) г", + "прије (\\d+[.,]?\\d*) год", + "прије (\\d+[.,]?\\d*) година", + "прије (\\d+[.,]?\\d*) годину" ], "in \\1 day": [ "за (\\d+[.,]?\\d*) дан", @@ -189,23 +241,39 @@ ], "in \\1 minute": [ "за (\\d+[.,]?\\d*) минут", - "за (\\d+[.,]?\\d*) минута" + "за (\\d+[.,]?\\d*) минута", + "за (\\d+[.,]?\\d*) мин", + "за (\\d+[.,]?\\d*) минута", + "за (\\d+[.,]?\\d*) минуту" ], "in \\1 month": [ "за (\\d+[.,]?\\d*) месец", - "за (\\d+[.,]?\\d*) месеци" + "за (\\d+[.,]?\\d*) месеци", + "за (\\d+[.,]?\\d*) мј", + "за (\\d+[.,]?\\d*) мјесец", + "за (\\d+[.,]?\\d*) мјесеца", + "за (\\d+[.,]?\\d*) мјесеци" ], "in \\1 second": [ "за (\\d+[.,]?\\d*) секунд", - "за (\\d+[.,]?\\d*) секунди" + "за (\\d+[.,]?\\d*) секунди", + "за (\\d+[.,]?\\d*) сек", + "за (\\d+[.,]?\\d*) секунда", + "за (\\d+[.,]?\\d*) секунду" ], "in \\1 week": [ "за (\\d+[.,]?\\d*) недеља", - "за (\\d+[.,]?\\d*) недељу" + "за (\\d+[.,]?\\d*) недељу", + "за (\\d+[.,]?\\d*) сед", + "за (\\d+[.,]?\\d*) седмица", + "за (\\d+[.,]?\\d*) седмицу", + "за (\\d+[.,]?\\d*) седмице" ], "in \\1 year": [ "за (\\d+[.,]?\\d*) година", - "за (\\d+[.,]?\\d*) годину" + "за (\\d+[.,]?\\d*) годину", + "за (\\d+[.,]?\\d*) г", + "за (\\d+[.,]?\\d*) год" ] }, "locale_specific": {}, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml new file mode 100644 index 000000000..9953707f7 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml @@ -0,0 +1,113 @@ +am: + - пријеподне +pm: + - послијеподне + +monday: + - понедјељак + +sunday: + - недјеља + +year: + - г + - год + - годинa + +month: + - мј + - мјесец + - мјесеци + - мјесеца + +week: + - сед + - седмица + - седмице + +hour: + - сат + +minute: + - мин + - минута + +second: + - с + - сек + - секунда + +relative-type: + 0 hour ago: + - овај сат + 0 minute ago: + - ова минута + 0 month ago: + - овај мјесец + 0 second ago: + - сада + 0 week ago: + - ове седмице + 1 month ago: + - прошли мјесец + 1 week ago: + - прошле седмице + in 1 month: + - сљедећи мјесец + in 1 week: + - сљедеће седмице + in 1 year: + - сљедеће године + +relative-type-regex: + \1 day ago: + - прије (\d+[.,]?\d*) дан + - прије (\d+[.,]?\d*) дана + \1 hour ago: + - прије (\d+[.,]?\d*) сат + - прије (\d+[.,]?\d*) сати + \1 minute ago: + - прије (\d+[.,]?\d*) мин + - прије (\d+[.,]?\d*) минута + - прије (\d+[.,]?\d*) минуту + \1 month ago: + - прије (\d+[.,]?\d*) мј + - прије (\d+[.,]?\d*) мјесец + - прије (\d+[.,]?\d*) мјесеца + - прије (\d+[.,]?\d*) мјесеци + \1 second ago: + - прије (\d+[.,]?\d*) сек + - прије (\d+[.,]?\d*) секунда + - прије (\d+[.,]?\d*) секунду + \1 week ago: + - прије (\d+[.,]?\d*) сед + - прије (\d+[.,]?\d*) седмица + - прије (\d+[.,]?\d*) седмице + - прије (\d+[.,]?\d*) седмицу + \1 year ago: + - прије (\d+[.,]?\d*) г + - прије (\d+[.,]?\d*) год + - прије (\d+[.,]?\d*) година + - прије (\d+[.,]?\d*) годину + + in \1 minute: + - за (\d+[.,]?\d*) мин + - за (\d+[.,]?\d*) минута + - за (\d+[.,]?\d*) минуту + in \1 month: + - за (\d+[.,]?\d*) мј + - за (\d+[.,]?\d*) мјесец + - за (\d+[.,]?\d*) мјесеца + - за (\d+[.,]?\d*) мјесеци + in \1 second: + - за (\d+[.,]?\d*) сек + - за (\d+[.,]?\d*) секунда + - за (\d+[.,]?\d*) секунду + in \1 week: + - за (\d+[.,]?\d*) сед + - за (\d+[.,]?\d*) седмица + - за (\d+[.,]?\d*) седмицу + - за (\d+[.,]?\d*) седмице + in \1 year: + - за (\d+[.,]?\d*) г + - за (\d+[.,]?\d*) год diff --git a/tests/test_languages.py b/tests/test_languages.py index 1ba280794..cffc8e329 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -334,6 +334,17 @@ def setUp(self): # bs-Cyrl param("bs-Cyrl", "2 септембар 2000, четвртак", "2 september 2000 thursday"), param("bs-Cyrl", "1 јули 1987 9:25 поподне", "1 july 1987 9:25 pm"), + param("bs-Cyrl", "1 јули 1987 9:25 послијеподне", "1 july 1987 9:25 pm"), + param( + "bs-Cyrl", + "понедјељак, 1 јули 1987 9:25 пријеподне", + "monday 1 july 1987 9:25 am", + ), + param( + "bs-Cyrl", + "недјеља, 2 септембар 2000 7:00 послијеподне", + "sunday 2 september 2000 7:00 pm", + ), # bs-Latn param("bs-Latn", "23 septembar 1879, petak", "23 september 1879 friday"), param( @@ -1396,6 +1407,17 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("bs-Cyrl", "следећег месеца", "in 1 month"), param("bs-Cyrl", "прошле године 10:05 пре подне", "1 year ago 10:05 am"), param("bs-Cyrl", "пре 28 недеља", "28 week ago"), + param("bs-Cyrl", "сљедећи мјесец", "in 1 month"), + param("bs-Cyrl", "сљедеће седмице", "in 1 week"), + param("bs-Cyrl", "сљедеће године", "in 1 year"), + param("bs-Cyrl", "прије 4 мјесеца", "4 month ago"), + param("bs-Cyrl", "прије 2 седмице", "2 week ago"), + param("bs-Cyrl", "прошли мјесец", "1 month ago"), + param("bs-Cyrl", "прошле седмице", "1 week ago"), + param("bs-Cyrl", "овај мјесец", "0 month ago"), + param("bs-Cyrl", "ове седмице", "0 week ago"), + param("bs-Cyrl", "за 2 мјесеца", "in 2 month"), + param("bs-Cyrl", "за 3 седмице", "in 3 week"), # bs-Latn param("bs-Latn", "sljedeće godine", "in 1 year"), param("bs-Latn", "prije 4 mjeseci", "4 month ago"), From 169c4ce94b90095c07c83dd497f8f80f74cc869b Mon Sep 17 00:00:00 2001 From: Gabriel Nyman <1233346+gnyman@users.noreply.github.com> Date: Thu, 5 Feb 2026 18:34:26 +0200 Subject: [PATCH 008/107] New browser based demo (#1306) The demo has been broken for a long time #1173 and #1188 I played around with GitHub Spark throw and put together a in-browser demo, and then used claude to decouple it from Spark. It doesn't require any python backend but runs it in the browser with Pyodide, thus should be easier and cheaper to host. It could even be brought into this repository to make it a official demo. --- README.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 31a0b6add..6106107f7 100644 --- a/README.rst +++ b/README.rst @@ -64,7 +64,7 @@ Online demo ----------- Do you want to try it out without installing any dependency? Now you can test -it quickly by visiting `this online demo `__! +it quickly by visiting `this online demo `__! From 6ca550f631baa7f1de0d3f6dbc21bfae55158523 Mon Sep 17 00:00:00 2001 From: Justin Keogh Date: Thu, 5 Feb 2026 09:35:13 -0700 Subject: [PATCH 009/107] Allow 'N {interval} from now' (#502) (#1271) --- dateparser/data/date_translation_data/en.py | 1 + .../date_translation_data/en.yaml | 2 +- tests/test_freshness_date_parser.py | 16 ++++++++++++++++ 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index ffa7a6de4..042a896c2 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -756,6 +756,7 @@ "and", "at", "by", + "from", "just", "m", "nd", diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index 9e888f388..dab056b1d 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -1,4 +1,4 @@ -skip: ["about", "ad", "and", "at", "by", "just", "m", "nd", "of", "on", "rd", "st", "th", "the"] +skip: ["about", "ad", "and", "at", "by", "from", "just", "m", "nd", "of", "on", "rd", "st", "th", "the"] pertain: ["of"] sentence_splitter_group : 1 diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 0ba2d60fe..5f790dc66 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -1808,6 +1808,22 @@ def test_normalized_relative_dates(self, date_string, ago, period): param("3 hours later", in_future={"hours": 3}, period="day"), param("4 minutes later", in_future={"minutes": 4}, period="day"), param("5 seconds later", in_future={"seconds": 5}, period="day"), + # from now + param("7 years from now", in_future={"years": 7}, period="year"), + param("6 months from now", in_future={"months": 6}, period="month"), + param("5 weeks from now", in_future={"weeks": 5}, period="week"), + param("4 days from now", in_future={"days": 4}, period="day"), + param("3 hours from now", in_future={"hours": 3}, period="day"), + param("2 minutes from now", in_future={"minutes": 2}, period="day"), + param("1 second from now", in_future={"seconds": 1}, period="day"), + param("five years from now", in_future={"years": 5}, period="year"), + param("a year from now", in_future={"years": 1}, period="year"), + param("an hour from now", in_future={"hours": 1}, period="day"), + param( + "1 year 2 months from now", + in_future={"years": 1, "months": 2}, + period="month", + ), # Fractional units param("in 2.5 hours", in_future={"hours": 2.5}, period="day"), param("in 10.75 minutes", in_future={"minutes": 10.75}, period="day"), From cd5f226454e0ed3fe93164e7eff55b00f57e57c7 Mon Sep 17 00:00:00 2001 From: Mrinal Jain Date: Thu, 5 Feb 2026 12:19:38 -0500 Subject: [PATCH 010/107] Honor `REQUIRE_PARTS` for ambiguous month-number inputs by retrying year-biased `DATE_ORDER` (#1298) --- dateparser/date.py | 56 ++++++++++++++++++++++++++++------------- tests/test_clean_api.py | 47 ++++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+), 17 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index e23444720..12b05d4ba 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -275,26 +275,48 @@ def _try_nospaces_parser(self): return self._try_parser(parse_method=_parse_nospaces) def _try_parser(self, parse_method): - _order = self._settings.DATE_ORDER + original_order = self._settings.DATE_ORDER + + # Use locale date order unless DATE_ORDER was explicitly set by the caller. + if ( + self._settings.PREFER_LOCALE_DATE_ORDER + and "DATE_ORDER" not in self._settings._mod_settings + ): + first_order = self.locale.info.get("date_order", original_order) + else: + first_order = original_order + + candidates = [first_order] + + # If the caller requires a year (and not a day) and did not set DATE_ORDER, + # retry once or twice with year-biased orders to resolve month-number ambiguity. + require_parts = set(getattr(self._settings, "REQUIRE_PARTS", None) or []) + if ( + "DATE_ORDER" not in self._settings._mod_settings + and "year" in require_parts + and "day" not in require_parts + ): + for order in ("MYD", "YMD"): + if order not in candidates: + candidates.append(order) + + translated = self._get_translated_date() + try: - if self._settings.PREFER_LOCALE_DATE_ORDER: - if "DATE_ORDER" not in self._settings._mod_settings: - self._settings.DATE_ORDER = self.locale.info.get( - "date_order", _order + for order in candidates: + self._settings.DATE_ORDER = order + try: + date_obj, period = date_parser.parse( + translated, + parse_method=parse_method, + settings=self._settings, ) - date_obj, period = date_parser.parse( - self._get_translated_date(), - parse_method=parse_method, - settings=self._settings, - ) - self._settings.DATE_ORDER = _order - return DateData( - date_obj=date_obj, - period=period, - ) - except ValueError: - self._settings.DATE_ORDER = _order + return DateData(date_obj=date_obj, period=period) + except ValueError: + continue return None + finally: + self._settings.DATE_ORDER = original_order def _try_given_formats(self): if not self.date_formats: diff --git a/tests/test_clean_api.py b/tests/test_clean_api.py index 4ed18a7b3..5f75f81d9 100644 --- a/tests/test_clean_api.py +++ b/tests/test_clean_api.py @@ -185,6 +185,53 @@ def test_dates_which_do_not_match_locales_are_not_parsed( self.when_date_is_parsed(date_string, locales=locales) self.then_date_was_not_parsed() + @parameterized.expand( + [ + param(date_string="Oct-23", expected_date=datetime(2023, 10, 1, 0, 0)), + param(date_string="May-23", expected_date=datetime(2023, 5, 1, 0, 0)), + ] + ) + def test_require_parts_month_year_parses_month_year( + self, date_string, expected_date + ): + # Regression: when year is required, Mon-YY should be interpreted as month-year. + base = datetime(2050, 1, 1, 0, 0) + self.when_date_is_parsed_with_settings( + date_string, + settings={ + "RELATIVE_BASE": base, + "PREFER_DAY_OF_MONTH": "first", + "PREFER_DATES_FROM": "past", + "REQUIRE_PARTS": ["month", "year"], + }, + ) + self.then_parsed_date_and_time_is(expected_date) + + def test_require_parts_does_not_override_explicit_date_order(self): + # Explicit DATE_ORDER must be respected. + base = datetime(2050, 1, 1, 0, 0) + self.when_date_is_parsed_with_settings( + "Oct-23", + settings={ + "RELATIVE_BASE": base, + "REQUIRE_PARTS": ["month", "year"], + "DATE_ORDER": "MDY", + }, + ) + self.then_date_was_not_parsed() + + def test_require_parts_month_day_parses_month_day(self): + # If day is required, Mon-XX should remain month-day. + base = datetime(2000, 1, 1, 0, 0) + self.when_date_is_parsed_with_settings( + "Oct-23", + settings={ + "RELATIVE_BASE": base, + "REQUIRE_PARTS": ["month", "day"], + }, + ) + self.then_parsed_date_and_time_is(datetime(2000, 10, 23, 0, 0)) + def when_date_is_parsed_with_defaults(self, date_string): self.result = dateparser.parse(date_string) From e0939ecdd7ca04a24ca9d9a325224fe7fef7921c Mon Sep 17 00:00:00 2001 From: Laurie O Date: Tue, 10 Feb 2026 12:13:31 +1000 Subject: [PATCH 011/107] Replace 'setup.py install' (#1310) It's soon to be removed from setuptools --- .github/workflows/publish.yml | 4 ++-- CONTRIBUTING.rst | 2 +- docs/installation.rst | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 6948242c4..fd57bf955 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -17,11 +17,11 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install setuptools wheel twine + pip install build twine - name: Build and publish env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} run: | - python setup.py sdist bdist_wheel + python -m build . twine upload dist/* diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 31d179b05..d988e614d 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -76,7 +76,7 @@ installed, this is how you set up your fork for local development:: $ mkvirtualenv dateparser $ cd dateparser/ - $ python setup.py develop + $ pip install -e . 4. Create a branch for local development:: diff --git a/docs/installation.rst b/docs/installation.rst index 9148904c9..d80cb9f3c 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -14,4 +14,4 @@ If you want to install from the latest sources, you can do:: $ git clone https://github.com/scrapinghub/dateparser.git $ cd dateparser - $ python setup.py install + $ pip install . From 8cdcf800ff16a0745b4782359db0c8085961219d Mon Sep 17 00:00:00 2001 From: Laurie O Date: Tue, 10 Feb 2026 12:26:26 +1000 Subject: [PATCH 012/107] Make logo more translucent (#1312) --- README.rst | 2 +- artwork/dateparser-logo.png | Bin 64203 -> 20319 bytes artwork/dateparser.xcf | Bin 102863 -> 104684 bytes 3 files changed, 1 insertion(+), 1 deletion(-) diff --git a/README.rst b/README.rst index 6106107f7..51a3ad7f1 100644 --- a/README.rst +++ b/README.rst @@ -5,7 +5,7 @@


- Dateparser + Dateparser

diff --git a/artwork/dateparser-logo.png b/artwork/dateparser-logo.png index ac052cf5765885be43058d215ecc498c81073bc0..9ee7c692444f7ece0e9c3203f46b52bb658cabdd 100644 GIT binary patch literal 20319 zcmb?@g&aR2aK+< z?H&HU@B0_L7Z)45_gv>W@wv}A_c`YwT3b_@hLV+%fPjETRYg&kfPknN|Mxoi4gBkE zZ(j%e8_ApJ8qWy`suQTLtV!{o2|aa{V2nZz82?zjgnaw)V_%CkQs4FWH;I4nZv=x28uTZ$D7<&>BfbL%Z68aU$ z`QR7Hyi_%m$hL_ns3iI0!+nNf)OEiIK4di|A&_^2^n9MYb4+@aJpZF zK%Ec&Xhyy86xj#DiN2#ZG^|A6RT;|vmPKN$5fO+mgc_i57rV7T;{41~H02)~#rGww zw3b^C{ETG|Q*XHUp`xGuTbCkQSb0MC zw(#CfyfBIaiws`r^b~K$`e74h9nRb2y=upLdTKunt~UZETuF%#YmlOE6pwQXPK1*AUAgblh|ml zT`B43L%evsiRFT@d);Kg#KD0fmIRQHAD~y17ipR|D!YOVm7IizM}Bkg0b7a$rPPM* z;VDKL+FCBlT5-GGf|pUH!3bNDvToL~H?qz=8=8LnSKw;?Yaw3kqn{H=>(KiQ%ihZj z%N-&9h!0qq*xvM!ZAVe_fv9n{-&Ep+jb=j+{t>hy*e9@KXqzZ%3n@t1j=lI)=$Y$t zensfmp1MrS-;iA>_fO4_IvpA1#Z9%_>^5eCW#zp1mMDl8okS`-Xrjw=< z56XAyR3NxT=ckeo`l2OxTT0HBg&yqBfU{emG|CK zV0CP((HR-~c#x2k+OzmC%OEW13M~!&~*d zrclGM<{!~dW@P1r?SEEbgv0x&=?_`xz=rKj zAZkl~&_j|;d}4#{&>AFaMr@||rmWPSHqZb*%tBhYlqQL~)*U^~8#drAyN8An_VoMG zhO=G-hV3F*XfM(I;EYPXnW*jZBBpd~a>hT$Gh`D8xOX$pK>*%b%+|scN9uSk`|O&B zif5TvX%n2l=&@MP>?g#Kqsc!L#@;v2B!P{ohsa>iB8*GpRx-PYE3F1Syb0@Svlmy! zIpizZ{#lUdd2lPy%ii3R&M~S8HF+)NT#@?h?A&!^J<&-75mF9de)Hz!KLOb&lO5Tu zJ-Jimw;vAb2E5D3nM4Sxi~)M5YJGrwDfY4rM(|c=xtmKc zsnSB|+OsS|;DNs@QJ7w6J&pPzG%W+pCtm;aMDXy>02E7%(;xq5+uL`-y#M5Et+Lrt zpb2G3S~Yx59w?z2XxDsD32GI%N-axbv#s$;ga096lmxkD?NwQ~2)MPiM3-AL;&47# z;7QVG&jHXjchfidd!u7jd9wDOus6DcM-e5mi*(`=894cO;=2f-^Ig10>tuT!GoGSE zvh6&2p7noK*r2=mK^VEM^`ky}J>-oF&^fnhqANi1=f=X{RjDNKXv8&SS$~cM1FC=O zK;X+oiDceHS)Mt4HYcXwi4J?veeIS#3?HuxXWoCe7kM7_-rf3JWCH5eBTqn9SZ>!F zS+{V!64Ffy#UawRY;P`Gw?=CtC$6~-5KwzEDSe25f_t#~R#93xf4akr<@z1q?HV`M ziz!S)&3~FSjft$=e*m2QcudFm(qvp^xx`_-#GH8U#wzRE2*t4b!Zu0}XI_{d>Cj%1MDcKl^By^-ST|K%z z?t$2P7!r{99}cag200J-fOQiVywFHfn}_ed@thZZJuIw{e-xT0ABw#gtv&k3ez^UO zmPAFDqAe{SH+}lz+>0H@| z5g!qdTV?m`DbZFTngS|Bd9pjXA{#bdwg6C*3ZnJ>Mb5DP&8I0kqD)PH0?32@pBBPA zg*YcHZ5LWT+fL~OR}m54b!YufIBko^WSDY%8i7Zj?#avknkdvr=`L#9T-&g&GtG7!_&%^S)esA{$L#(or_nLaLG_ zPpx2_BTC3}qIc-V9tY3gWrJ%uWU1&_WtO`_$O|<Dj8}P$=>rZ?L0YuqtWTbRSl`V+i;zm&Xuh(37)EslXBODjb=^O}}-Qulek@^Pp zz|wLWU4ET)CwKeM!CS5pUGrKN!?5g8UTXBR$;LH~YRsR8F|F?MN;54Qzhy=P$%(9< zaCWdE4@r@ys4t$OSS~}nXG-bqLy&^gt}=O64%`9d=GDY*t{-|<-rvLQQ8d55_Qu&G z&fv7&vh~%+vm$?De!W#s>23&jDeP$FOGRwUCtE@wGtdg#Fz4jLAmPU}hyFL=@4Rboro>iQT#NxBk z93g>|m&;rLtk$L9Cchld$qGSgtdCm=MEu6lU7Aj3WAteJ>o-vg6qHHXFxz8@7*Nhd z;3DsT(l99g62n;IGO4ol?*3_#OVxb9QeZ7kc>Y$wUw8adh3MMJN z_HsXMZrLpi5R0K}+p4#p6Obi)p^7Ssw20YG_fK!rN)KETzC(kMev+O+m%!JbJ)AWH}igc|_(sbsd zChCJAmD;c>X-kDl%t^ zcV}oKQcuS*?z1hIfmtGk;3lUKm1c~s1;Hg+2&`PB2TeQAn79h`cDhbIa*e~k?LK)f;P%utWE7u>XXaC#TjiXVsbtP) zGZwg?VLNQwlVzf%@>U^a=`U@BW%6RZ>9{E5f7)Wpj^LDLH-(mlP13@%LX1t(m#$E@ z0dv;oQy8lMactKpS`i(TnXr^+s&LK!&`Lx4>wUguKY(@4zWOj_ZYlpv;T(YAkH@(1O&KmfcsYH_&YNFygU5c_3 zy45%v@goN^8x0PH!p(|fe`pTNaj1Jvj7Jf7*%hv{@9i?^J{{^U&%YUrv+rtO3^!I3 zJHljy6;!LW*a8du&Y&uK%#R;akN-!|U0n6==@9tYguiT+U~0qTfq>b)TihKv;4wI(@Cy036ozn)=Ywiz9WIKj9)%^8`c3+|~E$t*xS05F5I7;C}{-z{j;> z0pjXoC6vu`;Q^KA{7Bm*B)iw?6Pi$O6OqLa>9H5?98qhWyTn%{HHP)982BsP#${}m ze|juYdTbXzV3K>pI>kKo>0Cb3 zz-u+QEA#|BB-U}wZ2RK-FOIts$t=2o#T|usN#S4QHdjrz{%7Wz%}8$svQB>j7ONv_ zRksOwU;xBiEg!T;DsT6JWvQbV0T5O{qlR_f8oX2@bvZ>DZ^1PO>8r&4gGr5eQqT0` zgh{WC(O&!FC@;ZO567oj*uY@Wzi{O0_rhhtx1n^|idsWRq6et>~2V*&09 za$5&=*=ozHc^y>89Q1BZM6`ofPU)GRP>WL|K^76D>Jf*9bLgv9sxiLyJIAdAC3{^3 z;N>aSLH1RnQ3=ACsgc#!ve;*RPdR!+|8hm|$vyw?u;Bi{jaW5!(0*AhndGWQXkgwB z!R)0e>MaE?$bgsp4QZ?XQg0*#TTWEt55lUtBOS=I1Ag?A5f>FZTr*RtlTk98?5T4| znR@@|6>xfk$0|awh7rjl%X)ruUxyL-5HSq0QS!X?{E zk-NO3Xj?efb?lLkdRIegCqu*1P=Zhbw-2f!=&CDMQ5T1uXSLl*I}pdN!pDS-Bs28q zcc&&{caUjc+eSL%lB(l?OB3k-QdJhb_c%QQ$K)R69SDO|2v4JX9LN)A^)+Vnvv0(c z;eERb8G#njQJ$yxtflzjD^p#g%hu(vpo|Oy{04o%PO3VYonUKzUKSKoNu^_!xwp65 z&fu1yHFEKWCUsUtBw-D!>;BkK+v?GjInFnygWB`Y%wYeLS_O>E4nlfsr5mUHFTH0h z9^yJrlnwQstcqXXMRu1UUM`ak>RvYIgwa~!_!%t?M*TQQD?5{qU4xr!Yi*TCX-{5f zANsozuRf`-);N{{|AdwQLkh3<=jR+$p~hh;2X}UeUaJGd#jFe`y}`4&T8SiMB=_KxXOFB;zrvJYdiej#*%8hHhvLScNM^C@qP_)4Y_a@8#F7Fb86yELzy= z{#^YR!}ejJ4dx<(;mdh?%M*R=48!dyC4fa+Bh`pv`cHC#j39OMMCj1;#iOjd=LQbN z{+UG5t1HKL%g`LGP2V@}TsfIXK~E1I=!&lm5cTugL1#dOVt)$(~N#kc75e&X7Y`J`9?XN|+7`rAx!*F4A2?tMO)Hr4H?XJ;PRX1Sa&zwl;C)e9Q%9mUMK7<`vzvu1sov=uS6GBS7PU?TZ@&I25zKL z>yD2>OA^i!JrA8+KL_2;X+mgY9{r2UuU~BwF3_Mg{AFI<`3(Fu7lboqY5G7QhF zj+Do1P#}4&QpowgD z8u3ai2FL`=*QtElXz=qZWz-vEEr8EB5Q4D)J=Te|)Z5F8CqscBh!Mj9DS;Up50G+s)#dvz5A2_AA zPs8Wl^8JJ2VTYi}`Wlh^aoO#0Ei24bamBEMH+|v3n|iDZ9^m@&uH?zv3C4XsJwzGx zWG^n>+{YJwXjrNt_t%Xsoq@kfZkgI*^GusJcil$OoWuIXZr)?~w?Z5cqDs^YoH{{V( zFHdV@k070GF3L!83AO)+6bv`>wdPPQj1Ca)nmg46dMZsyOS##%w}|Xx2hxfkXW}_k z(ZUjAs;Tm2gktUB+qDJZMxPrL79$7Xe=i}`!G#pOhTqI;_twDJv37h>fN{OS&ztvG zC~WP9EJrHl-aeYep{gY~f!Y4E2L;RO2oVklAIx5?-z6n+wLfaYj%hnhoevC%BGRtJ zQ3&8yV>H98wV0J|pNvQbuabel5!brYtUYv-r`;$@FWP{cRqF}vu2;fzcDu|Dn6}5m zWG~9Q$Tik`uFt%>S`@CO7Vc%m9Cq3ZEEXi#uGysI%CM31li2xz%X~op^mJ=v3diW15uY}Gxkt~3soL=#SU|k`QChNml1FNTQZZj)~!2UO# zO{iqdFv~^^)-xdEnezlEwuU&;M`WvUmi0iY!oyr-rE`H@$sy@ zi+Gc0n$|3*P6%T3HBgQTDKW!6-E7;< zpsV%nK9Z&%m^;4@r@V@4R@wTQE5Waj`R*_?%?A2jAt=2&_j3B8 zR=i^)N2mkw!lNj5+((k^eahXx3OpDe0JnM5!_3d4P&PQ!pzwuxPM9!k`Ge5XT-e=F z)|-cZvOC?MpVWJEs6yuqSI9&ei}En6vdx1hEFZuHWh<6p@3Q6Tic;xv3>k~8VO^0H z&nhAmwU~-h>YcO>6{bZkSr>*vn`x#BaD2(SxobYFMQN`6x_j^YgI+4zB%MUmXRT4v z10iA6l~R7a&MHJRNGGxzQIQVOhpIX z?vMAG%h}omQ>zaAfJ47tBc3A!ltRiyD=ZuPaOt}l^>aT+ zso+=6?0ZjeOd14y2p`r1yN%$J>J)19H$=qdca`t5e|SU_yq(EH{HXR-!e*WM zQXR|kUb?fQVY2ZTqjv7ZZXO|?WBm9FRU~hIYV!k=N@l-L+oj1Gh0V2Z#;;hHCVRJRWGn`7VJMnW%=7%G{OP4FStE;F zn(Ecrr+>3QWCv7DUpAUt(DB^)`=A^Rabk=$E1{uJwfrN$0YHoh2`ndrrXUrAm>^C! zTDuZzdAC9o8u^e=j43v^O3Xi58ori^^s&UUFKsBq0MWMr=m=oRpLEU}vSxkWfO>C7 znz>c+<(Ig{5z#)D6HsjW}u9TM5D5*tdb4_b)Y@|ZwaO68V>AlBejY=d9an638XS@$Q7T5 zEOiO7t6UQ-+PLLn_D!>!ZRrX2vI?1}?u3Spx2F`0<$gd+zPKoFyrnW{P{fY0)(@Ns zt6RH`i}zWARodV^s%NVcdLw8zHQxHqLsy%UWycn1XJ%x_%Quz_pJRc6z+7wC-oi3? za$$+8vdf89YXJomEn;%0HZI%jfl!yUuU-4LFE_TOJ3EeE_li(V4e z;tu(o7w{(@d`wr?LTwA?J$fax`#RS`Nvb*L*^up2J(X&?%UUJ^zH6&*g;fz*2@&J|9@uz92y9hPPbr3uP?0(e@r7Me55`;(CogNHgAQId6I4t&#N*1 zv7k+BdZvM^rmlLXLJIpG>o_l)puCiGre#9X@u%AW;V^pK0BIyBlby`!btu>nUl;9= z(>iv#3<0Gsl{8?Q_Bw)8E0f8bT?6e;ZY0f4N*MG&&tT6}3R+KbwiOSw#Sq&*DAm`h zXK6OiwU-JGpT)ffw@-S6Bg6;$Pl7CcZ?CsB_MF-30m`(R>;ubaoyGE~-C1=7BF5kn z<$Nrm0qDeX`2#!|5P_3(Rphkr+Qik#l+q@(XL!I9EDC z&8Bbev+_#ptyCldmJRt0*AhE{t_JOf1t(Z{KJW*$)oK3f$fz{u4i#UR?cJJD$y`)g zaW$nOQ<8sxLf1VwAxd&t0!w2Crzr}Y`lsM=nuP6JOI7a+wc^{CqKrvu{B9rpmTr$e z>mM+mukyF@XYX}bM2&uEtFYj=&YFh!j|TS0n-+96wnWd_QRHOtI+jb3`e} zj6B|p4ikxj=Uj5H%;KxXWyl8RjLUcIn&|$X*%ChK%x#cJ4G;P};qlpOEB|R1Floak z!~$STXv#e~Aqk-W;Ka*n*96{s@El*n={hg~o>K$C$h)GF2}VjA`JDU8oH(eObfo7I zf7YWSN)|{ z)UZnXh?ivYJO<=#jb3^g7i5e*e;eR?;~qSxtB1MM)))Lve44}q4=u!GcU+@1m&owt zF!q`+ptFlNN&^iA;U)zykCz@8wsJ*{qnaN;dlJY7V*<3}W*yRDQ_bQS5td!36cXL@ zZWT&r$1rGZOpB$wn%S6?B%M|PRzvCA$=(1x4MRLV(oo2E;AM*^>H5oSZ?kfy#e@gk z+Ik*>xfVu0TF4+Hy-s(pPv^}M&uDB8iPKTme4)+}azY)ZcSqCK(-vjT>qdPcpK62! z_SJwfa#2-WiHaFHK6YHfT>*r(hnUGvLr-1=b;MT#7YBVZW z_J+=W0~23yu8(B;M9$>@T*5pMYU%Q}wAVGIxb9O|d?LRhOobLF2NlIuyYy^%GmcpH z0BgFkCz-QCgYh0^rv3NsIQvzC{BP;LHpg!P|3D>A&Z z-T~l$6?b4e-x;z0bK($^>o9#Gfs?hPksd!o&v}dIuwCr)0GYvq@36UEE=eaj_G2<0 zCQ1HFUGpM)ni{wplPT61niR4F4WiRY%hFBf?@QYMl8%$S^c;xJzcH= z4Nf}l6u=zO-%Zws&{}{W{s2f$ zKhOMqE0)yQC>4Y67)Bv9Cdm)nak@`_DghWmguA?eaWV2YW$8}6Pl=3Pr#s? zHl1$i2H)PuOF$kcVvMPx6Bu$NY&r5YIT(%+m@i7~is9+M11#WHMzUdve!bZB)EP$1 z-@a^yH_>`}&%EynadhU@S#V7{|Kk#0uxpaWcvQFIH5el^Hn%F8vqg7&XB)s=@PMIR|M!$}AK#*%kgrR;G1sFLWFJ4*(C;f(L-N1OQ!00_h^)@u|*JJq^IeNKvIS}QbQAFV6mOv@;ga$ zPy7{UAnz@PaIE&SQ?!NPR=XP*%AiIN3qHz3NVzm zHSIWP2|O%yYL_4qCI2ZPWI5!~;}E6Rk;J(v@)>FWOtqVa~!}8;*mK z41;g>DVFbp8{~KmAhQrQBLlcrk?ssiB*B;iouufow71Jfa@a&8-q4A$qEAiv^O=`r z>3kkH+4}_iJnXD7(ITwCqm+z0a`QAj;>;2|hdOe?1ryn@#u&Mj0wNd>IZ>ejj(x3a zz`vhu4Y6uXla}lFejLC-qapv)E(y4;e7E^L?3u(5CCeqsshrq?lni-D^J$p)Z(^iP zTV{{))2l@RS@yxRLu(*Jhn7lPf=nICsmltv%a|4xTr@DBvz8<-I03@I&C(OBv00q` z&0}wLTljU1Uv@W-aC!=7bSKZcqE;`8H5AaxD-vEMTKoQD(+-?f+z0+LQT zFQZMXC^eKXE?V!2LLS)tSdjL{Y~&r-fwd9@g)my_5kcMW{Y^h!uvH~C+J7A2mo)8D zLPm$v*2$l-lq{J4J@H8+)-h#e=B*=~!kCx0G$+zK6?tlo1h{>0MH>UP9R&x~Sc#g} zt+62;`(&c&b)w{*8r9^NNb^h=B+=tLP7+h&VM1~XK9p$0daw+B*rgeb)`jGr+8p0? zwIi-x&91OV@}o zSLc|5o$Z)qL%kAli0(>lT|`Mwi9KHuzf~ zB(TKApjXC*rm3--oBW*e#7?*tQss#wk zwRqkBr3Ci>6>von36UT}(qcJSq8^9lmo>=QU9fGe3MwKseg53;6XQNG-QBRM?v|5M zviWvv{6QvEpmJ73I)jC%0IRe+5MJmnw_fUYiv?aYJSRxr6~B4Q5@E)}5noxyhCz=N zYalyeOrIK*laSc8d-GutY9r9}v9T-~-Z{XDiX0%N@Mpk6Rd@ff*l(t<$w;+ywM?~q zwR}p7iEWZ)fca(tOaQE6iAYZ9P_YrE?m9uqR&k(H&mzx_FxJv@O6yvfuZx6(9!b(m z8xfe#dtKgf2{};)s;tqZiV;@ur%QX=jHg=<00Iu&9bK^d`p%Su{I)?&vY?l8qhFlt zf^%y0%x>X6^!x;%$t{DMyn~H(x`l^&c(&=vS7oy;{sc&g{ox3DU^`3Hv7X&^INV1P zdtArMvX#}gu#x;K&hJYMm~oa*)pG%A^}u3akSqq?Ngs>*s@5dyEbtpOuW0&- zEaVTbW`2U-kG|TFqG^YnUCJ(OuPQ6gEmc3C9>@db3vxf?mgM0p@5U}YTd}=NuxFe5 z<=x;d`o1^l3Gq0-OKg5%_F=EHyi_MAW-sh~e)t3snpRzFKX7Hz!d#<2QhJz8%W`#e zGX21vpH~+T5H03n31Dg9I1y1bF_oGm9TjjkVi;STpl!^WrTd%yoR_7?liO|*?K@at zCA2<$!3PMok}b+Jiz=+)Y*p3OJZ83(BY&?8)VZk=^wgHcwvq(1l__w%W{<|Oc~!h8 zbm?xsP{_sTfV~UBU|*|F?XTrdL03}eZfTOcs{&x?LFkkM>*-b%GV4hVR0jgYr98L#cqvz*?jRO|#~uHK8@y zwvx89&RWeeC(It2nx8v$qBA$h6}??0s%16Rw`?agY3Vj)-6VC^Ro<@fcnb1`;%w0! zx;P#*gNiQk8nzyDN%IPqW4!*;Ip3PCpxhQ zz>K?`Xi{B|DF9xmxSk=_WoWrTjfKBf0?BZfhgBf?8H~iykbxxoZ2nGsuI8E`f17qTSPF8*0vL6|G}OEP68$C$|IFDv4Vg6tNlzy?J`F#rBN|wn zz0Wr&c;ExAqeY(+t;_E7+u`+3inIplhJAiv7(b4B`lmfmWc8BrinVd#OzNHh`5qbe z_qb(o^Y#ktjwdI5fL}BRmwsMadR?<6z8&sx++Y5l`}dV?x~Q`yK)CbFMReWtc9525 zdeugrxAc0#1xk9C$MXqb5Y|(wtbtI=sC-%BOJH|F6kD0i9{r69UU@YDzf($_cd}^o z$`bow2T?4vt2Bt(uL5ZrwG=P4g-n0fgvwU&Ro}AQ>A$q}I%OM9Qp|$g9#|%@>%1z9 z-7z^5fs3&$*Tgpb*1__)tMY1gSLZi1Qk*T^8?9qHN{q$6dGOYH$c86tfpoaHd_e$X z0xc)S`A%)2jG`{dr(Wnp3mJ-aJV*&3Rh3cQDBhC=i(yRw#@sZ&M#1z3@jamdud)&@ z-U0&=Pe7L(o&1j@YL#&#y>Bju-bPS?;a@&m5u(Fmceup+ly@Z~x_(@63jS#&8Fg=t z#n1@hhJVmBK6UYRuc>R8%v6!K)OZ6M+5Z%3{D@FiLH9XQQ*I=u@<3L0Pms1ul_<#P z0J68bA*o?@Z0&e+uSq&9Y}@Wa{kH5b8&)2!Q9B&=8rydPb%s@v_HJ=S>lufIhgZ`V zfFC;!{Qwa?<=e_#3gOKfCR1fRggs&ub4JLtFSbguqXf;4BYtXES#SAkB7h|u)(dFk z_Npi5&sukF(2ocC&*M?3ZV;DmRQS9HCE1st#J5NXaDxn=qX(#GaVZ$NVgXRw>N(L< zVQhpwU>xrp@oTXEEe;tIGmDx`j%=mDA13t8KA!Y8Us91$_x?axx{g5rY4`C5xJLXe zTzevKmho~q$8k>0OIV9HfX2Dvo8V#2E<2BbY;`Wj#9;!k6@w#NcVbnXJXYCn+mojs zToF&~A@gLns}r#EE`PTQ56U+p@U>#D-0KB?!53G8u?!SlBG1d)-d#}0#u<0v=W*V0 zxVvK_HfNN-LA`-0x3fZl3Nh--5($96wF`D8)< z9V8=Tz%pX_2LDaAJvcO5|Hb5u5dM%SNHV9yy1vH6Qa!wctQIXIDA=7uHt{z=dB= zAL_K!4o`P?SZ}4bM;K?^zdVM5hsS@#$pVn2aU-5`$w9Evqv(IVM-F*bu&lTTAgtohx*x7?p} z1|qs&ZZJ$GoOnvno?W2EeiJn^Pq8nCtSMHc;U*W;MLn9Rs$_)3!efIj$p=mRUNE?~ zCi5ntDFL-k@YzGl_axg%V540j0IRQ+`OrX~v-jG~#-2Glw&ZUq&J!I@u=kd9a{a)$ zn|c0KiM;bU^2w2+EK7n+^hNj4ttR{Ab{C6tus~_m#re#fZo1_B3zLr~a#{4)+n5f>~uMlVR>4N!(vF8|o;}tMW#j!S-vO$O{b)J*&C2L=sH{fiH9? zo?@N753!*)=P8DJ=Wo8Si_%khEJ(75-*rCJQ&RMP**%WUAinLT!y`F)m~!6BkcFCkbo2S(iquiw}iNO3q$PtCf{&< zGchG1(MI)r&$`O7CH;|`h1Wcf-U^uoP@T>&)=+v|CG~flU3kK`WnHb>-*bPfA+8ah zYA*BEEC1-A@&@nkQD^SJ<-f{cG0YNN<;o_U?1#GSohZI?&XxW)1Kz21^p!NriJWv@ z#dx#*Ssm}x&&0yA?1eU}R?JcQnoCOT#8+9l-FTsB-jE>B>_+6~9d<2VM5%_S$c>sH z3*>GC7o!(vuII%_1mgaW`t|G=x&s{BrZ3W{89HdzSE*F1LtPbjQ+=y5P6uYSVS0>( z^0klGUK{`pYHiF%RaBkNxgTRj$~lEC9&NPT zf>0sb7pbV?Gh&Uu`FK~K1OkJL1dPB(P#Qh8=!^J8#h8zAwcD*RsWZ2OsU;aXgqD# zl{M!n#ssrbi|N1U-b72tUTKw+{bBC_EUIrX=`W-t zLGOIl>o6O@OGX|&!SS*pG@sVnA5B3h^~Ux# z(PCG*YZzq7g`hobE!~WA9)&if{G9mroSH7D=^ zX$MM!-3+yjTBF2Q1oq+LZ4@<+i+;0~y=AeOnJqD|4=dafF4yjNg_qxP6*HmUb~TTB zN7+;N2u|m}fMzW2Rn*!S4I1EVgmnUq1+AtUIv;X>@_c@zM$^0H4&I+EOg9iB$qHhp za=H8#J9z-INK0$PDDfILfxTpwyN9YPceqE}cRq5jv@klm&&?Z09zoKma(#u=w`kMr z1mM9Z7&~G%+o=KQ!>=4cy0ANSWa+WJ;g8QyT!10x^xn&7gG99JYQkg#J^N{o8(P%+ zY8||ri^fPP?%8~z9+M7xZ8rn(RQE&7!SD%!oCMiGyf7J6`c*a7hV3+XPn)-6lVZgS zx2Eoq0#^ErZwm{#IEP67iugU1Zm{bCJ16_|O)KO?68`sG&yiQNq5q0WtTTC25b@I; z)R&uE)pd0rK4jpuQ)yK0)Wz+Jb zSOt63c@29mc%g+Mt+53_ACIp&@rz{QHwEYd!(l{kYM?)>b$gCjT^n4LR*t!rDF%Jd zeVOl|?{vH%doj*Y+KmwrR@leoBfgROeTL2S`f(uL{X}hle=df6nlX8@G9j7t`KM4A$z^-*+4-a#0k3BqY9f zOjiBVzz9ELsRIUVdja&d1D*%_=0!To0rHN_s3Ug=Pi!gYT7?@9uN>rnUNT$WSoPf$UJFGGqZ_YGCe3Aqac`txm zLq|_g?7*55%%3$q!vguZ=;mf7e)frJUiVejZSbGqFii7RUc*sd$?27TEEaa>@3bMu zc`4O|48|hx<|tEAso~~gm;P&omZF&tf^TrMc*PE~02O%& z*m2*m#TJ;pu<=$eFFUVFAKBtahwXSs8Zq*xn8Tk{wwZ03sp$Un65f}?!Z}#jkH&c~ zUg8>hmMFy5`klO>Bfi2M<&7xSA-VC9>FH+rUa9<3I@gf~%*}Z=`H~s*k70$3UPnLy zJ9Mb0!<}W{6qvY|`8ZzcG;lr-abhr#v412imXPjHo|7vuq}lG;Iqk>fmSw5+q}n1R zG0EzdYL(&>i9S?>(N)CS6DY1DnwfP*16IaZk{e`=7m{H^ryVYuZ$jm`f0KHJkNnF* z>|430h}$IxYBOY1L6VOdpZdeT!`N&7X2%)RdFpd`dEHTE!ZDQ#oZV)G4atK1Sdy7I zqVlR6hUoo_b7eNV>RDd8xi`;RDvn{lOe?M&)0w|@`aFS+BwNmtotLV^+%ZS{S-jMR zPy@9=E;(Z6nH(y~*(Lg8E_YE@*zdxVK2PEf0p&sO#M=a$+go_prO%jQO|$XClSLNJ zhp^r!(DFRY%&gGB9xu>-mnB+{n^!YdNAnEo%N+16zdrt%dF(|dX{SdWC^AZ|zw%kM=h z>b&1DaZWJhYdMn}^OR$EQ2JIXHUmQao#cCNyvm z+|gcnx}~6!j1@~>N@7wZznV{gJb~Q?-)if@KP+LeQri-%Kgx<9cIfby4I1OLQ|CE2 zpeuKRygvTynv_-c?GDH%iOsic#AmdXd0$}AqlqxJbhDHn>hv`>ljU+W4q~DO|>0MmC=mHT|cYApJ$Zg?$Z+Wq)($NiN z9`RUTGhhQ6>#ewQ;W8LnFcylR1)z<+{=WcM_a=?SJD4GIIr)^}!G8YvQ<+x)qV#BE zmW{-Z){jyeKfaC6e}#N7SoNe4cqgn$MnwLj<`MGb^XTygreObevWRX6uatTyezp*( zi7%zp5uH#1vbj69>Om9h%5&L!N0Ey1hsxkYodPp?UB}u5&TR?ctpC$}Vjv}yev0&> zjX%M&IdZy`MrZaG)%Oh4D$;DQPxWt_54ZNX`TE-9i8GWNW5;xBPS}j(84vz3 z+Q0L_6nPkZWHr=EdtX5#c1fpQE9~yUofy&9)f`)4C&#+FP2Yre*G-}T+{EKZefUCu zNCHcG10v#;)VhT($eqnKjPwdJd-eo0dTA;Nh%DyA#VBqSPqb=Tv&>Id&o^kHArRW! zMLJ)l^;nCCc**#*%dF$%R6Nr==8wR^{d=SJzV{DCsQ|y9{ZxN`(=yYtANZ=X^z5T6 z5(H@PzwGv^pz6j?y-<@`PebXxB@Dt)|=5OW5r$>z7t{>pfDhQ#n zmr8;(!ewT^&PtZWrkFp8@rpt}(ycyi4C~=Z(=zv!a2@GP7x=y?+TN!SJ?jM>^)P#= z`F}dO_IM`y_s`afEn&q9S$d`%mP6rDLPWManwG;H=2(f89*0Ongc6AyT0Eka9CBC( zVT6fPCK1y!W^;^|Npswo?@hgazwh7Qf9`*-*L8oc>$*Rm`@XNk``t`BVoo@Hf8nZI zN~w=$2#S8DU*s2qR&ZpzC%3+GHTogi`_Dbgl8$WQl_lfx;r&|{eeUZX1X{5epwM_L zQL5);=)AU!^asCVvh}?L$09JcEIvb{aZBV6Y`t=gL8RU|)d80u-W93Jl;Q9}Q_cj? ztb5jl(8sWUq#MffYYU+4pN*mNsx5u!yUma^t9M^%a@;WodD`cgpg$35JIVd@lpdgz z-)?I8RV8nXdb63ynFqB6zfSIjkZmobKmvgUMCX-TSS5m9w1dw%HzG_IL86En_Rro?mD^2UXU3u6}Pmj-SPGY7#GL~|RE1lOj7gr1rG8Q}vF zh1NAn?CX8xyxUQh%Tx^RFnbV*JoVIL)7+QJ!DWi0oodg&C~>^tn)%XoeW^@G9l|jy zkOExWql7Z!OXwT6(4^OGhP`4nCrrlb#If{}IW_@bPPi=w-8k-WfW%5g@xhg%2n_+v zxaxLio!5E4m5cLfvE0qi+apx3g_ZNO;U6EqMr1h9pmC>blSf_M2lDr5zHup5Vvg@< z>ygjPAb;98)l)H`Beo2F6cdAhy>jJ_m?#kZpxGG~0`RC>ALtUk$l{=_xrgxh_ z9vVpS5)WT*Ic|L8G2@(BPD6bP=b)6WO{QW|kgue6?jrcg4Ggt>kLIL{_FyY*LF8*z zL3h@B%si+HD}c62&o}S>=F1P!uRD|Y4#rtcsa0o${9Oyd3JZ4$G~h#T&8FUtIq_H5;{SJQ05jH{nz=f==MYb{cY3 zO&K>bG)y}ud>U;8(K|Pna$O_H9}CZ0Cnq_?7>Cck^wk=(7|7C?OqJ#F(fC|{2wz6= zExuyu0j3Z%M}%`4%ur@`{A`BD+|egVR7%27uDA)EiPw~>^lmbT-6S`Pg7_0{pZNVA zv0-hx1wyE!{sB@yl3tc1@?j5#ki=eIH8GxwQJrwhrOo;XSdHCepiGC&aNX^X5b0o) zJbQ$CWG9KU<>{NbZsd#oiAK{IKt3ncCg*%eb!lTkZB2a{#b z=^G_A1f`zA5V$^7Z>$&P5Hrs-B48o@i&ZGE1^F;ji^thKn*H}!b{@nQ$KxYz%a@os zK6ci!@1G3R6eY)S4B#ii!JJMxofW-y?(@u=_clJ`l}&qz@1Cq6@>|e}qQy6V-uw(9 zV7qPvpij_2Co6(uX@xj93pibDgmn(W{AndGsXD(eDiDBmk5h0?qfvzEnB}d;+XU8S zh!qS?WHJ%hr5>g#NT>3zFC76IN9ToKl=4O7jLE>l3meraF@JE47_R2^$zh3$bF>eh zr{`x7jawM|uNwYap-xdwsvBfZRqoR0Qnn5VIy4xtym~hMF;Hxp9|QBDt)#LbRu=jYoK1K>%x zF`yIxP5Wa~CkQ89Uxr!m(S=&nKdBS)-k&8X#*RQ$luLXgcD&#lX*E4z>S{F7;XT!G zZI?!`rb~zk6JN9Hp&a*XwcNip@@*y`M!vLH0C3?t_C*<^Wh#>(&C&Mda#+>$Ji@CAy?X%ecF>8M!7FB3avb!{*F{Z+9qX8o142V1}z>sWD6D#YeN;E+>~3 z_KIyR5_HdSNlECQ?9p%g`t^gNm!u+#OtaLmF&HrULQ#hHB%w}DPF4(>QhN;ONWJ#m z+eLd5|DK>-H6h4xnn1^N%0rYBe*TlJ*Y59$_Fv+Y=jMrsQ48Y}j}G(L?so$vs=XA) zhRTp(uUYrZa_pRXIlI<-|_e-dn&YX1pl6j;acImH2duof%c#r zOIx&=d=B8=HKx+!EHMRdN2$9?D!qwAYCEplp!T;b6i%Tof;05ZKTmt73p$D+X436! zS|Mz-wyWOm8gW^qb;vmyZfS5N;yBPdkJmuq>18GP^s?Jm7|lxfKOkNAaZ!h$49~b; z?5bu*$-q`YG~*UcU2*%XqXt3ey&g^rK$+tGnpd`qL8~)W7>DW=BlL1OeG6C1k^O_TZR^gLBC_UKmsM@s zW)&DYG-P%(6j2;POgr(WtfJDp;mM0<{GYDQ8%i_#^xA(IBPf%R?}6^ZikNV#cJA-;Zg9M3h zSx?0QNQ(SBs$3Jfr{&4gvjN!n^1>*pZ1t6b0 zyQwU)*PeSO|1wz?Xf<09DNlY$ZhI-CUpoMBUHmDkl-Q9_s<~#W)Je5(!@9TGRQS^< z00`KD7YKAbzIti?+A=_shImje0wORWZvMW#!$b>S_+o#{I_b{ZG}b{A$piYflM!Vp zJdON?IZUQmLSfFY)!@ZpXAV+9Pc;nX7eSX2JL^C-x&fUD0Xpl8O7}z_fY_=*6k9oW zTH=K0AJ<|ywsz|4@rh+g?Ez0GZ3x(;*WBg|ZeJEj{pQ@-5by^%wJ-++i~qK3#)No% zsTdSk@XI>@T(KeKnj}H1B!Pf3CpfRVa<8M3gqw*>%PD*9E1IDsu`> z?*ZA=7_))Dz`_Sg!-9~e%K>|SN9LG5%vRq}DS2QOJ{|<5*TuP|zZH)XmkR}3nC0dY zw)zTMnDW`Bon{xd{+}t2$njZ+qja4N19oO3tH4h+=C)w({l6FCk|s5nDG8u-cv8@$ z#ee`jXxOzKV+pD{Ik4fcJ(_+w;SXtwwgZhodw3nNDhDr?8B*u&ZSr9(geowrknmaE z7MgesII3oqP;5dYjRQv~S8__n!MVmbZ_B_92yX2?2T)D*Bz}_oOX7)_yy$6cbrj37 z=`X|db+xf~p3j3>)b1it&5@n5j4;VHN||-|A~TwPry30Vy?@qXzb5#fFBIjUtCCY` X7{3bz&7S}UI|;1y39AZAuekpJ`ufjw literal 64203 zcmb?@ha;E$`u~lh&@w^^4TWrlq>PG^N{EcIGO~9z8I_evnr4zDE7@d|N>uh971?{o z?{)W_?|<++=Q-y&k5hf_`#rAfwXRQ~%6Y|2v^!`Cg4lHC^hs5MpnQ%0{d)s7{+rF| z#&v?A@V|cIgvyx{C%A0wZA`9P8WRN1eb4*HPM6EFSL*3xy8UnsEUnbiq|ubyxt}xJe$kgZ1C*mh~dgY^2>o19~>u>*+7PEY*HeF$0 z7*}6qzccei9K(feip-bdJ-n-o1E#l|X6YK&x=*p(vTyq&+I)TU-kYcR<@^b@OAl3U z1+b><;N7qKo^yUek-hk|;8R_0VSD~qO6CXsG;4m{ozE6)HcId^(Mai8E*q`eFh&{r z%*vay-MN3=25Bly?az8iRAMnNo3*uPHVk%C3#RHkE2PmKBTih%zjpdAQ|zC*ft&MU zORxBaZRuv-<`o^Dw_74!CMEyeWNW)2WIK<0XMbnsXwhHySFPP!ye;kDidp>V!nRNw zo>e?atdakYElLc>Pd3_~)^Z>S!M)^vC|nX`obf{%$1~?n(fp)lq2u5G^S2p(La;fW zy6kwu#>&dr+L1V6Z*1Ube2weIbw@KU#WUwrG;eNZAqXzw%t<+Qm$s28S6%gAtJN~5 z;?%cx-ST9+=Sf4svToZ+6{Zfk4(*qfp1if5ya%)1sSam%PmVaeYF?ZkXmoXT&7PZ^bEVnLE_otTe&yGiTL0jO z5d8XeeBTmIpFQioH25w4EG->fEx}6ZC1qraM?{ROPV(#Krr$IP;kv1W-*r!x z+lxh2O^rJ%E6Wp~5uT=-Cz_L#^e1}&zgxoH#buwdvGHj9)4iu-8L%=}m^Yp)EkEbw z_2I_3bG550D=T^D&Yiol(%(^E&$agJv7Vvn*T^&8r5o|KzJu>Rn$dDt2L%V$XyLSXlQN3a|s)H{KA1ny-juX=2^B* zPR0XYqvFr(BiHZ6XL*i>+xMtwHm85^Twc|TQ<0pM_SO`+!Crk+fZ?s{Y7x? z+js3Fwj^BgE>+!hu~cep`J2NM5_&s#?Yh#@dZgQPe%CqSe~04=C7;;rz55Rz{`Bsz z3Qfy=_fFTpK&W($LwnXRi<)5t3E~fAm$89B*r<2sR#ze)Q;8ykgjk^mG;J-#tA( z-@mJx9onJ$!Q<)vNb>dW$gsEddEe=gJg=&&TR1V)m^}ZJ`@!jbDcUJ>#VkTse^PJ> z3U0o7_3Fn@pUOgaO87f)-9N3Os~ghMq072+r_rxZ5r_W#+k%zJXNi9)+WN-xJ!ZZs z4*mI&*!?;srExlX2OC>lQqo54l0Y|S!1?&Sig#aXYHA+zS!+D(t9W+)=dPq}(JECQ1xQFp>PNrMn$th7HNjqhGzw-EYJfGum(-UT{DZh`6PK@}OG}HElQV{{$Zd8>DY?;pb#;{}(Y$o2)B3V_-Sl`>MTHqNZRM4$6YE!5$~E=$ z!su88d%ips!|ixc5}}l^@Fy|mUSwp*(2zNi!$*6MX0|ynB;*=AyvU7oDwJUSgR zMV#kj3Q7(Q4b81iRZGv#zJ*KkQZ|la-%b!w2qDridnkXUpICcFLwN% z)ZurlS1SMfy?e}cYM)8%vn;ocTs!VV;dsT0ZiXO(VQq2S9@!tcxsuef!-InhHdUmr{ZH_d6SwF^Hf`Ee|t^7)kcSa+y*u= z6Q2RsLlP1{o;ex%(QH|5boo(m_}PUZITVkDqq15nS0dAjSC{rz+to4zp1i28e#m-t zWpPq7?W$Gn$B&oWJ33aPl@iRY%*^inp;fM8eGndgfMxskE`A{)2^tkAoL#J4oJR6R z9i8Rm0m>YPSCV(*SsU8ZJ&%soGm`I8B&&lD$<57WKX~w9KuU_$`f9uVt*xzfuN%#^ zu3!JtuIK$X%hcF7;cb-Jwe0L{T#FhZLBT5jjg0hT8N*EPwFLyPR+0%iOM2hBDUUJJdqUrbHe zuUofHx{Nis6}P&htf=HT|`7h zhg3x06ipQF^q+ntc!idVii+WNPOqHHh53=z@>3^IN>g_P{cSYQGJN-J!iFLFzr)#g zW1y$hk6%#GI!PfuP(oC+Y_h-l64qX$y`{yav7uq)sN>+h7qPJ=r?zrig?%Y4rPvYr z`&Dr8*%PLL7jJxXqD6@*<~#2it*D~1RpBl>Z;%>;!qOLXmMXv8&DC~10s@{D&CM*L zPwDZOYLfbj*8cFoXq#RSZ91ISK7(6^Dg|5@FJA13J8}E6hDOtDTbs67R+|(474!7j zv-8Fwt#iZ8LTMQpBBS+jCtk2#cmMh9*)u^rpQV)j&pVgnXE^fDqa*D^J6cSAb&fuC z$6;F4Bqjj?0o0s*L2Vh=f4pkutZ>5KSa;-Zi~nYJ@9ERPcke_89i!wO9S=!MOZSYA z3w7Na^b-8PCiVP?_U%$?a20XjY7>j|HZr4{4c$BuGV4E^S;5uGjUj2~3E;WV|OS&jO z5_)_0?OPWY7bkr9Fm|WnS+m~wYgawb*-PuzuQ%w-cLEThVWJHfI~SarO>Wj?y}Yq` z{w+IpQ;X}@YY1J#kkXo(n#QiKXrP*u$m5<%rwQdf_Xi^$QPzvIQ>YnS+6W0qTmO^uDYkjXD1Q{xqr@e0%rCQxb=E)LzL; ze9W)q`{>bjT*o!5W`A@+mxVai2Eo%Y$32;Pdwa(<)zwRCYtK;;v;p#}+S)-K9UTE! zC@o4^p$`v5sD*@to@Qmus-hhcwl{9vPDtP;V&A`K!p`LUkqXFe_DM?{-xdDaKcoEC zrs1vgr&q$R6gVHdH|&4wRz8(10MC`Ewdp#UV7sJziAZt*NYr(1WukmbEjKr}A4P0N z#>F4|4+-Yy=l_1Io%P9RZS`-b6l18Mpr8y&igvbBRN38KM{WOn=Wc0h+r!O$ib-Jf z`moe`Jkj30d*5egcg+=TY+p`FO6s!+muwu!YQ8F#8)NtA(W8&GwT;ien8tW!)0XVA z+2M%a6@YsYE=++~|(2&F#_;KmdCFT+V8y-SkQ#1bUTl)R`_qSwQ>D+#l$X?z1yY~6(v@}I5>%FKb z&-Qul4d3ePRYZ2*em8&go$K`Ps%19Kt5?6)J{3#+G4M7eWqfD{i3Wz#itnC#E*|&d zg|Fxmi2xa1SNO%feQUX=+OF#G;lmC%uysod3nOQgl~@ z8*9UfX&LD(V8Piub?Vd;8Smq%SBrw)zdwX6KarsNCy+TRRn5%GsxtLTK|QL0P8g5X zc=xXAySoYoM1Z2(P$v35MI2nKKSE7Bk+A7vx^SV+{lhEkVJ#Bs0rPf9*xA`xGcz+Q zSy))Kw6}jIxFjUzSMbJZ=sGg>D6G4Dq6hDt-uJPlMoULiGiUGa-8VC{vQTwDe*KCD zrhpsuVRgv@%R5xG-H6`mO5)a?JA*ee?(g{4|Eke^cX*Ak$Aayo)0xPj%xg6d8n9Tp zy8JptZimlDOE12({nFmPld#1-oZYrsRfq zts;z!;hYL#99AP^W5-i*yA|1tY@MCGm~!6DyRHa1!~kk!to~j0=70Q|g4nomw8j^MBlI|Age~Xkt-C+$njWa5A>O}#57eHcvzJ`Ib$qQ<@1Kg9Dit^lXP-<`e-|4Y z%V_0oxtHRnaMitM&+@mAema}Av9SXkWw*HaBQa4?Uw{VmJOd*mssjfOoIG_(E=A+U zWeXY_8eDIEpl3AVk)G>}73SL7JGwlk&k-d$Hbv{B2iBU5L%dG0cVzk??-Ws%hy1E^@!@kL2GNAA1rJ5r6`Zox7;1Nu#EwCR|mY zrYCbqT>M2i4x72TZ)oVIx$*9>Teog)-gqHIw{?c5)v*(TLw zTKnv9)4bSNX5I0EzTsi__JKz8!+d;vV?)}`&d#}Z{nUqcgz~7^Xchq@gP!m)`L#ui zZNDb!muXtJM_9Q2+IUxyUgXgmsc&LqWx2y^BH7v5Ujn9v{J0pvULBX0$0qZ4COkAb z`CwZaQNrq{nsn02N&vsecCzo(MO)f1oJ3)#A$7~P_em$5i@7ug>SDG4Gw|zV(@+1d z^^1y%x@;a)cxlP9`$N&p)#`QB)Ltu~Y<=Jk8@6oG6J)>P=(vuMUi=x}zVi3)_>lJQ z-Ma}N^nMYqhgevcospzEEFIiA9z^U01KAke_n^foZm4gfH> zJqlZs(P+wn;Z-hQzJr@zI8jFTLXx}p$9)i}j_D_AiRaI)EcAy_5C_gjUf#nV780_K z`1$+y=CL1%byt|>W~ZmAY?CX^Wo3PGk2~%q@09e63VSc7&E({y?(;hz=O-r((CqAu zLkt>TUyP6TTDsn!ZMA5`UL6>CQJ(z`$ZzhQI~xd}=g)V#MBm0cToYwuHM$cVJnR@% zR9Kj9S{Hq^D%!gB-TDv_oRXmNOLvYYEd1!^@E#f&(Y5a_TVIsMNo?P~z3Qs_=;4h7 z*10PyUpLca6RT1ByLV;Z;uTA$rL}c*k{WscHBmW^2EmfC&H^nDkCmLSU%z&Cbav9Y z%?$3Io|<~*3Zk}@)8&@jR9X4U6ZK$&GhMHO@0kSE3F$OJUS0}xf`a-8eH_~X zb93{F*=D^9It9+7>v!&aPU+w$Yt-!PMn!ZvhuSg zyssl!osZh5=9m4W`}Z$W5P$ys*%aleI669d@yeCZo*w-oqYx3G(Jfei?_pJaaxq<1 z0=s3gjz>GF~3X2}k@e^}~m&n~A4Sp9+Gvx@k>^h_tk}?mluvOZ(!* zo7t&qJ(8Qz2FRt^E_9XN)YNp+5P|D>trO*+tXAm&&4UZ?GB(3k%<)V&#?|9~#nbI%D8P9qWq!*8p`- zSVW{0u(5Y+j07n02??i|5`8t*xAIwATN@ty^0hEAFfi~R2%U;u%|9X~)fGOko}@0C zqLDm6!TiB1KjSSRWmFg2!$*($mdA^mkBXaqWfz%qfhyGF$^k_ElcZv(OAk6@T3cGu zok!1W+1d&>;}~D4KQq8X@JmZaQV6T?MQos@{k~kj0=m5C@Zl`K4b1*;fZz>{jE=I? zSVt%^RBTGA9nUPPV=adSGW(m{Pj+Ibh~YXa9~{Qbmp^#8Ixde7#LD@Vu$H6BC*SZG zZc52@9^Jt&AaGGtbk}?c9MLYY}(Z#>)~Ue zVPOZx{}kmUUhzz$j2Lizd$lOPT(j=W7iE5-h$l~4lD;p2aigq=ii*zM)hlq`6yrJf zG`BIW(R?j?SP_o|rLW)u2nl;NtKaS0)knm{#2_netzs>Q7}xLbfIf0p?f|cnaF%v0 z1TzK-E@9!VAtLDis0CZGTeh~gxhWg0gmj&X65Z!Uc8~u#_AD%{?pUB2Aj9Vnk&23n zJJa1o?(-}Z!dtd%xp<|rs>)eK`{vD?WDnIyKIP()>(cS<+qMu9vc<3-_gLtbk_#f$ z%L+Xzr3XvlExC4kpG&*iKhqV=nVX#j1@S*XkoDi4g6r6^W99gSc(L8r&CH%8e>1Zt zpcigJZS(Mu#XVEf_}1j~#?O{{om#Qi--?Wx+pA+ha(Ri2k=&wnGiP_&}`sNt=Rjk^OG!PMqo&r za@vQbnX6ytCnhAn+OcO_weRQHDdqV3C-B4xik{9J-RCHMk~PzAWph5if1iSpkw9d2K+!1(}?inJfc8P}R2$a-AU(t3KeISJhEdUA5|Y`#3oj!72hQG>E|B8z`+ zb9%|PZ`$27k-3(L245;j)g-aG-MU#ROHSXNP|M`V~-Br2t8x*h=fg za>l9P?V%N(*T#pp56}<^sx<)rE$^@YSfwE9j?H&4juwYwbNhyW|N14Dph`jD$#Ba{ zSWmdQNgZDv5mU0?J1+BI6Io7t@xoA$c$t{UN%(|>ggk)Yf0}|zN-CemN8`$cS6nGo^_Xqc zT)QDO;O_1|e!aM83qdM^uG9OQQgr5-h{$8^b5V0f)nS}MZWqoeD^FDIv>~<@km|>a z7khAHeflM}6-n|S{rcLxDSP!{LLaTHh}CGYtEfO+QnDq%>gb10EiJhx=6UjTzY@9U zo{FwV=PfBAhT84Wh;cR=hDpPY7{4xix(-P2P)eV--{Ptu=9!@fOG}_HEjbvUj5c9%%|#wz45f zO%Z*g0T;J-q%|{z==u5c+Vp3kVkWP(zw=YRzP@MSjg0o6ehTF3Ha|9+2MH2D>d>J> zC3SUM09sXen0R=224`;Vm6m3=`LJk0b8`s*wY;oMekPjXM)miEv*F{W9e{myvqOz@ zeN1Tlfn_&qpGyp1YQj0*2L>J2Xdb7+L&)+^35D16;C!U$?SJ_Au})q=fp@${^7LaNy)l*@JGALyS2))estZ7)cZ1%Bh`dTZlshsq z;tFN@DC%_$RzMW(B{x66tg(@~+hcmuOI6wQCh`-@bh$R+a8HI~0BPvEb~rkkYO$FAhiTXSA=> z`JM&`e=Y`u?djgm1>gpa%4=5UI3tgT5_YjM3T%Gu)?pP1%CwIS6=wnIsfi_4$bW(d>RvDV<(7Y z*Hl2Fm*z%Vr_WZgKH}HvJ8u8;qh~(lrH?;BFY@y3e|@@%i*eH2obMlVI05kuB3;ku zXvzVV07VuSmXit!t96^&ADs-3h&aX8J#ThUeaav*`Aztlh$EEoE)= z)nhd}edbICY3n=|snWN$9^<}$nzh=_;{au!_UY3bP-07_rSGB?pg2Ey`m_|?83K{p zaEn*_@k58yXQDT=3d;(`-6~96%hbv=DUyVu{(F3UP4=Xot}eS#h(T{zK%X|Qs0dEh zBs(w#s)EGtu`w^5y5!7Eu^(oKyzgkvJ~fSYz573#a@NMs%gZYpN}w`d#1s^e0yZO7 zcm_-GsCJBY6+PEU*O!xd-`+JKdH2jdhDQ$`l##qy5CDLJ;Pjl?M!lJR1F?%C3ddn9 zBV+slZ3=y0C~u4LKUfXZ5LOZ2^)xhMCr+F=W@ln)`33wy3ySK_qt2E!XjtYGI@$AJ z{!qw_z&X4JoBrBl+4Wal;r^c=`uBOI5Y#2{J0iDkQqhPK_Wx`H3(31b4%Q3ZX}ntG zwun(Fsw3V4F3K-msmIkYezF&_CHL!S}7nZI`u#) zfg#&o06NgI<5E&?sbOJZ??$&+Ty-DkCAxn62wzW4tw1|G-Jo`Xg6Qk-KkB0BG&wcJ z;Jtm_5J(^z1<075$yHAGkqjf?GZXWyrEJ5`?d{LG4;;vxnVGo-yqi|gnf2;I%!gE) z?hjuoD^I;XnrwRh{CV$O70ZIaMYWLs+dUz3m)t=Y(S)Q=*_DrQ3e{l||C>rN@amKzh%v@&?39gGLg zHyr$;r=_*1!txu4wxcsyQ^>@?;9F9x{f!%@N(m3x*w`}s{ikBq=>IPZunr_3vN9+5 zaMrtbhIq_A>76@wX126keiR+uRi7#_x+>>K-ILWsUm^<9CdqQ;*T$qQv( z^MJdiY&z`NTua7!y6qu1;4xp2o~+10m*ofQx+}jNmc6jx@}IE8b#sX&YujFhLMA4r zeJi~ePz2OMIb~ME6QkYuo{3N=sV^z%_^P{a;iF2YCq%`>M8Ho#+jfx`C4(DB$Zh(Ch3M0enroulw{9(g4q46NJ|cn({6rz% z0J6>VDUz{`wPqf`W$M$&ySHwp%_8lLf3sGeeZm_0)JR9GJ6QVM6yPAW56=FLrQ`b; zHfFwm-#~W&Km?+ZTB4rVpkvsMBla&BreB;2R=|~C70p+XhWe7sy7`60K9&FE+AT@P zCMy_qbv%D85~!c7XV08*wf}f;_gTQgBJ3>%74^OVfB!>&f>e7&!1*|Fai5Ve^wg=+ z@820v%JC%PbEEAvSf+~)hmJ2TFULc+?91niP>PiCzB&`_+_>nrx;Rj7WN7$AK5kGw zL@D9>=EH{L*S>xGc4L&n14OCFW56Q#^!1A4KtOiX*C`!|yLz z^idDa6B8W{b;rK_j$%Fn3vj>klY24{ImEAjfBDy_DkKR7D>TnG6bz;bCLpQDn>UG$0Dn~!zumtOnKdO|^=3S^J^So0iB*6sA7 z?k;z8Bct$QoZn%T0fWK%xXam=Y>xzVZhd|%v{yi26OiAo!o++y8dN1IqpPVy$2@xj zSme=9x^~~JX=s?qHYB<2?l_nt>1c^TylSsJ4&4~*U_(RO1xYVFobl}W^CmframU~;swPnUB76#CGWuMofu|IqfU6dXOB=Uu7l6ddttP=qOt^x9;W##2;M7C{j z*$iF}T1fXdcPW!EPj+-3=h|)|+mF^}Cr^SZ-XF=oG%6I^(*BY zK%m)cV`es(ppo1=I@-C3FxA(OZH12UIeh=QckCjD6~i&!t9dQY)N?OFEbxJ_VA56S zY77RD>#-;bTosz1F9mGUS8|gIlv?|?9f}@|JRW|2e-$pTPY-$fILA}JH_f0Mw)|~1 zjj3#ISh)~iSzW!Ci;GxWYAz--7DyC;Zu$00HZ(TIWoK`PkAOc$J4J&(!r02HsHVPN zc))MV@yndMc7?({VX1p|_^j(_Tb5RSnwF;KV+q5G4QxgsM~)mh;}We2*q(Xo7Ipil zPoLU=lXqUvY8!*4;AmlOon7oQ`GSqO(P{DVmpwqPJ_I(n0}4Ro00mUu-rgPnkAx4) zRhQmOhk>uXq%M?8c2M%&a`WN=QG9X^E^Z(Gy0hO8z$OQU(xL%+gB$t z$v@QQ9+wm@=&OTFL9-B@zO=Nkg8ux|7e`u2y}D0kZ86Lxm5af{!$a6>#fATBA**y9 z34mo*7viHO|7HgGL-|imO&zoKnCK~eot%u0Om&yzSP(2fh>%ch`>H~B=6d~=Y74Fe z$9(eqIg7iS+bbchcRzcgt~Pgf%X~ys#TqtE6)Rn8aFzLRjU!PAaD_6jBs;rZpAL|63p)fKs0xR0yo?}y-c=)Nb z>(ndcSgu_&HZJ}8b@Q1sXG~XT)4bPrnQ&xyEZPIFP~v=!s5CL3}ze|QZrA3yw<6z!}a&xul+5oloB<#$S*3wf85V>++W z6uh{+oQdKt9I8-GziHFcloWyKxj7RN5fS%WTR2zGL*BJCH-9q?x7&)0Y`{2vfKNR? zFJ+#UZ`=0%x&p*9dZHaC8P@gKdx0)qDdS{H zt06W6*ZUO|xZfUzUP|}?EyCpGoLZ|CtCOYzyUWkNVo(r6dJZ?0oLTlm?4?LoE*@M2&U|>l1M8 zvSy)Qw!-%1>?-zND`0p@HgGXSvrPUj&zs_SeEI(U0oY@PLHVr=(nGVhvKqbD^W*6y zP0hUr4$zRfu`c)VWBhs_q}#w`ov~c@N$Py>dDge}=~svD#9DlL;^*ggRrP*P#&(xq z5t`~|7Fx6fq?7EcxwZyw?l!jQ#gdlkBX3s!3^ejks-2FdHOxX> z#qfGkp2I*;z+!>Cy}G^qJDxHG`<}+c#0-i=k!Sd5sOMPTK=jrJ_XuII1rvmK3JVJ_ zgV?}gG{S)xv92(4aytAjGc&_!SOfMqEj|&_68*^N=Xpz51M{6NV9|%Ea$J5Pi$-!#<3KcxB3)w8Mi6`WVo}bqf zu>6G@v;$aUVsf(diHMQZY&4}$V&VZxDw}{!a1ObIgwoDNJPHa7G++qyhs#3kv$(Y6 zJhb~tp^M!Rc?vjo?dtp^?hTC@bjOHn+*~f>{{BgG8b}<#f9xC0>8=9Hyam1cM2bfD z+)>cJP>2eE!SUxD_tSPp0@X<*c<%PZQ=91P*BiKZ*VH8W$uh5g+uy(`S$6JAOerWx zg$e@{3Q+&z^`H9IcCkrVM~2GBrN4zU@8mSw6d4&A23R(_p@fk@0MD(VsfoHXUr0Za z>kyj}o-KKPW~Pwm@#o3a*2A~S)^tARC!4Hhj&1FSXMz{uQyu7L^ z!=W9UAU(V~_q+-jPztVPNc=V^N)q}ZHA-jC&RWw$q!=0=rXYYL;0p6(A)W&yb<3eJTZ_h^PfUsJRwM*#2E|A^`}6YSN)a zeC8-4Gc$KuYO3?wq$G-JyU3nJgAjyUdsY^wS&;QyMJ}|WX!`3>~NPwEHNx@7LbxaNYm|-*@0ZJn}3^I*~aA z)C{Cc(_JPF?KTGo1#M+vk)V|IG%|{pLkZWw-)RU*Ny(Ci1}4Oyuqg-%mcg^oH#et^ z+j9cvTOow?n+3>H6>%>*dh8y2a_C7^Fa@)zsi{fdgV2XygQNDty_iII3)5(a7jX;7 zMu`Q0?q5bHR7k+=x9rHxIQw=KSVKismGbD(qZx0o%%m$ZDi6#1u3D0M)9o#sx1hot z+HuYnrRNM9zc9gm+@qzcqr;j`~*E>ymB)O{S!K&{>@mF~1e@OA+yJGiLaIOf7Vl3$0g$WR{fPmB=FpN z@Y(+IagzLnUkhEQQz?7`0xHF`v^UAf$dC*OnBpYh5?b;7$B#)aRXEpX;Q}F+qJ!_x z&!0d2!H8m^+aj$(N)RZ*q#|s`j+;`sl!O$OFk*AC_}YpCq}d-qZyPXvSPi1S#-Mnn#dZ99N{_QlFz9Nz`O6M}CEl3W#8oQKVsh#usH^OIc>IytGP z#)ugGBvkO&ckdX;RI-=XarpU1ndXYq)>PV#Tl_pmYC9Y}4_jvREpaUQh+28kdYppj z%Y`nJUm&0414YcR1ATzQUqdoz6ZxcH9s*BO>31hy;1sT!7>p;A;akIGRwZ#uchhQJ zp{J*>$bJTvi~Q#w)tZZ=0*4Pbt~%FkYpKYko4 z4$$mv3>5%_K%Ll)1xM-3(@j0FfF?zQ(+#9+gw-Jr-{cpux*jBXU#F&$S>We~u78&S z(uhO{{v6{mRbwSoyz(w{OllK{^pj1T$0I59fsn?z-kE-RlCgdCK|I9Eng;X3a9k_N z?b&ZqLgyfC(Ud}c8Q{PS%2~nqhhQLezX8{bJ$@=pXBHNnofE%bKsDewc<_XU#X;0F z+mRL#%dSGUI+-yMQ$w?bjaYCndi&=NI>sw4-qBC-8D zSgs@hFb>dB$EZG6j>g7D#2iTodMpL1#_QLwNeF^Yip?j$4&{>6hprU7c|(f_rGv%Y zj4RJ`R!QmB&tJbpO7|jE95ULTQx40H(1$Rd@bYCW`UjdS{v@2YRb|2!r@k>+GvN8{ zV~E1{jfBD7N@DCIiqM3KFF(;K!n%xTI7Btq$ijvQEg|)N=1lhDNBgwWwQR7 zi`f+*zuWC66it1Ex8lZ9Wwo@}rlzOwhllUIB|g%gvqkYP`_1#syre@5d!5Pq-#`gX zRLyZO^o{wP}qXExEb4NE=?eroJU=DUsmFzybmY zu&}WOHtTusx_|%v;N-(|&VTWD!(1yxV?a1`BYLVKqN`61 zU1xx`4qYlOO-NAhL&)#nCiHBg>)5Le5PXpISP({d2wvRHkrB&7hY!oee=GU?nGSb? zG^tE*=&gzR%bJ>|F<>N7j~{D(^j=%mBTC>c$Ex#*7=L22Y)Pj;Dr;hDsthU`j`BJ} zSX|sho`1+9ttcB(SsyUfq=|`%N|HK{pdhtvGSicLtOwM277)4p_We60!Y*LOeT|xW zr-1$TG1S=H$0$}?h2UG!ZO0(Wp#BIW}YDM$%X{quBvVz(WA~I zCD1ExPfXa_MJp>S>swgRA(9NFQd(QP2@I;G*jom_wJlh9J2P`*^XJc>n>#uR9ZP&D z#sDMSIDWuF43?pre1vjI`i2^*x`9x!^r}+E4CslgUW>*9$d&)~>zBl|06_pySGK6d zQT>=5Zmyh{wrJu9IehrgpM+{BB8OuB^ft|Y7;mRSq;TBAtMAZdP z&Mrm^L_g zI`SB4ws15QL>CnuLm9PQoHCZ4ZBT>cs+E{_@J_O(o@b+0g6ee$LFWMjKH&tZhh!|l zy#5oVr>gp5;HI?KiX=uK)?ty^kJ$VF`u&@dfJABo?a2@aH~=8;7gX2^GVaZIDyAo+ z!E=r5sDf7uHzcW(cUkb8ZCvIA!++V~wt&|6*BPG+8~C~#8THp79!o`_-c#ccdQ8_! zOw7+KDkxBcVzu-Q49p|^G-rwFl9PMjmY_Tib{6C)Iy;LaD^#g^hP-=l-&AyT4hBie zvA=hU@>k(vBZ76=yp411Y~6i$h2E` z?4X6()X>}JjBs}|yQHnYi>_{mh^gto9~3o)?idok z?QMh2V#|IT=2TqDFjKZock1%f^z}r9Qe)ik!?C#!6G!O`$YB7ySM^z;B7Z31fz$H7 z_x@94I>eAA;wRr3??l96Ow2w{_pL~t_nH@UQ&;lk>F9!O327tcGCTGiJ9gkzhe;+y z&v~33{xtd@=?A?@PDWmbHp(%o4EY;?6QQ6dw=aF%F#deNm42r>%nO57#2GasS8U^k4VWX?gz)DiY#kCzxf%OARz{xOBL}*M1lVn` zQ3atRLk7&R<)0=&sYQ-jW2Lh_|NL&m7f6Z*RtVpd>c2QmklOB7YIi~#Iu)AFZ5ZM= z_y}d=?WAppUV;8bM|Z1#Cho$Pi;>E;#@!OJ;&A zAiGEs^=5}SaT-|=k-Ag2v8WYElU|G?WNBYvMJ7s9N5}nqi?vCJK~KreBe-d~axN~C zPyqf-VL%xLA{ye7a>Bbprc-8ceG(92y+B6CjE%Vw8pe27`n4JckCn-4vbhy9u>9ekUDf2otRjdfnb{7Lp1Q-M&G}o|L{67(@)?8-SrmtC z%T`}twXKYhe**jKRmjrrr0t+RLJsVJ7});$#7wFk z(7Qd}B1cYkBKRzrr#orms;&KOJ3*Rf#TcT~L?EM3khKb;qz@pvCtk@CMp6M<(qjC;=e;X1u<2WfFG61kI_QUWoL4<&}Vh-16MkV z2t~(`)L~3=pn#HTZk6Ol@25`W_G7Nao6DwXcDp;sW*M829J1GeuyX4Nazz2ws;+5;D&D{v;TX*YqcaDY&< zgR?}Pj@b4Pz_;8c{%g!9L#*GXSf|u}eejHf2^ZTGkhvS-1*NcEN5#Dn2z*XKiUH{B zM_~WZ$9*pYQ0@KoYdt}tVWf+&(NDHg_w@DoLOJgRGyW%f281m51Yd)9u{e~g+uUa#&9FgFCLo++6SXkgx+;Ei z+dif~8rwIR=P}11+KxdcFB;p7zuJ;Vjv&0njNu|gvYQxf32>{;UCcjP1OVVN7sJ(v;-2y#t`_D8&AHIh;|#|RV*DIfQGvQ{qGXu zwY8VGK1WF>9~X^e$<)Mz(x>HO60}rs5W~@P6c`JZ{yX!-JMic0uZ6G6`bR~_IQN0~ zA%9qynUL_y2vz3?Q35S*!3Df(zV|jKwUm?;>526Pr-7HKoHyVrgMf5vlU-MPgS$LE(MTf2k$zu`p1d!*D1QVL+*) zGIeSQK90w5$ve#F)R4O7EVoo;3!@H70GrV{`A4n}4q}Mam|zl0@B4@0hxcmrE?$gl zKDaBl(TR*9{VI%!E=jPN1-4^Bu!O^>g-)#&7k z0N;V*_(H5fQIwoSi6e>dziNYLIOF5h%)8rNk1yf{dNAyQ3LsnxS<70$Dh+(f#WanB zWRY1(i4!Pu&%vo)#=4#jfAF9Sqeb5-_3z%jYY7`Z8UuE6#15zIg<6;mnP>^Q+^|b( ziQMId1%0so4fOQ>#lBTNw+uHu_d#sG&m;Q2LcXPq#igIRF0rRXHgCk6=s{ zd|@polQ}p#<*Y`CKIlQel8!yPQY8Q``c2yOk?@43ImeW}w$%w1Unk)i%{t{g-dzY~B zC$JIwN>VH>G36nIneQ_Mb%+Q&@v$eE;424;|Lp&glkBmHcuIlhQK^WiC;?31=j7x( z$rH5vmE#n(^x0~3jSYGqg)Fa+!c%1vIs(zmZik5;IcpS(x6l-jOIelQm;^&pW(c+? z>A*Ia&x-U)b#-+~g2n#h5s1GS^=LHnmihrU(GxFZYwPM*p3@;mypNl^7opfnMC;Zb z80`E%QuPs`j{{`H<};kJ<8L&Qhbe>uPnKa9PNh8y4BXf+c~?tEr_MUrbMclf2Z1S! z590=~-oO?r2QHAY2)u@v@=%R0&Lm8LSUgUEJLr z{uUUNQ)2_jx>pw?^O#1l=Gbfd@aG*r_s_?EN*Q%tnCK1Luv-BE+(&pRzQ*5&e-)bG z+SWHUy&@Ha)BCDCj(czQIWpqq=H>>i4OuMtdKU*C|UdgVPB0VFJgP>Tt9gL9$K;3_2r%BL_-!# zU|r+A>F0h4at+dIf2#QlbR#6!RasXzelso2<|$0;^(7N7(r@D8?9#wIqb^F+{kfvV z3jvyiGS+{qbI{s0f_|6OL%^UDa&iebkm?6NcSFgujqctpv@6 ziD0G;U?OH`W?rsUxjq)q5&zWD5vi&amzH(`Lzfzjh?5&*ivLYwq9P0b<%yJ$nd4#A z@$}_Ah=G#98p}1jkQ_Qn);z_l^HD)qR|Y@@!Uqv0KLb{9GiZo$dc|HHVmB~0c+JGb z5ZBB`*|q_O`44Cn*Nfb9YidhMd{VWu-o$$Z>0$H9!%Ne!W{WR6d3SGDtgAG~B^4E( zT_T45G{oUKF^(`8l1^f$_H2VxJ9=cd|2y=rPTHaQo40S%kQyycKnbn`hQBB$)}~&8 z4Z?lxoqGA9wjB&;xP%w4;Bh==_3U3oKVRRai%Pqsq=hXedGhk%iqB*tkPh&F6 z?9|i?Vi2wwPXZJ2P$i@@F=DT=8IV0Q|J;0uROCXISyksQ-7;pR=pzmHz(o=Ztp#IC34X zz!fpIZYOp#&KxqTqKCJsBNL6wLFa7L``4*CxVrzM z5-;Qo9>Uzp%8Ja|296v@b?9&sq4y)dAmGoR#>wcb7@k1aA&23kAkq=C2rmsMBVS}! zvuNBLMd^cP$9k)jtkIc0uK|O*U9@;oiqAa}-hFBF|EiJ1k=Sfo@MP5`078CX(*)gu zrVCeeblSbpQp>e<9_8n|CE>fJ^r4ZM;jT8~Zv4<%c(Y#kW_b9It?SnZP|mR;3{G3} z9c}^`uRop-@@lEv8w7K9=|^0QavRNqfHCvK6s3Jr8I8^X=kO#MoNz}dF0=wi6s=NK zHjfxnLB$t3@-mUS9#&jFz z&{K@3IKP$fa>*OaD4^9uRQ@Wq|xPQ@Zu zhySq<@MA$6{p?Ei|^OahZ~euScD^UzEzo$pDFVxRZEKa zr6#(nfobx)PtdnM!BSgU9Edrmu!zhh1;KjDwU;}vZeTCuHyl*GJVcpot~wptvP)`) z9QAQF9fqpt?TvxAF;oDV&4fkM+v_n1RgdCX^|#8~0vSNdw~<`VL*x>Y;Wjq5JTpiY z*D#wz-csoV=&zVL|J^o)3ZeTHJLiXfj_>mbf`wpfJ8QE}k&TsAMJph=*#J$Adbj`5 z;-c|rcX9W^rH6|-Z%i`Rxt%@LAG$F5=b{GBg;K76)zs?HcYIULm2?cKL}JUXhCzaV z^Ee{H?&3Fo`i!1Rw`B98Li zu^nxum^qChbAG!$ju*@I7!MocPXV7RoVs~+AHz3{U5Vn$Js#YTeJr2KFc=<2RRSh|Dg#eRVPYFfe;NTr(`1%nb!533iA{{e3x{e&sAAkhi~{Gvn@FBe>G6E!Yg+(WSJ+LdMl@xQWdoG%cK zRJ%?fgkQipN=n8_I-Bc2v;P(wQQE#s^qB9;wU%^^KHQ%K;ppgi*uDiUNZ~tRq>bQO zGtcKxgVA824?$suI_dRhjrJ_#lpItLKhK$xXE_$hSp<_j5cr`f%N>C->iHpIVK&Q&;IVVC=U6ozFAa`UI~d#x#&gcu$!V&wy}fi`WMoDE+O@enC`%Sl zzRa6Nn8`igc8d?5nDuBF;O#*kl0sQPfr9tZwPebyQWYK2+m7GBBX>^5x4>Vk+YpDmmPBbEEAMh@&cUN(37E z?Rieg&gl7ooHIm6epE=y;|^S9!+46X2}Q8YC4h|Rh)ZT>Z&lqDP;I&rAi;kr2~;H> z51WE3l?3SUppMa!BsS}; zhX=0O2R9w)II(}9C@Cx7&~R~?`G*su{GCW$wvwBZQ|jK}n}}!g?W6#eYg7lHm$newk?46* z93L7z6%{u?5jMGxcR5puXS8MmqG@aXr2G`MiuARiDIFpQ*D8-PtuQ~oVwR0=Y~61h zr~z~y7Sq>}oOc6IO*)d*svW{NpAuVm_bJ_B`nv4T4{i*g$tvLv=p7gch2F}gPRz1> zBLCG-bSkQyL^4@4W|YQfdPwo|QV2bxEJLM9OQ0e-^+-RCo{kQD9tEhWPd6mndrH?9 zI6cNl*6iiWAUuByI7{6|meYH$0ifXsjyy-15=6~NSt$}6qT9K^M!N~e5UAoW00iFR z=A45eH)WxLX1;D^;^QO>H}^gK?BhHvEuItI1+@Q+1v%#2wn!G}i9Xq&*RZPJ_>kS_ zmiMFXLjCB6WDh!xo~o69oR^kMe$8eUyXpReqo)bJK0}YuHsOQdX&5`*9ttPBJRLsC z<^%GxcW8*e&}aD_OCE(TBUkMIuz{7oC~@2upa z(HNZZZsD+a9TY+bWB@Il=nh6dT$TQTie)GJ;IO}btLitKr$gtcg&9sU2C_AP{IF0g z78TDIprSSV3mm_5769H}KqbKwe0S5E=Q=B51U|EV?SupvZ@vHF-TX4 zn`amEcLVGMUbN?xAK8oIKgBcT*}In#rNGTwx0K))_-N}eKKoyS-%|u%2oq(HWI&-( zg-ksyQ&UD|+IH%(VrrsqBxVn1F-=hWp}99Aj)uS3cfDp{o+*i{{AoNU<@0bNd@=EY zV=LZRsx%02pRG3?QKF;t$8t9k7pXG#GX=3U7{lnr_hE z+`M|=$Pq_g-V<6M54^4fqPM?vV|_Io1<^kD9(Qm=JG*LgQy zvKadNZ`1%Z_eRT)CgIF!-003Aj=}S8Li(1Z?}{j_Z=aK*I6%Ze@k^hevY!-J4mBk) zB%ghH130CVlGSTUjj%1dl=to3dm;TUsE2(=kKQ+>EHD20rh5iOsW}KiAYwO#q9} z?m?k(aiIHp{KWFkjz9LpE$H<SCF># z;CE3~nNMFv9kmrqd1v^eMy(Tts9IMRCtvFr8g|5m=%PO%L{v33dyvp+9UNmh*@Bf5 z%;E}^1f(0_Yv(srBBVu#O#Rf+sZgKRRcnNudTDjF;KO)sUfz#QDes1p*+T=<(get+ z8Ko+vhld9?ki_u3MY;Il!xIH)vCMGAB82wONb}Faz!*_oS#D;iSjhJlZTraHBh-v^ ze*oFsMj4pUnYNB9{+<6lq?8u26C?^r;N<$vgf{B;2pWxFPe;(?jqgH*mq;3`NCp@t zCkn(xfUAEpYX^@xKnhqXot)?ibd)F5)aakfdfp&A4epwA6e$Sq@v@dQeP>zI56_7E zE(s9G<$#S?Xd!P6gPp1jT>(P!{3$fPef`R&#`ho!Z%mI6HZlfo7y!WRH+lEcZZb(| zT^0YkAxNDl!KKmj*w$zJitdDzuSDORX;$-Sdb{y|Rq=6gYXRy!Ju&5H+)d+yf+~Y> zux46a`a$O1l2cDYkToLXIn(b?vs>!V*Id<`ctuE#hl2MY|Z6@JcS+_N&8!ibEcaM zJ(kb=x6XT6`163Qq$M&<3SA7512F@nYJ~q#9_u?ok%vVOks-1pU3sI6=ua;o{Pv?G zZtsZE=$9{ERICZJ-Fax_!jyj(YgbUgYwoHvA;Y%m2vU+q2jl(a>3i=BmBD7FK%P+# zcZHUNfP#UiH)@K^A;^SxG=;C@U zFxm>d`4FIpZoX$-h}CgYBd$4Y(SQq^Q}_==N8}13w?38+lg2ch=1ZE{rb*p?!tX4EJ?Y$C_c%e);$agyLOYm<6B~sB;@UwY-jj!2u9er2hco zi8qct@)NQpB_%`vmyCOhlmchDgSq()6oWd8tR2|34wv1 zWIKIP1%-g4BU=PqLS*6xitKW=7Y^M;g}-pde9S*UCmZo42A zS76?jdETw*P+sd9Ra(UJ*>4X6q(@aL@-s?)_1LFB({F%OTthAS?eq)8E#II2`EKiK zxO+A(a-0HhY+40LO$LtI6HvjdEQ~YsZnRV6)L(&Pyde3#SX*&!K+A>t*f)7Kk569s z6c*U?=kaY7TN=M^W68+kosnG?`H@8j=j~iZo096hspe7Pr^2rFZ@}M}n8zij2hUAW zZtgWxi1_x#%BLoM9uP*qt-g~!WCfY5hlnLWn1#O3b$-nn7ea4^VzeVKIf|69m}b3t zW$9%baNCR>vVD87^UL3U{*;BtlPrwIp&Ty)4kv6TcOQRZI+kVO!TYMD0T<2>jXX72 z7w{mfYie-J^e1HEw=VSt4Oo2zxK9lR+w7!kxmKn}Eu1H)(8F-8(WKz2P&{#BlUcbg zKkIKa`|OfVJlMfyYA@O}bz6aQxV>`{XpSco;r%r7(`{4EPDvS@Mv360C2N3C+5bBu zAYE5|ezW&ioF^QcU2Sbgx9oE479kd*w%G( z>pmWtqnoBp8Xom@a>qonvra8@{uo17L)%k($Js z#-r@=Z+Cg`0=S%IK(}hFKdZhXMT*Hg%Y8tcxM+^ZOlW&C_v-QIh*^K!BkQ$mQt1A# ziUGgn&!v&yW!!HExfbr6XQa_nzNxIQ-h;u&jL5Qk%6+ytgpiOoQs;G8sDu%_`PzUDA~2`ada9?No59pgV9bSB0K~tP^pc z#1v7txpwV-hK&oFoCT>573j^iE?i)O%n}M(T2%5U+|w7KNgBdU0TI_|^&Rmk^XZev z6*Xxo7+i&?V`?9h(Yq0m^UC@C*WJI_ulYfu;|sKDxo&No1y$ZF z$DBS~DyQ7QB66uU89P&r?z9nJOt!!6_B|zXNcC0(pcb8yoIG*rKMHL)N(^Dr)h?In9u7o76Vt+c8v@Pg%8OpktVI_Vir- zA8>-}_xb`Ner}=-C_pk5jN<$Hrmx2e2?@D?Mk5HwGziI7fv<5g1@|PP84W=DDPO;S z{b56sjwJHkeN<37Oe1F&rwkB1PpYYxF`||NQy1E*2+X0f${m zY7XihP?AYv1(Se08tc3fRvCSh(jIPkpHvzGJ8bP2{EtVHM9-R0@ z!Lu)p^gke+TI@0&dL_ENGh{eCt`CBv<6Sfq-venhiZJe<;r7Q4b zRrp@2SZ8RFSI3~V<-Z z+}xa;20?(nMQe|v$TjXy7$YZwW(ZPD4DY|mN>*FN&iHzN0ZFSLF>(r(B2df-;!Cu= zI2NqT`wh9xZ{JP}qDkBH+Vo@F7-ggOOO;|C<+AQ8q!bdj14mrN<@VsxeGBQ^rVB1N z42b2muCJGlWPMv$OB!{o(;KYY(&biU)#Jb68(W+_AOGLtj*NaMqaWFo>8~8;bGWbf zZ3A=CUE>X4s?~8%LiWYd3uu%EjBK}G%c06bRRK}LY#?|gI)b#2K`Nk(f|W*1_|f9s zn>Rrk;;ALq+I)j@7G!P#lObLnZAgVR@f^tRnw`1%F~+iKvn_BUyF5QFo>Y(9EFmMqm`0rZwpU~JpoQ$x6NwUfMomMr2tm@g7a-%q zi62n`BMC;M!wn8oI*eM`eCSqf@;~eEkiFJ=9_}p40v>C!r^DxlUdktQcrhaYbn;*L3GyqO}C1u6K?o+3k4rn}E`u=N{D(IZ+nZEApidOr?5dQU`MMW|RQXMT_ zT~`e?H9_*07;ekr#M9zoyVJPl9Gdt9>0UOK@1cZb#|H!#HJJ-z3&el-{ zV1I|<{0SW%8Ik@7Yn`Bgz`M(6xZoCDfptr_iS#e0TG+Zz~n@idKHoSda^sKxLqS4c@r78cc; zqmE-Z7#g$=YlF1`g~bhE2;bsj78GV!>SW3WkY1=h2lP@<$;?ttLHodtEIM`=XK-*y zO^T6-zq>)0EaLD8@n+IRE|zqihtj}pz4LK-th>r z`wdz<6t0R-TRD!Q%UC@8P45i#2u|U>l9EeF^otRaiyvNZBz<9fofnI0t-*s^=i=v* zrQZzySYnC7zBrR^k=5#39y8A`&Rk&yYS3+`sIRTf8>Le_I2)m(rfxJpdX6Cl!-P(l zn)*5*185%dl}IG5#>B;iqm*@~var=l!QC@~%Lq{Dss{{Ik@G{am;44}>vlt$miOkp zdm4y!nLJIXp*`9TFi-rg;aMoLg`noCt8~%XRe=u zz`ZlUVPX3aL=xMU|K?2@bg&oS8=%cJ0`kXK_BOH*W{^f?TJYz*d6Pgo83Ld?;W>8f zK~OWW2@AwEVJeGb-bf1)T?XFz?!B+tJ2Al>8yOi;U0q%NZoFRkB}!c+$+(^mU$+eBY0{^OIce{|C=LhT6%guygh=4YCM-`{$>IJ7Bl<|ewxE)=!5(CZ4^f4*xEWM z^iVvIyA@O-DU&!Pj~~PY;!DWzO@NF$67KPMznnHN6;+ zP00+Cm6F;!9dXO~(1N~W7rlJWPq#l>bT_qfC99fCwIwW`$BUji32yY+d=~%tAqX{J>C=Gp z=7XM-&0&1$l&>MCS5}bClnJC6CN6i zD0RTGc3WPyJ4fN8jCk9oc&{%ZdyIg#$*l{0qIRP+xH&DPbh>D z3Bu{RkgVtWp|Zv`hL{pWz!l313Z}tgU0sv}Zc$jM{_gaXgo2H`QELj$a&q#QHZr)Oghl1X(2#Uy zC#V-Qt(qBWV;>_ za=UMAikRh3-n#7)PU*7>1tEP~XH*E_wLFf&1ubno|7ajQn2z0?3RC2(SFeJ%DX*|7 zm)K@S2kWTm>*?K0PQILuhj$S%f8b;ft(vT|6yyb6!jIM7NQSQx1*t zesq9d^TjD!Dic7yf&qT-)JF-J92lx9U|;HYYI-*svn}ZdyOw_tw0s;2`h!s(q6b!5hfMWv%{0>&umYr@XPwKH5 zmkau1Xc#$yLD2bWZTv%fK&B4BvXoN>Lng|hPxshWsYu@G@z{{TIKCi_d*8!~?nzP|<;SXzD~BS2hCPdtMO3<90j zpI`XGpCFro6o8)WY!t&s^bpz?w?fuX803Q_wQgwTWVM)>aulcuu;>tPkrTSEz zGp>y@jYVx1LpgpqMZ6t7(-p_CB>p1jF%T}#qFn)Mw7jS`dv>s~N#}_N++v{w*9&dP z_YWxjivSTp5klIhf8TU{8py4vPDE+(2dnZ`pjo<#pzq7*99{xgsrdtzu>`)pY{Vdx zr|G7wz_pS3qqB3rYEsi30+voKBfNNQbHF^Puok`Wik?D#r=@m3CWbyxF#yYJFCSm< znVNl%)XGJ+?5v)FE5_qj&XovVSEpK$EdWp6r`ajfTJ0+W$?#q*1!bM^4c!HA6rN{e zMCmxi?Gyn60K<^Fj?{~W*48zsJtO7)*LUOi!lz2xo{K-4JbyyXoNy|+M(IE=Y6o25 zNfq@jK-gRkSvE`zC0M~)nBeoG<-Em?Oj=%B6H`+Ls|fO)r|V~ABAsnO%%B7UQ;v+jNwgJzA?&!FnOm0Vx0Sir85t^mAlmUxP2b!`7S19?HLuuv zrjvip4|=THU+48bH@Vy}HYh3SFE8%!bE)DqM{s_-HNdA`v5z0Szrnj~)n26xB(ODU za7}&5AvPz}6eWj01s8w6v z+w2wsY6_#otSsLlAVPFt{6OWnU1005T}6I})6$d~rkE*0Xy&{)VY-)vmfzbHr!c@n zv84m8TB~*IYd8kXA(psQT$wpP+#Gh{qkA}RKB_5(BvCE`q<$J=NpKaNiaG69fBC5* zws>Mj#vKx_Mi~wU?F*m)_+rl;eCrP@9cs+m5CJ$Xdl>&=L@ai4xThw?bpWdLC{XvR zrTw>>h?yscP2MY7_DzA?hQP?WQA$o$7Ub2HA9J#pZ`KQLnlalGN^E7^Ii!3Y8&F(8 zoTBB`9NE%i0lpUpj`=WuCM@S485W^BNdx{B~L@ z>#nscbB(Qa<+)2oTqE-LYnQ$e-r3pa{ny@KW&Mu(RV&kKZ}<9w)QjtG%p*u*IEzKg zBt95tN2_Kt8<+elIawoW{%c-&5Cefh6M>0|W?XOn&MpU{_4<$*qpKVD^7ZT25O-b$ z=-;Jq;K1co^eAq~<=2H^T@$i~m2Jw&bfwZ<-cT?B0ksS<3t zf&SFk&=C0-PsQ`D1+L*MyYGIMo|>w~wgpY5lq60E&5Yh_kVbYCx*jAI?_HnPW5yPt zb->T-$pafhn3|f#plW+|E|L)Innb@12?RN01V3vDtAQSkc=zR20Wg8t-#V=4kkJyn zy0X$m6@Wm1CY*l`Z=28*AxMi3@(HEwM|2?kgoLCVws*oT@z-A;fmAFV2gXKX= z$$c1naT$Xtm0(CA$lz}H`ke&c_SHZ=wP-cWu9ft7au+D za{lUn$Kk0^_v5$v`$5!H-0^nb=`&|u+SkO@ zdYJ&9KXMC3$-Vcr8G2cXYA7Wtfg=|n*(Dr;$R;E{eF12kO;t^%iH4$NaUSLU z^XCsEdgC{??T0~iZwDrQ9Xt;FfY^wE=rmfU-_(42y$UDYd+Q09?q2wBtV2 z9!B1wbE8?BH1Ot7(?W?%2dehd=g(>#qI&bfhY#P=Qro&?M+mTdh&5boPh0JI;dSJa z^yN;-GByMBCp5jXwYJ-{L0Y2 z-Ev;J-@ahzYr>b&*}cV@LB6h3;?@6e+ z^<8Osmv7Rg_2-=xsgsJ1=0rhN-q0}Rhlgf{ksZ%jem_Qh1^lU8gi6k+0@v={xd6DR zfo?$cP9~^9mqEUNFt-sPx=BrZUb-&$<5R$mGtTFw4eVVINZLe(HhflR){GGqC`Zbu z3J51qkn9o;COPB#(XqjFj}j-m`RO7~Ik@uEvW{1gTz(QOvS}I`8lIM4K-#&9h;G7JO%LJ0+EbddhS(u(g{fhzb`-au`ASeVWD^~%bE zolzEgpnX{8N6Zwkz>iVewB36*T*5&}AZa?_e<~PK^aQp-9}WslaKIWtUl6E6wr5}* zcoA`HoOcg_+BuEiVgGW&%+JH6$i3&9_ChHFBZVtZY=t1YbCOzfP1hxRUld6w-tE1f z14)d){jfdXzatviLHvhD1Az&k72&kcSeeHpK+fpBnR)dKt9FHjF389ey(BT`iFCE1 z_O&T#4FPLYRM zW-J^!p`nox68s|F9Oqugem^EE8dYE6c|5W_`Lz);w`2)+aXWU5wb-0QP9ek@o)Uyk z7K9&Yqg&`?N!WY{1|+n?_jXHBCTdliGAFSDc#is?K;8#M6p)V8)lu!y%|GxMKH-+s zB_t6_y$qkV95w=^?x06CQIA!PU);Ff=|>`%U{UZVqL?X+rtbWMii?84N#zAj&IbB` zYmhd;0FhN{D3o1-1g?=wqlFsM>Iux$L`&B=P=Fm@(P;m6G2X1SgcGMkOng%O_Hr#fFK7i z;z?d&SDBErPqP0fqtQ+4_#V;E<~N=;jtX9A>Tnk-J>dc`N1o#h_hVyUWZ_PVs4f1z zKzl(Z;jmHeO)$rC3lqP*LlYDG_->t0K7B}qJJc){MG6>#?O^0w&7nAXmG^uHn+7gn zskJ#Av~APRp*|68QJGs$e*Jo5yUfY&&+9M`qzG};UjjJ3c>t?c(bu21P^R_78T%R6 z+DCGjs~6<&&rsrF#)QHh!`_V4R2C3G0|*w9O!6(E7i`S!k9EDQ~@P*{do!*f5Q1_F#bkJR2svt$92$6q zKZzZ-xoZf(xOw;Pi8FdBaO|5LlqrLns<9VuIsDM{)YKb_0ELZz+fgKt8FW~RXna1P z3_ZP;tGlIA)o^kc2@q08aLDpO7K6(t0UsJilz2zzv2@+5aLr|Gn}zjR^!-E3JKYN1 zVi;q28lr^xlT0odB0DBVJC01B9Ku@d$_#%`0*b&5d?_>*G3OBFV;~Eu&&73v^pX6N zR@o+n+h9~r^s%|0nj#gIN;zv3B?YdqB_etTqB4vv2ugC$r~?=1ftOyK&nTY1b55(K(@k7rc4n? zEoj676PH%qu8ec(HaGGbVWrzdAbaE386Flz!AF?g8iHG@A8gqFT^`EF%S4C9n}I90 zMIbdT?d@~Bn5d`|9Z3w}&#_eS@o4GjtQ(GdumAHr2FXMg>D5&Ru7|w=;0S}ujBsl8 zFx*=1bOC4;hQm$6%?6#@voJg)RxBP{Coj~nD)U%ziy%$T?e!Lhuxip!TYGDKZ0x9^ zscDwpqz@(W-hV?LlH~HPJX>;pJ4#A?PBI7sw#<{qk7d3~*M%_4Eu&ctj?DD(dUOD7 zp!@tkRhis_W=N7n=vE*3TxKRXsFUEa_YCg={ z8CfJhbsi1a!LR{N@pX=$p?qG?Wz|dlSyKka#%(W3oD;fUW@_!22bCoh(Od7Hck~ zz@-W>!x<3zd6K()CBeH1y*}!X-KgXmo{U7H$xM-UgF6@Ph@y(y?K?}^%;MnihyZxW zTD|6lnc+M+qpI5AkYIlrOrjIwumK}o0&oR7EeyvkPT3$JiN9eRvwOp3rJn-v)yP@> z0;0)5bf$HavT7A14^*5h$55z{sQeWuIi4J|QmbT^jG%$EdK&v9w{Xrh{5;N*ivhZ7 z0$8U8nTF-%0=DX}s?#kX>#e|cE-d>mpZRZhvjOM6Fx|qM;xw0sR5qNMuU_?6pt^|F zv$7eRy}$3&W0FF+$hXazXi;kwfZ+wAvRhO~&SN}>=yk|s3lV>$q4Axac#Gx5jPn{c zug!`834MvEe|Q_ydBeUi!XF0vV6y>;p9fmJ?<-YU&YoxZwz)2BppT!6R^@9aH`$>A zQf><@7aa_Q13OS$hT*?$%QjuLu+Uu{Gg867@L8L0e=770bE5G=k(<#F$2EpU!DQf; zepE6mMLGmD{7+hZ%+l7$uoIQXVQH3N$?S-%$qUhxiYo~l+9PO?s_iwP=Ac10BOPGg4Mry{y zZ~!CM`Qk0eAP&&=Du3xP7@T*X%$*I^&NA9vXh%5eLu8QPuK*VGqz*jDT_r=oFnom^ zN=p6XfqvW!82yRH$JuhfioHGRRZ2cQynny()gc$q^B)JlK5gb_m6nujfC@WLs`D>$ z?FLOte4YmBE|m1oE@R%ZU##1kI0*GPIBGXX<{fAb{5c|TGjrhjU{UJimekshx(<$_ z3Ey!z8Yn3RnjW{E?x+Xlk4WhA2fLo?sKN4A_Gh|e3E2bboHGx^uHZT%WppDxS8Q$1 z5SLKWFkqWzq5LfUh;}O%RiZBpmva<~d+)O_Ge_7$$Ql7NHIRjkNZ}8;xpO8E;YX0_ zDqIVexHeZHPH3VI!0t`XX)rouI}-W$aVU_BQ~RAGL;5e$z)7p}ttC>Z`RWy)$QCM8Xb2<{egB;tJSN-HA-5Gw1OFRi zRQtduNoNGwRAz7=q(1~ldn!;s{0gT}joCK<)Ce)jnt4tQCydz4qg5b)KO{VS#*ONC zYUIM)w4bKYoBxU58RTS(ZQjR{U$W zfVABjJ;y$>=bmLsbMbyX_S0oUf|;CcL`z`dYGkLUdr{Eaq|m1!QXCRtCImb)CELhd zJ;Bd9A%jU+bZ-rR+SEe~PL|Pt-``)_(?;@*F2K3EU_qQjMbL>Khikm>C6tB_9zDtf zja^_@3`~95OJJl$P#lz2I$w$+$&$nN4V2ft>cg#83gdM6HgUKu2O? zFu+HQJyZ$zJLzz^gRM}Ghk{pHiKTZB$MW%W=g5)bTPjK4aL<8*2TKWK{1gx{xR~*) zplB3`GHh!BPM&7qr({|nZHO{Cp&EQT7KR?EB}`v9a`uS`1BeVuesUNu4q0^faL#ZdMQ91gED&!B?g$#3{iGJFk$)Ktp;W=&=ZO2~`|v@G z(j05yW<n=d+E!r5KbHGzC;25>L>&d5Trdnqibc1oL7DsD);+YG@NC)_BTPZh%~H( ztWt(0RNZEmE=^t7d@@go_tb=#FO5CoG+Z>(e|8^Qg;f5B&zLR41GHQ(Aka9Drk$f@ z0pd~+=9HJ1d0!m|-{rr{DFm|b({1@DkLfGu!CqF0ht&fk5KJP$7y~NKed$ z%tJzr3j>dc_kx|Ij7(j+MtN7)2cAXa!QfSorIi&@^^AHG z8;i`|kpDMz95p0_p5fd*Aa}`pn&E6CdJ{(VZ|C&&3!6DIwtt1*_$GR)dgPmbox?@S zK6AZDM=ebv;!A8Y0M&F%l>8)e*UvcqJS;3o|Jm9Z%_wdhti}HcU z_~hd?!N2~7X5`=`JQ83TkgH)C9T{_-?3Odba0edl zh-hHJ97rI`@?97^FLCR{yIjl`h-wm)k5?e)^8Uv0!Nbejr{v;t40kYsZiP`5Q6UfD zt>ImOb79!3Ep0Ms_>bT;71;&QT5@fB)wyg zLS%MDaO0pS+XiNZe~}r%m_BmQ7Xqi#w7lpZK0_sY7p+=0BL|fpcLW*sN}>;lUPN1u z(*|tO6DY`O_>MJ%A;YE_3OiO@G)()0$Ea+QQ=pK}uD&6LlM{aitWkm3t9yBP5>SS% zPWg|;c^K*ru5R=kq@pyN6sTrVqEOnrsj9dj-{H;+B&ug!-LaVZ(ZM7k>*}u`=~O2@ZuUjd*N0_yr4W9C)UBog|;gcsOu5B}cbHg(pCyV4jXCJVd}L5gAW~ zW04SX>Mg6m?J8Ir{q3?Y(5){h%^|~r5^5Ti+;L4!X7ntlko9-z^5wQ(DG4lXC&}H9 z)(ko6;gx*k=;H3qP0{PV)}x8A62k)z5d|5No|R>9Wos)F$I_&KIQmQUYAIIh5uJ812 z4t<`ET#`XDkgl=0gUsS^b;Z~m8KZo=Ti_Ks5AgA&em$R=nwp?A>;<@$fk5_T6wEeU z!7St`fwN3K2#`RlIn#Y1#iejJMu94!XCR>r{z45iuwIUNtBL&dq@r^t47vOFSM60$ zh_5t%YeQUWP1oOv+-Ry4QBlYVm_Y3%kaj!}#-B*d7s-P|V3N(bYghTFPn+=C-RSGC zYEcGYULKFQI2#x*GDi{xJvnU&8w`=Icdfs^E~-cJat(B6h6I>R2oFypQ3G+1HxU&~ zOj*7)ENx<3fAkU%4q_HIqjw=|JWyH62=jyCfShD@@7{NBQ&KEdC+)OS;wsL^XX&=q zvfaz=y6lC=utX{;Dk{b)00^?#<136IYD_g>zm8E}66dv);@t$=eJuGx3Py^2*!Qp| z6_Guk1b2Eg3hXyIyc3q$@RIi2BX4jqNG1VSt2%msfo&X1n6mk0hmA8cn^ za}#}=tm*M+P?l?>nso!cL>f-HWt0OWX|*B!PLeJlCF9UcXrmAM?jzq5#m$P~2IQ}A z-vA#M2Y^Bk0^f(GDOl$8T~AX{A7?GPjdeJK3STiee%#_&V4zaEp->4%&5uKxKCp=Y z>^v~dA-LZ@!}2a<`hgYukA{#6s}#6jWBD0C3UP^o2bIH4d1)?*tgX{PfEjuLf4lDGrEF}>iPIR0)e1yq9L>0etg}-PK{At9+dWJ# zWsjW*@`5bDxdNh{q0kq`m1JWo2;R?ehz=ms~K{NKdX^zB^Tq?L7l;+k`;~i`JoUZbJ z#%Q&(97HVKZEC} zyOXfQX5oFvgQ@HsP9YU5kfvlPWE?pSoLpfm&ujm>@SCKNs1%%K$9Kruk_kMvjW4Rs zGctykZlWyz2@cV5|2Dda7pXX{tgSugfm-c{v7Iapkq{e(?l$|HyL;Q-;4)keVD_yk z2$+YWRQYZoHYJSZ20|QstR78ZDR4e``0zi7c%dJ>hklxjVcpF{gE}Y)!OjM0`Hh4q ze+b&Jw=lN1rxfwTM{HMr!wq9`7$(1UAADOTi}5;}ZX zBZc2ak{~m>qw#Y_JDxX{k$?=~18w7cyGA{|336~9B=79ms{7v0$hQk1x$wOPitI}O zWVPOFBx0nTV_FJ|#C`y;PzeO1zK3ZV>nGyL6Vf7Ojj1^D2ZL47J9poR#>W0ao{w-V zSKy!Z3pL2`D}p8|?DN-9;Hm3qlEYM351-3pulO_VKKS=97c?TN56^%MJb$}Hg}iwQ zIBQA|5jH5QU*c8uc>5wDO7Xx$ZPYC<`f}yRn(4hT4+%1)g@WE|jW14;o_DBHsoK@W zM3#QO;Js+;mU?`6H$^wAwm|9ne@6%Z?f*2*$iDTrMQY^6+h}QyL&^WPGpK87l5Ay% zojB~vaOu-xj8KEfz|fE(C4mT(R;W2I@-s(aXaB~6RL3_BcW6CM6ZLE8X3C7cSfb ztizcuc=v_>Al3}PCSCl(5jo80fwt@ag=HPF9(pEXMhWY_jH|}@*ceG4nG{{$ikDuF z!$t9#W4yefzvMW5vU*BVTW+fD)7^m`6@- zZ3um0>3KL(plW^Rg-+=_{-%nrr-}Gd34gR+K4Yw`=P^L$l*AKxUuj4Y*xLo97xfCg zdfMBgNfR!Jy6cd1l5tVE1AoKwfqbnJAG~QJug-KGIb4>%q;P$r#Bl5k2JV4D^prwu z3_5AK-{q5n3^c73?au<7Ps^3VtfE5*cFaRyAUD#;j_9s)W*H!hsb9D~4ImE}sP0!_ zH&on)8UpE=nEXWG%)Yx@N=F>b_8vkDX)Z0mOL}UL>KmvBN{E->q_!BdSKz}!!uunS zFFH($2#%Bhnt%$Isq7xwG!ybnKr6=h}iVH+}{~yGV5px+}?|WG*Y$uYeQ#eXP|>UW`K)a zpXzl4SeHA*x|JA$SHbn3mZT?TJXn6g1G6SFFNf;$G|{!r^?(Y zwsDXnE5_j5ISWXJNmu*&z0nrjJ|dU{hiW!?r%16QZji6Yt~_ASZ0tt@i zAC)F`KNs3&-jZEBH9xPvN6+owY=AV5Z!Qo)dA0h(nAGzL_ZPPB6hQYaJq3>OXZcxQ z0Pr~l+(3A<$pakz<`B3GZ-kDrlG@K~3ZG(>JQz#&%mTjN^1m+4cvzZntQ)fJ+*yef z&zImLt6;L#0u68g))8Fi3Hquh$8K}d0@Jg&u=3Ig{q8=YV+0nwH zS)D>c5Ad1|G~O!Y0p5%Ep#Z$7IbpNFugbjj1q7k~h9>TXSP zUET*4hO}2=b{MHA0y7v_kdqUHW|Q<~d%V{uN6eLboHFtNSTLSOnU>^1q(`g~yjcw< zvv+tHAlzAsGW4i#&I>-OK!y#jD8YIPE1EO};h-y`06HO99}5Bb3uGcO7Hat3^r9zl zBxk<73tSvBw7@EJ(l4n=%WMCrXA)7A`>{hX?!gb>Id!zL0%M{dJUhHHGMwn3twX9V z=ivEo<>F#Q;9%zY+46DSqaG6`$a6}xs(UPWXPmf%#%c4&kBN^jU-eHW_2*}7dlz-l z|0{!8c>Xaffr-V9_9JfpT$x4VH@%`PyO)wi&dgXzNdFU0(E_QARxk^WySn}V{ihqm z{RExAbt)gU5XZsOucGTdv9Z2p4+6kuNAr4c-CrFDt9T(BKh=Vrn|9!XhEkt&2rz+E z6AWigGcZduN8nG zr204N2Nh@tILWpl@oO0eTpy+aBC^`eEpGx+tbCkRIts}BDvQWjui<&{0L371)G`+lU@kkqzK%NH!{g z?0?qtlw^(3j+wDx(OL5sDq{zTuoZva~@%;7lPAy)U~UR zW0)-!ROcX@cawkW7vK#Ez>$^O)1XDh+fzCm{RcA_!`_YRLEiE5Ir`oEV9@6#esLl! zBl&+Vpgkh@R)XT{hsu6WBL;0+=`)0TpyBA{{Ofp1N|ORLLeMhOp~8)z7t|&?-aGG85Ec%9s?r0) zH)zWd{w^G$01aBU(9xwOw$_0?s{jT7$s@l05!?WZJ7@U^l|V`aRQ8cWCLuhM#889x zCWo=)q5UDP^+!dzF?{cLZ?6`dM5_-~`D!-@fSD{X%DvjS58gCGBcsoVDE>g1dfXL2 zE>?8~YR;!UyEr)H6Ef&xIdE*->-=3uU>`FVMn%4PzRi0IH%KGF^XNa5Pa6MU3!v5r zk=_ev1~Gj2%B3}$dw4n-oAjWPBQwpAAB8lC)aH&2%=9{r9uktArvj@O*nv_BX?biI zLT<-W#>okC$}s0LBecZqe>S-tZ9xxBjQK76J07h|qd`ilUNdv+PWEcbu5XD8FR_(a z=hSOSzQz{WyWOQu=S!)f64xc$P>zaeRy zp80!5i*+-IGAI$m?jR=&G1|s;2ZPHxI-cyBVzqxBWtxIoJ$2hQ)Ikym(RnCCq1V~b z@wKI~@hw#8Mp{NjUZMvNUh%qc;dv0qdl(lxzM_Z(yvqk(1e5Kl4PIXe$AG&s#7hsm z+L)Oo9$~v9W_4^AE-?)}l&iX|AxP6>QNGN{!J&3_es zlF6)O`b?&A0aLAe_S_1zLR?Vgo`m~|9HN7owz8=SnN$R7Z8B1TmY1w@3Xu~{-rph^ zk?4+z9K-meIT+Zq6vd*93fYX2H<&SDFF*fKmee}*Fs)B7csM)nI$K%v`^tx;4w;wm zazVYbN%#Gn{39n^%d03^mmf1e(i8NhPk0hKi5VJ-MDqNvBts!KgpPGZjG!!&y6=1MBgqTWb%G0s~&^pSL?8ag&+VqhAghHmjGpK zV+zap_Tz{5Q*bJG6nP?NmVH>1Wl5?MUFkkiQC8SQlt5@8sl5?HkvwDX5`gu!$gZE!6-+5B|J?5`E{Q^kwQCPu6E8OUT86ZJ~oV{M}(}UZ!cXV{sKsyQ|)zh#IqjyR^&G*0s zF@UoB!SUR}NpURbD!TNz$>crU>;Gmo=?P$uU~a=uH!7bxMGo6}4(Gse@`d2KJ#{== zmmGVCg13rj1(roYz~L>2W*CtcXP`9P%E}rwgLI5lz)ukb4dH zUnJM}1qMO8ziykl&!)9|U$23+LYXRC_iDA94N&vDHY+7Rn{hlJ=|M4lZmu5c0C=Z1 z5!hmSszWwu5~IuX#1Z%rzLP8ktX+vN%PmF8lk839M;$(j&UfdW|F-^W`;kA{^p-D(`t6Og+w+nofNm z=U*`hIrBq)2hdGJVi|Lg&_b_e1Dg9G3?+v6!LKqi$6U^z-$kK_w`zt`8%4}X(Wo@1 zIAv7eNX#U_aJRU|-O%E+hG7@QxyvOpK7#y zEXv6#P{1KJF}}tXGD8Wx6(o|uGkFV8vLZig2~ThU5&;nnBZptV@+dkQ+xOi$JG)G> z-o$nDU?_VtF$Fre4RAS5MG6AjPgl{=!k3nY0B?Yqx*V8R1HKwRhxC(h0U5-CZKQ1% z0OYcjAd4TML%zUW9Cw_A+wVT93mqP=DKwclyk}3mx*8#Yoay}UwStE_YY9|2C$Wj~ zJ}5#)SuypJq%a`TLTHa@|Npc(q*@YN0a57N$urKpik{3@0E`JO>66IHz9NKo#Uq4+ zQK!q%62`M~thZ8H0zT6wBn4QYcr(!tIDW3OUBN^Dy#`9{MBer^bbg{8k2C!2Ae5l{ zU%CN0t89dS@xrA-5Rft}2dnlHORbO>SZ@Qn@D@2K_})iX70;hsH*{LjESo5$JNu~b8b0G5MhyuJ zAw5lVFZEP@J-d#7?C#*2?+YVwiA-V%l!{tfk)IKG^Bvqp^AyT%lL16=+3BXr{=-#n zN*#Gzb6SV>|7|lw1hSfOE1EvKujvhwF{tQeZ`cpFw|K2 z4!kU>tvF1;+8{Ln>iR7~4c@@?75~UVW!mU3f4D~BC}w@IHf%a+tk@?5XoS*H2*V4hW-zC?A18en(vcj2b?MGIP5hMl zk6_fu!pu5qz9A(A8JSqb-ynkTGY)}iwB#VYUShid%l?dg`$Rq!NcH99dF%PkmX@dn z`)8=t5KzkuLHGq|w+;}9dis!6+tc{L%@#4*rZoTX`A8}XnjY*V!Mu79& zGUbkNpeU%ted{UN+_d|N$pWHfhB5;prU(2s4{kPC2)r`?`vsZw~y}oV*=1 zX<6^uAokCzp88amquv}*u3yJ~4G28n?_-Qvt_V>1d{SjU*&zOfQ~)dZ$>dSOG4Yl2 zFj5~4wPj#=;QJBNmpO{?=SM#vt0DZp=>CXv0Cy4sXbC(St8BJ%LQePN-_&%zAA<%H{`Kib==PxH_Qxv_ec(bw z>D|36KnOuZfLi=S!KuW8zzZM^Pn|w};$qqpYXlibAt3D$hysGDm)HDu3PB#8NPtPk zqksxAg!TmL9i2!i)mkG=t`wBO*U%TxQ6s%$7%!f#^s7I0xBV@E5QHlIOY}(!fpFSL zH9r`#aUXQ@jUyv^Kkg#}st0u83rKwo5a$}M-zbFiRG4kA0BBG3=oI;A^!Yu{2|E{G zX#706=O9RO@_3B9EO2hyJHuY zS5nfo>+naZo6SXG9(#e;crUHwWitACxppcJJQ_e(j%pTH-s#9-!PqlZs$O)bhZRgE z@LJ?hOk#QqUf;fRm@krGMaa_#7+quheU{dNa7LuFk=zlL(eTXXZz@ z+snMEzxTkz@vx=yW6cr5NqzY4PJ+bxu=luy#$A-KSA0uMqtbfaL(@zoZTqy5O=&{X zr9Qt26X1TJuB%sRWQ&>(JT7~`5yHnvqc~V?(y%tWMMwE|Vmk06Q%s*1*WM%pCf37y z)P&UFFUk(KJle%mNvzoVFk-IUw1I1{6D=eq_ZFzdeV_wJV}G+V{X_#FHyOk|X=7Nt zCHtnVOcM_goU@0IN=fxJeEu9njAIaAW?_SCIj-Z=xcgoJ*kv%wzk~om=N42WDWYJY zmI{OLnC|`S=LtN=7ZB9To1>u-5owoUmQve&2zG)an4p%pB<<3sad;tje)Rca z9Bn*!mkKR*AOY{4+Kj)CPgXw&ZI{9GB_1dy7;s&j0gl;{4nQC(xqHVB;nIyaL>>x^ zXhKt`-DeT-L5sW^;!r|JH0Y6(G;*)-W#iZa(F@?4B33Kd7eBrqBZ=T2+*ZPHC_^4V z2x`AoI-f8p=z?gAAh;omt34N%^7JG2{5d<~pDNIqR_t7f2cL^WuWmslCJS;v+@1iw`*DNbU71=5!&yF+%Dd@|J(8pyY#WfIJdmohCcq$DE2@ayr*Cz3Px-OEEP=v-3YsAh& zPH>Wt`lvvVhG^qNWPuTyfkHq4qBPuY1_BOu;c7-n{SKDjAD8P(>`3)TzcScgc|ztJ z`sF|XTkY2Rps>2m)gPCmc!g3MBUc z6c63x(}xeK!*)FY1kS;tb2FgY3Zi*xI=Tu%6IJ1~xD6;BnxB6_bzJ~@Bb=lCsqF_m z`TND|B4+8n^n8KQRrAd3Gxum<7f4rXN&H1adV5M~UmS2%t~xLBA$ z{rCMgL$1);&!3Mjp?~?z{0nm_w%H%WH@-&4-N1n_3ECLM|_tc;%j zx)%rd30&_a4+n4-4x~;9O=ty;Dn8_F8ku!s!@Lg`QFYsI!*i0UT{!@y2Gs1L54u0e zpYI8_kzn6?YQSFLpPRcs$@mXY{=iV$w*oF?mM{|I!^3Jd&I?g1dFOT^+(6fa5HPkT z`mPA{Nt}7wnfv{szvKqPmvVPzt?XG ziuhw=Q&VzSw60>p9G`~^NsVW5<*jKxye6*65Sw;X zYX?a|Ox+mtvDNV`zRex*a6zwU_o}ckbouXJO^|K`U2$ONS=sPLd;EAf)ZQ@pZ9yc3 zHtJ@dIOuQ!|NM@55lkU5D%*`S(i^Ffy^!DcA%)5bvLk|^N5q&A5UPMQ=%{gH^P!Ey zU@1Og-=D61m;%{xkHMdH14C3WIWyOvaedEs+^9__9@#?F~|4 zU22p#U39A>KywGe;r20qtxV$$*pH~4Wz`NzfV)}YM3>~mMM8Vn>4f3P5i#_uSi7W& zZDovs^~)H2DIg%}l0^hX@D%g9mBNK^oD&|b?!^oJ_Yp<`z~~IiX=r1nUUq;+noS!K zPbq`&B5cETjC&s)bv!!Y)PBHw2|zi%94|$5nRPd@Ho^p!fuMgZ%*-eU?|@SD_0>B( z<&THzh-rOY41}A#9u>kxE3WFmqqO4BV*@#;Jbnk_k*pXDI)D z(hWIdK-;JYYPPMWx;YH8Cvl-7fb*$v_uPL|3uQbB4uEE?vNdoU=jA0VRTuFlcOW}%k%%`{x&>33HVPTPxG%PvV;M~bb=!yMs z5Vrn8mx9}K9?|tglF4;wcy+MjwhyJ&s>~n*QvqO@w~)%~!JlKp64kVE5^+&U78ehe zqDOs*>`+sj+v_;Qc#uHR5gRC>0womHBtqGdl*EIs{0I$qN8w8do{m65YeQ)LYvI5J z#p^TYSV0cUfcd`8&dw+B8JbB+N!2zt=TgYbRWBIxhL)kei9Sdx{G~5939QGUlo2DD z*Yhc65DCz#LM1DY00TrnK7=^b1o6yDf)iSTxS98N&@VVr--8dMEdDe_24zTB$y3&e*<<7i@WF)Q(y@=Hrs zJTYCRA{L0QVnKS?JoMzt$N#KdFX%$o>64o)__3)endapmkA~dlE`!H z>s9!x)*Nm0G>dvs>Ed^~h2+yKVt+UP4s^>KvXW4jQa#BQRY_8;2EiIX1~D!(v5_0%CWY8zch@hh8`d-j=Hz6MdN z2lu-+?t)Wf_Jvc-KwWpILDZ<`u8IK%6h=z-8@!M0fWf|<)eIG;e*-V3aY5Hb_#1+I z%N_2WLPfNVRNIP#XM}-8VKDcq9U8>vOKhp4<|h2v0Ji6_mS{gef56Qi>TZo{SWJH8utYt}TFr5iwan=pQ`Q3HszEJYx^Jw!?>kN4Oo@$vtIZitUH z&=;@CHE*gNXA6sM>*@eDeYHyx8wNyVIx3O3Qm){w7guKh$EajZy-sRZ1x!h|!;!0dH8lI(v zwY!tW?^Go2ZVmvT+^PW?JfuQEd$w9y&p+|qbRreP0&?ce8OLk-xr9U!6aD!3xX`*d z891=m$SRax&!WXBVJi^-N=DEO#5RupNjcJBCKB2H@#BO!Ot;3cD<|W{CKPtVWZmI} z!ENr(pPUecoQ|lV`6i)dxi+l@iv@E2s1cP9JG>p;lLk>8l01ul?K6PzlgREaF~WOi z0$O+raT1sYz5R5=qx$+G;_t`TjR&^E&scSL_o&TDRJ2GkXZ+S#>8*=~spITbD8IEm zJyFQk6sp%+T&)YSssTL(>ZzHaSWmAw;F2ZCz(qJVQ9s{xcfW*I1A78~M~U73da8o*^ zj>6l>gpts`eJ6q+FW@>unIRlI7_vzfd^)Wi9cEPp;4>gDL|W9X*todrBi!63Z1kx< zjMyDzhs5*6Q{qu~u4-$G%A7b6F0eiFHO7ut5X#jK48%ny0x91LhK;ZV5YQ5uNMe%) zgimjWtPsHd7_tJFgt_y9+b&-0)JCUE<0329_w}o|rf}H$!`dMs?{w^Hfdsb_uPtb2 zFWbdvLJJ3l5$ss&`#RI{m0g0&APmn6N^v~8VUV<$A+*v+p@O|AsX<|7caDc!mA(+i#Z_i zjEM<1HMfqEmFkhZzt5HV;`;A00^kan-c24)$vCXERmaOh>vcV4mWF$IDz}gu&YBKCl}@BP{QYX3DD!$SzEf)$!EHSAK6I{p+g z{bwr;sZ~78GHrAD|0cEo5t*!=;3u^i^lLc3MmD>Rt*soJy61_L1Hfttx{sRsTfq&& zl?WOIUElU;NNDT=s}* zL1|13JAxh_S&6xnG8#bE6|e%HtOH}Ui1IniEo!tJ-S)&bW=QOBfXlk0aO8y#qv`G2 zf!HZFN@kG)>kIasWn_9}4glx;vxSN(37;{9x_)YhYQg&FLs~+Zlki9*yGRMnB#Y&D zP&pC#^`K~uo;|ShEyOUZkbFMDB%E4oI^&Nb!?5H{`U^zwhWu&KHZpGiB0!3ur z(@#lnQx;8T9gxU&yD_Cy-Tr59B#ifhB^Z)Fn!uX#U=Z+Yq^}+RKDuc#AUEH$4a$Cv zmk*LTigH}7zAQ=q8EVs4=;sf>?u0+DLw=n#dgdzxls%CB$v&gF_yr_!5qvMuxD(kO z_K-_KV*DIbw;yH(Ok#ewsK>)PpM0UwH9GAnKX(mjUr1AE!C?}`A-*TW4rhq^7vNO5 z)i8X1R10)=bR;?U*njHpkJXcYl=1#=z_!g@0DwEOS^l{=>lXwmhGt)<;YK=XKjq*M z-o#^+f$e~w$VrI94+4O0kXYi1F3kQ#s~3Gda#NL477kSiJ+@{_w5@SFfszI6MpdPdeGhzKMSf9 za%Xy!WK`2fLcH1>?2|Q>G9+cU#lHr4uA|c{gze_f&m8bcuxq18c#TLd9 zI9ma@p)oa|gBE5gmT=|!A}IL&0`BZ@HxA%ls!4?^Rx_nJt6~S+6G>OK_#Xve2R~ThfRA+=MSC7)%Vp~GQFEJ6=z3zPmk$f!;-D;M1;=sI)$dB97;k@bae0<-|K!Z{>Agdpp!r6pcU zS3}i<9zS~lH~v{96=+KT)U_T5N8Zs- zFbrb^weR!BHB?ge;HVu0ndev5p2!+aZhIgWFV3N%t)&&qzj8_oA3D|Lqk3z2*nAE-5_paE6T@^41*aRaQN>w zCjq#c!03r9MqwW#`48W)K?dhy&jT4)XEG@!n@ zqE8QA+7IcNFCAn#`Hd4%1%rJU|06HZ602!jody_V0VFySW@bM~%@Mtg^Nz<7%3@x# zGYBeug@iAW$e>%)?4f&KF)7xJ+T`O3b9nQ&rR*u_S+K2yJN{6WdGWW0p2B%>eS^K)^l|Nl30AAz{<>1BY!MjoqyQRCAb-tJx(q~9bA z-WRV5_f;YTnTI3~IBWlfZi zM7q&W38|^T&>t6*wpO~WOI84VXUCG~9Z)qrPB}fg5GX#42bWl^3@4S1-E2Pxiinuo z@(>jaRM<@UknCGCpJKODykS^guzj}a(~Bro8w*z5h}JtK=q<1X?aqoksX80IH*Q5fP2hkA7witdD}+ zT84v^ikmhI1Vk4uinrzkT^K~3ZNjnECTRGk5Kp|X6168_e0-z!kmwvifd^Afe4oE^ zj8e9ZCqgtppJh5mc^Gj>dZlN1>D>Y#j1bMR!6 z(N!0`hnwcxYcpCXfX-@aKKo?r-QS5>j2W7m@Wz8U1em|s0MtLn@W*1e$1meff}9-I zcl4quzl_O1r0vfq8R;+`6BW$?{2HXf?q*?8rCCIIYljJj3iS33*lO;j-zq0|#uGvZ zcLaFi(-`*vS%|f+x$4*4(JRIQEfybh?W_gMYXvBD=^dZ4Cgwqixc|#tPF2ieJE%P3 zt`elEq0R!(ouhu*bLGS=YQE?Ius>g5W1_Ccx}F;_Yn;*Up+&gQ&IFA!0I1opnqI71 zG;iail6RSbKm#I&!JA4Flm~9|hXDcaAe3mWa& zVSrb;O7+#&so%D&=Qp0&Dv-%51inH82X^$~GpQw)4>me8qQ3amDqX z+H%!>(htd+%O{WgreVWRQlj9c2x~ zHu7p)9EdcGsnF1o7cS_nvti{+l3i>3p^%Rx67nBIIbd&B+RVmPdf?EZt?*6t{^KE* z_K9yDm;M$?N*Jalv4-L#U^0pjdJ^4to4;37lSMo_xgsXkg$UySlrbg!Ww!nw&*@U8 zewwSmx)cl|&&U>#dkKSuX4x)2F=Xn!N=@a02x$*gwrT%VF?;Owh$XpQT$`qs-?Fdf z?OPMg^_0IErU0n>VDWZJ;yfu%wB|1`d(ER~Gblau+WEMjYTWa3Thim0<2Pc&wFSd|(NH3=zZ`W4 zyLVaVQjBY{b3R=pg=%l4nt4c6RN&g0iy{Smb||{uK@c+Tv4bxlTCMP}u9kx{<;x{IM8WTa>>9Qj&|%n2=8L#92+eVo zL1c{f&lgXq$fHxHV3^D<0%bz9JuN_+&#$y@+RDboQISwyn!7BEV-(k;Hi4^-^1}*B z5I2y{lq#}(Z_N{jE=mcF9M_crdw#6@`veNHHsty9h~6`A(yP@Dc_U>8O*5~)VQ=Bh zkRLe8bpf2Yv%2SRdZ1ch1|fExLA5M~Zj2vLC0@|+aX;N^244E+->-GkQvkdJmI}on zidclphjR;MrP~@(AcuhM{S+i3M1~g}bWDa)GHsUNa}327hmHfvBm#6Ckz2>X2E zU%%do!%NVS3ykS>sayrRdh3qiGjrAKq)Tz0&sQ!hm-BNkF?s6beA;-!MV)$k^$&?T zn`^HY|E6;MN`F+x+PO~QxO*ObN!2xAH{{;ftfnuDZ^T!m04}@?mzP1J!dd>XTi{6! zmY0^&#Z$4u7OIb32a?`&%9`*B6>kAThHS<5{Oeh}IB>*@fl=QJ9YO(PhCcR2dkap4 z6QBG;P?0ce_B;SvN;r;yj-nSL3(L%}z4* zQ5S8%v;yIQFo9tI1KFZMDz+kTXAPu8R^aUTEWlw!ef>Q+by*8l3uSqEPwC~kJkFY% zr&wQ0alyUM=e#TWYx9ZZ5^NiwAQFJlI-szMu0CW`923$8zoi4}W{;~YKpqiwqW^{X z>U`Dva=Qr_F*+_uBtMaHb!+>g0}mr4r~rLY>EFVqs;Q&ngY3D8moH6`s=SO~j+!AW zHs`OKv=ZxEJp2}Eek6o_UXRb;^ zJI`TgFRKr|9UF6uTir(~CMo%58Lg>-lRP>{k?qvfH8`#}T0Mq-{P@#`N%=({LIe#2 zZnPIdD_{+1@3DYU#U*_#;DTEQP^&z(0^U&?!f0+`QxuUnUJ7f~;@71on1A*^qXxWV z9AE|~_|U@NP(MGFSwtG{$G*J`r13+5INe{lm$2nRF6RlYdZ%@_CJZWX-;&{7DuFwP zX$tdii~O=z!-x#FRzyTaM0^v21qBUEHfnq}%AT^5(;J_h{TF%5IWbg#OCX+6Rn4bb zRHmV1Iq2WjJ%dH^cr&$rudM$4E3@Ax9=kZc0}>0Fl)Vc10eMX!vxz{rG3(Q~+{C>u#gUk)D7ryHL=EagRUK;THpP6ao`h zL8$I2e4^kq$DI(;;_SS)L$3dKS&exC>`+#~Obn{sIKW?1uzxE*Br*6WaT7_!_+eE53jH$>+gIDB{n*DSo@rh_O)q0n%w^6~JD1VCqS zkdgW!rb$Of31S5^`v1}c|XE>a=zv_7(kbYu+(wDR6&)Z{J&MUIS z=gnh1Ohlm5(^E$(&@RF?)rK_y-nc+e*1+c_ufpQYD1yD{Z?SEzrMJ%CIPf?Ev z04PGx)jk3)S~)AZxi5}fSb}om_`QC1R8QvcMoMK(jpHN!ury%y!J=IwTPKS5l(s<5%CaSpfsx(FZq2Q z_zD2N&d&`gee3B-04Us(_jofSfUuuYS5N7uO!<@n%V`57e)&j>gbKFPItC~!7Y-GoS|8)_8bs1C z5#FnpV?YB@V<b=H(N7cg>8GxX6*<1BHDcLS2ZosR*Zq-+s`T625uZHSeH# zUBz4yR&wURt+ToQxCIi5i|;2Qv*8YyxDNWonma*Ss&ZB>H@Qhzh2;&27tnYn=v;Kl z*g+h;nbRyhTfR;4`0Bq ztsWRkGC}o=Ld<3aXv9a+!~$$>GSD(8lFVY>>Y3=SY<5d6m8MPpe&YV+vlWN2-;j8% z^4)&wR=NYs+O2AtMgN>B47Hz1eeoyotNjt}OflP@IFkwU?l+M+Q#s)RcLR#UZdTRN z?sHVoC`+N{6%wkUqx<~%?>gB)TcmZ3LUMcT(v(>4^OFlQW71UjTQ`e->?~ z9))N~4ey@%a-%wIG9D-$h5E;WRFZW61dKfZL;4ZNAyzN5!|R9+bgZDf?!&TIQHF45 z;-VQtT=$D(!}Ayg+z6Wp5%vhiW)L(0A*mB$5X43k$p3m}mU?Sdo7ox&5)7We~3uHg9C*y>&3c*g)Wd{9%dt`8$w}@(#2cj1IxrJAJ9h zu^atvgEc!;Xy%eO-yasDG@zrxuY-71BeMfH@ZaxPhOia~l*1UYt3>mLV(#<#$dyuN ztnzW;Gmh-TGi?HWpoOJnp-qf_o-r9(3eE@LcTD$`FrcRgoAG3I^_s83*1gjpa#m z4hK{2t)e}IWLHtqD{mk^e&3d@TNU>|i_goOd!?T0?023!LiEOV*^T9ELrZ@3@1LEF zEoLpU3@#`=F$*Z)7Z(K)rd9lS9S>eY$1Tdh5wLqaVqz@lr~I_iE8cJMs^e2&B;~oR zu_57v)BP^QS837Gy929F$}3cyD;*NoW^bsZ89YWfd{@8J))Lv<6WmFyyx||OXCkzt zs1ky^4t$|ZZ}k86={{O^YN#m&oG?m3PTmjw+i%q{RkPz!O$f-TCt8u^kta!&l^lB> zZ$(zMV%t6IGHJwLV8+8r$D%#qm3YXo1?UT;(wA=CzD=Z)f+HYETDcAACryB`0b^0b z)K-sg)+&C}EV$HKb+2uj)cPsxer=M<}?+bnQ<>4|L?37vfdf9;*z|Qrogo zc%;TUZR2wNy#pVTZ}7HZaiijDZPU7??Ma1&%$QuU(U_qHWpus>Yl3|+e|vd*`woca zvpJlK{-ej$Ue7Z-D_-uJ`s?<`#EpR@hJ^B+?iWU^%1e6xiW#6b?4meb{=%*v_kr-8 zzJb{Y+p4gozP|g-19SWupa~U=^yx_m7I}~dDVELc+nLd04=@lu7LRJW0RHZfo%Gee z0?LPuqz8^2z3*HT!_bKrj~_5w!&A~2DWS_B#wKKLCr|)WeNfqRGyiGMfX_y{oaSB z#G-XSo+SH_y2P_CYidEb{qbKH;4OsC9m_hm;CCSOZ@}wcVJ?w}Gj1n&-OSAJVsrqd zAB1jjYfZllG)UbS@)5g(gK>`$>PD+N`$;&M36g@+g!juHQQ&E1>bE=12p~aGk({t` zL6{49{7Bc0xF#@#!*-G!Cm<~TS3 z>ug=?oiT&gXrFSr{?;TyV;RfTxgkx$*rYeiJZ=@U2e1A9&tAUJ(K`im<^`9>kJlJk zy2FD4qRer&atY;(SfvKeZ#$ZSomHoZu^YM^Vhd}RCF{?#pQ8V8Zbr)lddc@%S1f4! zb3Ra;MErwu6InNS;~mIO9M!n-IpWy~%vQZ${OJVUS|A{yKZyVbF3CH)%8R~EPY(Ry zY)Pzo`2u}+T(#ZAKL=j0%yi~*ftZ5rn-2G`ewpwiU#yDXq7uYL1|>9p1I?)Ri~7Zd zg@T>6IPkbFMlqo=_hw_TBR3Q2T0mwLMP+5BHCDzgSgzrFr`JwVD|?M~D4>}Y7%6~C z6D!rxGN7|L_AnPMlaTN#QX8x=NDk{?xpETlQ^&h^7RPOHSb8y;pNzluC4Htsx0vnh zQ32w~8(8~s0)5kafWDNT|9t)G2N^GM5nPa2WbW?i$#bjf!>Df_FZ*7_Er!-T)Mfj zI*+8{K@c2U8mtxf@;VE8zx4naOlT3u@$GCZH^>og_s;e5mT%t>E&yA*AI>nrQDFXN zl(f&geY@vHP^rDk+*_*UYilj#8`9;gBE8z?zEo|G7ifPunMylN-tFW7II0|7MOIBu zyV7y}g7c?>XRdcwSBL%1t-&$G14%}-E`P_(Y&|KD5eZIGgX}=e`5RBR&!tZ9WAK2v z*fTTpwgv{UgFT&iFZqb{PU|2*)U9Awm<%3U0zF}3@+PdpeSIA8Vkn9?8}+b1I^~7N z430kcK*+f4!c^_Ea&qok85;K8mTt}+04CUoG=6=F;46?o?y?W4>m0TD8@K2r0}Rhc zHrKM1t|fn4pT+USHv4UmpJCBpNQ*fj%59ytF}Q2qyx;l!ZTDIh)|&N|st=*DAhe6P zo*toBLA@G+(zfK~g$FY84I)E$7NL6>hje;vRM0*D<*o?}@nAE#W306B{PX|bkE>jO z5PBnNnwZJ(3+>P1FtFRj?94jmtUp&lB7)220F7xG)S$tv3_ks?`x$F$A>UZyq9oThq0Y<<8fdK~i#&TB7 z{oj9b99@!m9lf4RL;-EgbySuA*puS7br=E3?*Upl*~^uTv_G6#Fef4wOYA-af^!_)fCQoPyT!C~M5nkuJ5 z`vx3G=%HBMg7Sl0H+-A^LM6}N8l-+U7uDfsAp)6n$xH5h7GO0X(3(SP5qSpuVSlbb z@%$OH>jixL-Dn^-dfhh`xS;d;U4@}*2KnH3t^(wP>MUEjx!IWZF@Be%=*LcpsXUt* zG`?AXh|UyXf09&ZI*d<4*(Lp6iV39Vg|ysUB6jT$mI?rt9D#sOFY(DEE2PM}Ag#o4 zGCh?5opzDYe4EpN-iSyTwHuS{FudPu^fi>G44tkq zG>m$IMNY3*u1H@ve(V@M!q~`2VDUj-yhT=4PE;fts$8DlHO!Nx2x(I?`bi+Rc_tK` zZp)8KZ6rt}whL!ZDd-H{4z50&*cAJbyuo^T$e$|@)$@wh{&G!-FntjVXpBWAB)6AQ zE(OP4v9qK_s_zuY@0%B_cPN*q^uUw&d2RJa`LEubaMzWExXqyX#!Z`^8?T){HGT8z zSD$vCVYmeRvN=52b=_X=@_OqX>z}i7^J#s>-X|L4Hhv$LUU8q5`c<;?CVhAL3GYuL z62Mgrka5UhoP$jO7y|a(us-xz^O-44ioc3>6I=ge?kYdA0-mQraWxa}?RS%BpWqm1;(VAzg ze^4>+Hx5-Qz{iQi*45RC-zL9D$UlIGdG6i}2hGu5yW7MgFM|=dehX=S$ z6Z$wKr-_3moC{6Vb9-6R^P3iX_uS)pDqnN~Jd^CPO1sYJ=3n#I@)|wE`kSQ}=-jH0 zjO6S{4Wi<7B+ZV+mht5Fo#xXf;O(nx67ZsbHH(|?e}}#Goyvc4I`gcSIvwg|+-u2o z*Nj6ON29gUzeC13d*S@~7=uffmKA~8heO?fy!tOje0}$Ik2??4*C%&a9Di{>LMVY) z2-3K*(phbu|GB^Ig52Y!erE;@`VF`og^?D7Nm~1Z<)a6GN5f5o*uc#SN6WhEfB1kL z5D6(MrOXb+Y`vs6Z&qHaMWJhlr|Aje(4GkJ@-F+Ampgl%+Fu5kCu02PPq!8P;b|li zK5Vt9K%pNR8Sw@#p(B3$_!i(IUwn7r=+FAyI>1K;)_*#bq9>nw;=V><+L;b3`2F&oRfiKFneoC! zaE@@={4q#n|LgUxI1ag91aR?K#kOr&y~0C{KWrF>@TYxexOqI~z(=3+=!mnScBej#8O&~R~mF<9=&u4`L|Q6IP88;Chm$yA>nrh$mG1D5jJx(hxBN5ow6r6!j>9yvl9Kvva1URDruP@zV&P~b_5gJvm#pV$ zwq`$Uq--ge#I$$sZP@KvxNu*U^#ed6pedY|GQ6WXgvBvANxf7%1j{IN>f2&+wDlU~ zkW7d7)BQ&MZF4gNssNOIDj2k^5F>W`OW>mj(AB%V-{uwLj{S-R4D(LX3~_EMr*Tamc@?m}v!@ z=Y;Th9eH+Bu<={Sj}23!2cs--WvS&wu{4`i?wG&Pb9bV8b6qg@!H?a)+wHfFkF%_N zy>gFROl2w+2em#8@1uB);B?t(t7w(T`U?g>@nHNt6i)QF#T>r{$ z#2@wx!!odOR&3fvR(A0nkb{w`$*(P8&kP5~dfgG@M;Qjm1>{zqId`rWc7vhs-+kbE z<3<1%UU;9_WkuoPvb5=S1n&?fP*k*_(e@g{6|{foSC1pA1mxDbN@^R2I2&CG)b<}h zuV72t0Rrp=(41+1|NbAS_b5C_$yyJ@WMz#Qx8QIKV((87q$aeAz9SL{!bGwl2doF< zTHjq)CQ=czEP%me@pn|#H+z2k5rCCB`eWiY-(!uvUW1MRMUporY4!y85%Ce=EtVMc zcA0BJ=I~^fk>k*db;YLWlS~AV2(gu~L~p=@h!gvDx-uU4sizXk211>vuO9&U$M~WX zCd7vZsl@Vbpo+LexdErba_6C+?N?G#(jj~PP)OfKc6Ixt%g(eDvA)-4>hE5Br8U8k z|M1biheoG*(>9z0i(4MbFhZK-vs4U!C+2LLk&T&q?zZR7o{c0MtZLwN&T2lATOl%r zAx!31uWj?4D|yCm)ndnzi!Y1CCxx=1saktR?xEnll^ZUWo*zGk{SWrM9~j_zBD=zi z8?JNaLB88#SpUr9I>@LgNxq8K%1Nzss~fAcZx^J&dvQK__%KcR^!vFFnrEK4(mkNH*wkMyC}K4W20H(Yb-g2Px-@iiQhia*`hA!@;B zd7*yw+NQgx;Jn22@`G3+#Tw#H0wKWH{kFcI5;q*NItsV#JZz+hilo@;t*{(4Gv7Cz z-^F=Yswy_eqa@rK6h$pcQdV$`{lik-{F$?BU5%FFIERMg9Zp9~-+wt@5f?Yoo3o^! zt;2mf$8K2+xgRUu7Z|r#pV-!(JNq}D_8lh8Ji<1DMj_UL7H+!mqqg-r&cJKuzqXJx`p5(vO(+)}SC1B1s!{xBEl zD>I-b04f5(fRNK~i_CoF)iD63C2`z;3h2rD%qwuK!_bzf7#kZu$xR3F{o_kaAQ0;# z;YWMc`))m}`$=VeB=^S;bId&0;;=T-NU1OJf15pN(`-BE?)Z{_Jm&fXX27H z!}BoH%QqL^QgQj<1t6{#!N!lV`5Js6bsWZ5?=H)&1uN5E>{TrvbafOLC$f%@`%~2< zR0R)f5$?pUC$uMn_kLbj`-u^j2Vz3SLm`nDq9r^behIr>q)!^e3idJtd#8cG4lqoG z=an2M8>=+gF%vSDs|#P`a~`9$D|{sq)r8=dIyCKb?`Q>yNMoq6h&TWwecCi-+{Qo;k|Hbp z>jO^&GU177lmOddwUSp-@)jymOwd5&%od0!QLq)zrZ8{w6-v2NR(_)KuT153!}TlD z$#q7SKaU$-bR0Z)C#1Hg;AG(z1;#o7vrj3~K1B?pavyA}-&Mjs&w5pxUG3%vYn)Mc7+f zPDi4xs5KT6>f{6bb}`Sr0^K!Z6h2#l#vs$y=DJs1mVSumiFN*YQW{Si04!o#BG7Fh z0yw28jYCsYxbP`ZH%+ATYulR-#@BV~AMLfI++i#Bdi}vYuBhxYVXDb6lX%r8Uwy%6 z*0mlt_3hr`Vp;6dN^JldTM7?z^t+*7`n_czwO6TOoMtDJ_X%&uqnJ^`R4KFdoFAW= zp#-kZQMrk!k63w~bj_UBMRJ!s8OP}QLEL`@(C2OfMSB4f^E=DVo&Q7t2=9ag(G^RV z;Jl9(+w<5PxL<-+y2izeheO@rt@43_mB#Cg!L6TX*}KN-Oxt#lb+o1LsAjd?wJZPj zexuKa1R?{K#p-|m8S(Ll)24som>;#*zMtj?Dl^=a8Ej(5va^m|HrI%rsOWMP=5B@f z-pAh`G3&q2M0azReE2ECCBLP4f#p!hP2*G{b_e(@5jXgP(6W<)RIUk;+B-Y1L0|c_ zaa8e#6|^i7C+=~+f5IggTHa;Q9$WW}M%%htTf8}>vTmLCa?s2pe)7&bq!Li8Uo9qo zarx`(j(O%bsa-o$@qkpDdfo~Q4-enBzpGc<`fo`pgVU9KRt}EG2s56OegfbQ5ibKR z*01lYL-`1}r4D5-89Tm`^)jc9u?7N0H^#Jl73(;m>aPB3DSkyF*c*O9Xs+A3EXA)u zum@QNcH%q{y8GZk*`R(s>z%%!@f(+A#ZyBoE$f+R(qaR3dzQO4qDy5S-N~u`DL$2Y zSUVmc*qQi^Q&{E>m9S&%X*lc9HwhzJ6!v?>{#*`Qn|Vaa=Ve-QzJ4qUh^sJC2_VfF z0SSG=E-0%avvUfu=YAjnBh*q>@f^J>E&X;jx3dJ4?Eq>QXbbf0G-znkzdzuFmJd7G zXtsC&*@x3WWgLNV&{1RE-VTr8yIY5s@O+8YP3+Bc?VrBwwjsCvZm#xq^787yrn-Heqs99j^#WwB5i~?~QJ? zOBxP+{Lwmk-*Y7;CCw{WGOcZF_-Scqh8$y?@x`wqD9w5&3F^uw%0XHZurN8KT3pOy znLxYXkzxcjsGPf_hSGbU!p)A?Vyk$k@Rkue?U~ zzawTXcf7$NfD>Qx^U@{(Z@oPc^CC6sK+K44@C}CdE_B zYv7zn1g~oDe^vu`?-R7uU`Puv;O!#ef%FzIe6uBXj5sRj&EZAA$X1=7uNk2|g>)Qf zq_#;CFOt!RK2)J-M_QIEo+cI)>elx5Eyy@kCH;gAf8;3ZxfoQ8%Ly91tBX@(6=?8Y z03D(Z9>J>VK}o3mE*!GzlKu*qjC_3D_0#m}3m_Jex2o~qSA8b_{^QbyTduA$7$X6| zBR7bl##lT`3@oC4b}_6+H1M%aUXcBJDkLt>J#6d&u2WPY$J*XggQ(B8#Z>e-zvJ7N?Lb; zTVE14M3MfnOQoDx_DHfqg^g%32bhR+8u;JeYeLba!1C7e;$sya*ezSD-QDLa+G$B! zVdmW+4OVESyX=#cbgBcHPz&R3G-(hE!cw8&0X}jN`m}`3DfClWBIzhFWVSJ;qi+9x zW7NZkdA)C)euW8y;8sL-S4yjx@bYviQ=XA{IOZ zL->Uoq)R8=3B!Ff7P}!UICc!FriV)n!1B?o{({gJp^20+|2>ra^F0c=ofP9%URu1& zBvQJL(|b$tCqE=|*yPXH+KT3OPIXAes5jLe^JsxM6^|<(1bVzsBB+=E?V;x;T(|f( zySlmnnZJeDlJDEUUm4>8jdH(5`5C(aFT`}?oDk-C@u)^u7Z)LTm(KtnzaY2HjDw?C z4JhFqg~q(}6MVCF=K8+*Bx9^0Kn~|A7$9)+_y+&;EAPketfu}!sy~&CsBfrJ6%*vI zUw?&(Q2m||8-mBTpe@5-9k5ICGKr1M(LsD^mfFgHikTFjoUHsUmi5eze}B(Yd3(0} z8XbJ(w~Df+MJ3g!*qTz)T!gXDW@?*1EC8$qx7ZeWpP6|=>EzF;Yh zM^}CBJi3ahpi)gnTAGoa-K7)&VO2tcXULfY5=gUIO{0`Q;vq@WA|dVqdOYm1@Wjgn z&P=SWg4Hq}P&mli51&83s$u%?%bMY|9{6Wv#fb!6h!8doIN)$Ly+P9zaGr`(Lt!x{ z@r5McupmuELY*bWcih6`M~KBB$KFBs*K@Sn)8hX9YKQgH>h4h;l7(>rub#~Ax&~JE zJYjqMK9#K9mc26|IP2zK$se)e0H}_UcJ<6l8m1CpoymMC#tY;sDZV}QZ^g{>6iK^} z%bn!*nwL^i^^ZzY>+|sNB^i%{tbt~d9wgG2ao+h85lufP(I2NE6ex2Z4=09DYaohw zO9(*m#E`6!_n%sZszBcuElC9W0VNhZ8Zj)fJuEDYWUPAT%<^|2G=~rF{8+#mc#sir z@)~9Eh-`XxcI9=cyTAil~?T4D)N&*s%)~A7|# z8eT8(Rb3C+*I?~Gugo;h$cX4BY(2C2=CTqhfZnN#uPfVik6`ZHoxX>R9L9@UvU zm|cla0?_Ia=}2B8@)nG0*Ny{^)`fuk(7gMq=L0quz@0vgerC-%-rxWJIOCsqWi3PG z4`k{62sAPMjjzxvt>~bPj3HynAHA8VCUZEfwBrAJ1;!tb<(NlO4t_quwq2}C^N_>^ zbUW|gtAJB3zpN8G_U!4?mK_$)9-6h0<9Yx8dOTHc}R?%dP8dQxoa@P9u3=1mHg XTb9ja4U@-6_|I8o^;0>D#$Nvi&yg2Y diff --git a/artwork/dateparser.xcf b/artwork/dateparser.xcf index f5e0a074f29be813ed96b2f35fa5947ff8ce9c10..504ebb46243d0c164d44d89cfab2cfddf933e0d4 100644 GIT binary patch delta 3080 zcmeH}Z)jUp6u{qYv$zGTV`iO*mA6buJD2n&#Vw39Wh+wzhg;{|=H`dDU*NtV=`j zn>U>MJNLYE@44r^dmov;?47;t?a+-(P99AT%SV-HwA}I3+CfQ@Izc=j3}me&wLf3p zx1)_6EMMq!d@{7|q-9!pIWQD_Cb&JgO-@-OhfOUY_eJHvA!QlAzRk*^En5Pz($nMX zKCFu{3nC_)hQuWn?4cDC#4i6l?D%=@zVLJ?792?U;`NCMNFi>kx|~%rT7O{2s4*OVmMLk#?mm+X@fz!?q`E-fypN7<_I=PN<#pRx5^A1FdEN%w(pdjjMMuAhG~%Y7ej(0QtLdl+$s9s}`;J%A!YK2ZNg4V#u~b1T%TIIvK-S>p3~pmla$%@%TM9=;;4hU|1+E2J$m z#a-HY2hHKWkAbYQ;3gRMzuhP`?uw0_?UJNB=hQDQk!)M?HeMw;qZVG_eqIosO%Vi3 zBo$u+y|HxsTze|F*h3vM*FbpNI5B^QC7eMVQP0kP*ASEmE35dCE}m=VenI0~#2G=+ z-PtglhVhg5eEdz~X<~^u&QC2ko&!bDCE|@@=PuHCig<;1m3WPKgZMs?Hd?LoW3*R4 zAyNX>nUCIV3wJ`k4S$1KT5^7N& zr-e7L=pxHl!+*C$|1V6f>)wS~RjfG;vWypSxBB1H_GAmeCT@?h&h`~^(!^w$DSrcX Cqt{#j delta 1345 zcmb8t&ubGw6bJB`G$v`aT9n2}QMY(Vi$9VOYDJ3`RJ0U-pog~hpy`@~U~43iR*1OO zDhk0Q(=A3&(`q~j_9BA4co3rTs5k!tJ&8Z)K}0al&if{{5D(7s_A@`;?y$4(^E1c0 zqN6z)8@r%g(j(fqKM)YjU9GzrV{RFC8C*uIj72eU(8lIP!5!2(^!R8zu{{wT32Afj0R2xrJdrF?UVwM|*8XM)v+LYx()4a{>wtLKBd&;m~ zS6S+2dm{NHL*+4Md!?p%<|sS`Bk-@CYR}3gyI-v{#|v`9JgL1Ww_PNCj2WuuYr%vD z@dDpIjE}=JWLJS4{7#NVNzp^z_mB^CvM@}}-XQ0SsGP4?Pf;-?|rMwxo z*XC8{TQlceWgd2YnCf#a^tpKP)?n>VxQ~?Pl6oi+($0ppWOy{J>#@>v>v{ZN=0M;2 zx^}DID{r#7WLP;?fi9~XZ+>Q)2Mud}sqyT7Su54rp*5bxiHTX2$OWA+7dSCdT6#h4 zS-E5GE9K`F;Scx=R;XyWXrKwfA!#EC;Z~~^Fu?w9kcoU{!7Md^*@8vJgaF1cM guu9!%`p0~|{Qu2uoU9lW?bS|wSA47FU*6^ZKYm{7`v3p{ From e22e62e336cc59b1ac38ea947c1b9b471d420846 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Mon, 2 Mar 2026 18:10:21 +0100 Subject: [PATCH 013/107] Fix word-number phrases parsing (e.g., 'two days later') (#1316) * Fix word-number phrases parsing (e.g., 'two days later') Close #1314 * Fix word-number phrases parsing (e.g., "two days later", "two days from now") (#1317) * Initial plan * Fix word-number phrases parsing for 'later' and 'from now' patterns Co-authored-by: serhii73 <24910277+serhii73@users.noreply.github.com> --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: serhii73 <24910277+serhii73@users.noreply.github.com> Co-authored-by: Serhii A * Update tests/test_date_parser.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Apply pre-commit * Fix approximate day counts in word number tests - Update 'four months later' from 120 to 122 days (June 15 to Oct 15, 2025) - Update 'six years later' from 2190 to 2191 days (accounts for leap year in 2028) - These values now match the actual calendar arithmetic performed by the parser --------- Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com> Co-authored-by: serhii73 <24910277+serhii73@users.noreply.github.com> Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- dateparser/data/date_translation_data/en.py | 4 +- .../date_translation_data/en.yaml | 4 +- tests/test_date_parser.py | 86 +++++++++++++++++++ 3 files changed, 90 insertions(+), 4 deletions(-) diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index 042a896c2..a91bacc04 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -813,13 +813,13 @@ "(\\d+[.,]?\\d*)h(\\d+[.,]?\\d*)": "\\1:\\2" }, { - "(?<=from\\s+)now": "in" + "from\\s+now": "in" }, { "less than 1 minute ago": "45 second ago" }, { - "(\\d+[.,]?\\d*) (decade|year|month|week|day|hour|minute|second)s? later": "in \\1 \\2" + "(\\d+[.,]?\\d*|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later": "in \\1 \\2" }, { "one": "1" diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index dab056b1d..ac07a0ef2 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -87,9 +87,9 @@ simplifications: - (?:12\s+)?noon: '12:00' - (?:12\s+)?midnight: '00:00' - (\d+[.,]?\d*)h(\d+[.,]?\d*): \1:\2 - - (?<=from\s+)now: in + - from\s+now: in - less than 1 minute ago: 45 second ago - - (\d+[.,]?\d*) (decade|year|month|week|day|hour|minute|second)s? later: in \1 \2 + - (\d+[.,]?\d*|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later: in \1 \2 - one: '1' - two: '2' - three: '3' diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index c461d1f4a..212e0220d 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1503,6 +1503,92 @@ def then_timezone_parsed_is(self, tzstr): self.assertTrue(tzstr in repr(self.result["date_obj"].tzinfo)) self.result["date_obj"] = self.result["date_obj"].replace(tzinfo=None) + @parameterized.expand( + [ + # Test word numbers with "later" + param("two days later", timedelta(days=2), "two days later"), + param("three weeks later", timedelta(weeks=3), "three weeks later"), + param("five hours later", timedelta(hours=5), "five hours later"), + param("ten minutes later", timedelta(minutes=10), "ten minutes later"), + param("seven seconds later", timedelta(seconds=7), "seven seconds later"), + param("twelve days later", timedelta(days=12), "twelve days later"), + # Test numeric values still work + param("2 days later", timedelta(days=2), "2 days later"), + param("5 hours later", timedelta(hours=5), "5 hours later"), + # Test other word numbers with "later" + param("one day later", timedelta(days=1), "one day later"), + param( + "four months later", timedelta(days=122), "four months later (approx)" + ), + param("six years later", timedelta(days=2191), "six years later (approx)"), + # Test pluralization with "later" + param("one days later", timedelta(days=1), "one days later (with plural)"), + param("two day later", timedelta(days=2), "two day later (without plural)"), + ] + ) + def test_word_numbers_with_later(self, date_string, expected_delta, description): + """Test that word numbers (one, two, three, etc.) work with 'later' pattern.""" + base_date = datetime(2025, 6, 15, 12, 0, 0) + expected = base_date + expected_delta + + result = parse( + date_string, + settings={ + "RELATIVE_BASE": base_date, + "RETURN_AS_TIMEZONE_AWARE": False, + }, + ) + + self.assertIsNotNone(result, f"Failed to parse: {description}") + if "approx" in description: + # For approximate cases, ensure the result is after the base date + # and not later than the expected upper bound. + self.assertGreater(result, base_date, f"{description}: should be in future") + self.assertLessEqual( + result, + expected, + f"{description}: Expected at most {expected}, got {result}", + ) + else: + self.assertEqual( + expected, + result, + f"{description}: Expected {expected}, got {result}", + ) + + @parameterized.expand( + [ + # Test word numbers with "from now" + param("two days from now", timedelta(days=2), "two days from now"), + param("five hours from now", timedelta(hours=5), "five hours from now"), + param( + "ten minutes from now", timedelta(minutes=10), "ten minutes from now" + ), + # Still works with digits + param("2 days from now", timedelta(days=2), "2 days from now"), + param("5 hours from now", timedelta(hours=5), "5 hours from now"), + ] + ) + def test_word_numbers_advanced(self, date_string, expected_delta, description): + """Test number parsing with word numbers (1-12) in 'from now' phrases.""" + base_date = datetime(2025, 6, 15, 12, 0, 0) + expected = base_date + expected_delta + + result = parse( + date_string, + settings={ + "RELATIVE_BASE": base_date, + "RETURN_AS_TIMEZONE_AWARE": False, + }, + ) + + self.assertIsNotNone(result, f"Failed to parse: {description}") + self.assertEqual( + expected, + result, + f"{description}: Expected {expected}, got {result}", + ) + if __name__ == "__main__": unittest.main() From 5add61cccf258788f9cca748dee3d5094ff65651 Mon Sep 17 00:00:00 2001 From: Laurie O Date: Thu, 19 Mar 2026 20:31:14 +1000 Subject: [PATCH 014/107] Use official publish GitHub action in CI (#1309) --- .github/workflows/publish.yml | 39 +++++++++++++++++++++++++++++------ 1 file changed, 33 insertions(+), 6 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index fd57bf955..9745ad994 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -5,7 +5,7 @@ on: types: [created] jobs: - deploy: + build: runs-on: ubuntu-latest steps: @@ -18,10 +18,37 @@ jobs: run: | python -m pip install --upgrade pip pip install build twine - - name: Build and publish - env: - TWINE_USERNAME: __token__ - TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} + - name: Build and check run: | python -m build . - twine upload dist/* + twine check dist/* + - name: Upload package + uses: actions/upload-artifact@v6 + with: + name: packages + path: dist/ + if-no-files-found: error + compression-level: 0 + + deploy: + runs-on: ubuntu-latest + + permissions: + contents: read + id-token: write + + environment: + name: pypi + url: https://pypi.org/p/dateparser + + steps: + - name: Download package + uses: actions/download-artifact@v7 + with: + name: packages + path: dist/ + - name: Publish package + uses: pypa/gh-action-pypi-publish@release/v1 + with: + print-hash: true + verbose: true From 341d3080f377c058b35ab39353940ba0f9349724 Mon Sep 17 00:00:00 2001 From: Adrian Chaves Date: Fri, 20 Mar 2026 10:45:33 +0100 Subject: [PATCH 015/107] Fix deployment --- .github/workflows/publish.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 9745ad994..2c5f4d872 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -31,6 +31,7 @@ jobs: compression-level: 0 deploy: + needs: build runs-on: ubuntu-latest permissions: From 62710c066b2cb44e508d07532df069b78d52bbf0 Mon Sep 17 00:00:00 2001 From: Adrian Date: Tue, 24 Mar 2026 10:07:59 +0100 Subject: [PATCH 016/107] Add a security policy (#1318) --- SECURITY.md | 13 +++++++++++++ pyproject.toml | 5 +++++ 2 files changed, 18 insertions(+) create mode 100644 SECURITY.md diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 000000000..5435d6213 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,13 @@ +# Security Policy + +## Supported Versions + +| Version | Supported | +| --------- | ------------------ | +| 1.3.x | :white_check_mark: | +| < 1.3.x | :x: | + +## Reporting a Vulnerability + +Please report the vulnerability using +https://github.com/scrapinghub/dateparser/security/advisories/new. diff --git a/pyproject.toml b/pyproject.toml index c1b06db6c..0e4da89c2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -12,6 +12,11 @@ search = "\\(unreleased\\)$" replace = "({now:%Y-%m-%d})" regex = true +[[tool.bumpversion.files]] +filename = "SECURITY.md" +parse = """(?P0|[1-9]\\d*)\\.(?P0|[1-9]\\d*)""" +serialize = ["{major}.{minor}"] + [tool.ruff] exclude = ["date_translation_data"] From 7a3113e3b495dc95e6e238da696433e259f11827 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 25 Mar 2026 09:23:29 +0100 Subject: [PATCH 017/107] Add the en-US locale (#1222) --- dateparser/data/date_translation_data/en.py | 3 ++ dateparser/data/languages_info.py | 1 + .../date_translation_data/en.json | 5 +- docs/supported_locales.rst | 2 +- tests/test_loading.py | 50 +++++++++++++++++++ 5 files changed, 59 insertions(+), 2 deletions(-) diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index a91bacc04..f348598f8 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -718,6 +718,9 @@ "en-UM": { "name": "en-UM" }, + "en-US": { + "name": "en-US" + }, "en-VC": { "name": "en-VC", "date_order": "DMY" diff --git a/dateparser/data/languages_info.py b/dateparser/data/languages_info.py index 9d0f3d475..fa72c2f5c 100644 --- a/dateparser/data/languages_info.py +++ b/dateparser/data/languages_info.py @@ -496,6 +496,7 @@ "en-TZ", "en-UG", "en-UM", + "en-US", "en-VC", "en-VG", "en-VI", diff --git a/dateparser_data/cldr_language_data/date_translation_data/en.json b/dateparser_data/cldr_language_data/date_translation_data/en.json index 3efae0a6a..685df4b1f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/en.json +++ b/dateparser_data/cldr_language_data/date_translation_data/en.json @@ -674,6 +674,9 @@ "en-UM": { "name": "en-UM" }, + "en-US": { + "name": "en-US" + }, "en-VC": { "name": "en-VC", "date_order": "DMY" @@ -706,4 +709,4 @@ "date_order": "DMY" } } -} \ No newline at end of file +} diff --git a/docs/supported_locales.rst b/docs/supported_locales.rst index c2523236b..9b48b5ed5 100644 --- a/docs/supported_locales.rst +++ b/docs/supported_locales.rst @@ -48,7 +48,7 @@ dz ebu ee 'ee-TG' el 'el-CY' -en 'en-001', 'en-150', 'en-AG', 'en-AI', 'en-AS', 'en-AT', 'en-AU', 'en-BB', 'en-BE', 'en-BI', 'en-BM', 'en-BS', 'en-BW', 'en-BZ', 'en-CA', 'en-CC', 'en-CH', 'en-CK', 'en-CM', 'en-CX', 'en-CY', 'en-DE', 'en-DG', 'en-DK', 'en-DM', 'en-ER', 'en-FI', 'en-FJ', 'en-FK', 'en-FM', 'en-GB', 'en-GD', 'en-GG', 'en-GH', 'en-GI', 'en-GM', 'en-GU', 'en-GY', 'en-HK', 'en-IE', 'en-IL', 'en-IM', 'en-IN', 'en-IO', 'en-JE', 'en-JM', 'en-KE', 'en-KI', 'en-KN', 'en-KY', 'en-LC', 'en-LR', 'en-LS', 'en-MG', 'en-MH', 'en-MO', 'en-MP', 'en-MS', 'en-MT', 'en-MU', 'en-MW', 'en-MY', 'en-NA', 'en-NF', 'en-NG', 'en-NL', 'en-NR', 'en-NU', 'en-NZ', 'en-PG', 'en-PH', 'en-PK', 'en-PN', 'en-PR', 'en-PW', 'en-RW', 'en-SB', 'en-SC', 'en-SD', 'en-SE', 'en-SG', 'en-SH', 'en-SI', 'en-SL', 'en-SS', 'en-SX', 'en-SZ', 'en-TC', 'en-TK', 'en-TO', 'en-TT', 'en-TV', 'en-TZ', 'en-UG', 'en-UM', 'en-VC', 'en-VG', 'en-VI', 'en-VU', 'en-WS', 'en-ZA', 'en-ZM', 'en-ZW' +en 'en-001', 'en-150', 'en-AG', 'en-AI', 'en-AS', 'en-AT', 'en-AU', 'en-BB', 'en-BE', 'en-BI', 'en-BM', 'en-BS', 'en-BW', 'en-BZ', 'en-CA', 'en-CC', 'en-CH', 'en-CK', 'en-CM', 'en-CX', 'en-CY', 'en-DE', 'en-DG', 'en-DK', 'en-DM', 'en-ER', 'en-FI', 'en-FJ', 'en-FK', 'en-FM', 'en-GB', 'en-GD', 'en-GG', 'en-GH', 'en-GI', 'en-GM', 'en-GU', 'en-GY', 'en-HK', 'en-IE', 'en-IL', 'en-IM', 'en-IN', 'en-IO', 'en-JE', 'en-JM', 'en-KE', 'en-KI', 'en-KN', 'en-KY', 'en-LC', 'en-LR', 'en-LS', 'en-MG', 'en-MH', 'en-MO', 'en-MP', 'en-MS', 'en-MT', 'en-MU', 'en-MW', 'en-MY', 'en-NA', 'en-NF', 'en-NG', 'en-NL', 'en-NR', 'en-NU', 'en-NZ', 'en-PG', 'en-PH', 'en-PK', 'en-PN', 'en-PR', 'en-PW', 'en-RW', 'en-SB', 'en-SC', 'en-SD', 'en-SE', 'en-SG', 'en-SH', 'en-SI', 'en-SL', 'en-SS', 'en-SX', 'en-SZ', 'en-TC', 'en-TK', 'en-TO', 'en-TT', 'en-TV', 'en-TZ', 'en-UG', 'en-UM', 'en-US', 'en-VC', 'en-VG', 'en-VI', 'en-VU', 'en-WS', 'en-ZA', 'en-ZM', 'en-ZW' eo es 'es-419', 'es-AR', 'es-BO', 'es-BR', 'es-BZ', 'es-CL', 'es-CO', 'es-CR', 'es-CU', 'es-DO', 'es-EA', 'es-EC', 'es-GQ', 'es-GT', 'es-HN', 'es-IC', 'es-MX', 'es-NI', 'es-PA', 'es-PE', 'es-PH', 'es-PR', 'es-PY', 'es-SV', 'es-US', 'es-UY', 'es-VE' et diff --git a/tests/test_loading.py b/tests/test_loading.py index b79db98f9..96e6adfcd 100644 --- a/tests/test_loading.py +++ b/tests/test_loading.py @@ -190,6 +190,56 @@ def setUpClass(cls): ], expected_locales=["shi-Latn", "teo-KE", "ewo", "vun"], ), + param( + given_languages=["en"], + given_locales=None, + given_region="US", + loaded_languages=[ + "en", + "es", + "fr", + "ar", + "asa", + "nl", + "so", + "sr-Latn", + "zgh", + "pt", + "zh-Hant", + "zh-Hans", + "ru", + "ckb", + "sq", + "shi-Latn", + "teo", + "ewo", + "vun", + ], + loaded_locales=[ + "en", + "es", + "fr", + "fr-BF", + "ar-SO", + "asa", + "nl-CW", + "so-KE", + "sr-Latn-XK", + "zgh", + "pt-MO", + "zh-Hant-MO", + "zh-Hans-MO", + "ru-UA", + "ckb-IR", + "sq-XK", + "shi-Latn", + "teo-KE", + "ewo", + "vun", + "en-US", + ], + expected_locales=["en-US"], + ), ] ) def test_loading( From d405657bbefd10ec8c1cb3df71ce295ca473f910 Mon Sep 17 00:00:00 2001 From: Adrian Date: Thu, 26 Mar 2026 10:26:36 +0100 Subject: [PATCH 018/107] 1.4.0 release notes and fixes (#1319) --- CONTRIBUTING.rst | 13 ------ HISTORY.rst | 30 ++++++++++++++ MANIFEST.in | 1 - dateparser/data/dateparser_tz_cache.pkl | Bin 134536 -> 0 bytes dateparser/languages/dictionary.py | 12 +++++- dateparser/languages/locale.py | 10 ++++- dateparser/timezone_parser.py | 51 ++---------------------- tests/test_languages.py | 33 +++++++++++++++ 8 files changed, 86 insertions(+), 64 deletions(-) delete mode 100644 dateparser/data/dateparser_tz_cache.pkl diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index d988e614d..0015e83ff 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -179,16 +179,3 @@ Whenever the content of the corresponding documentation table:: dateparser_scripts/update_supported_languages_and_locales.py - - -Updating the Timezone Cache ----------------------------------------------------- - -Whenever the content of -``dateparser/timezones.py`` is modified you need to rebuild the timezone cache. - -Run this command: -``BUILD_TZ_CACHE=1 python -c "import dateparser"`` - -which should update -``dateparser/data/dateparser_tz_cache.pkl`` diff --git a/HISTORY.rst b/HISTORY.rst index 992a5d960..361072705 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,6 +3,36 @@ History ======= +1.4.0 (unreleased) +------------------ + +Security fixes: + +- Remove import-time loading of timezone offset data from pickle to prevent + unsafe deserialization from packaged data +- Replace ``eval()`` use when parsing ``no_word_spacing`` with strict boolean + parsing to prevent code execution from locale metadata (#1056) + +New features: + +- Add support for expressions like "N {interval} from now" in English (#1271) +- Add support for the ``en-US`` locale (#1222) + +Fixes: + +- Honor ``REQUIRE_PARTS`` for ambiguous month-number inputs by retrying with a + year-biased ``DATE_ORDER`` (#1298) +- Fix parsing word-number relative phrases such as "two days later" (#1316) +- Allow md5hash to work in FIPS environments (#1267) + +Improvements: + +- Add Bosnian Cyrillic (ijekavica) date translations (#1293) +- Add a new browser-based demo to the project documentation (#1306) +- Update installation documentation to replace ``setup.py install`` guidance + (#1310) +- Add a project security policy (#1318) + 1.3.0 (2026-02-04) ------------------ diff --git a/MANIFEST.in b/MANIFEST.in index f51e2255e..ce4030d7c 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,7 +3,6 @@ include CONTRIBUTING.rst include HISTORY.rst include LICENSE include README.rst -include dateparser/data/dateparser_tz_cache.pkl include dateparser_data/settings.py include requirements.txt diff --git a/dateparser/data/dateparser_tz_cache.pkl b/dateparser/data/dateparser_tz_cache.pkl deleted file mode 100644 index 4eac858abab5c2c6e260d88cf2d6b222174ce603..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 134536 zcmeIbU5sT(avs)Q=icT1%yLINLyClU$ss+IdU?_7Tm3gZ0~^Dt>gukl+qb%=tGau- zJ@iu6jx=nL(Apls^y=DJ!y*L<4MPB%wk*Mb2-pB0^gzh4KnM^(0sBTj(1i71STIQV z!36Xm3NT;;gg}20k$EyAGftk9eZeQs^wd4)$rE?=VmuKex! zt^fMte}3s_UtW3f#YYzhA6?zO_TF;&@;}4#{6G5muYCMVFJHXI*Kd9+JpRC6`m4YA zouB`Ok6->O(){3+Z+;_Xd;8`3C*L~wvp@V}moH!5x%B4x^)Db!-uNSzFXN^3?`L1G zE?-$aT3xITR##WMt81(GR?F4$)0eBA)#XoLK79G&bARf z`t!f|@yi!qpv$*E{)JEfBIus{3I1FE_HV2%{Y|9*YrpdHlgj}7N%zTDK6(9F=d-cq5kH})g>uT z6%vU4Xi4Wi9Ys;NTY{DLQeTgJvw2pnQ+ZDXK^ z^XUbF>xo%`b0|rv1_aKhkpwQWuMjwogGt~L9}9s~G=sn`-+k{ok4Li}j>CO{nPu+z`?woPL!Ivrq3<`NM?x+LfAS}W266MNl*)je zUBNgYfh^kERv?SfCYbg9^+}`6<-181uh&MKV6mqhT-?Ms5l2;_MjYMRyb57#Wf76; zC35+0teadSDaO=?>H>*qOVc5eB9w`q5lWAklugJ?t9&BU%cbIDE|)GVqg-l+7ILZT zF3F|L6HB>_x=xd)ktfIxD?1@Spzi+Y_mW)xw^1&s)L$)RP6Y19e{4wLcCNl_YL|Mm zcYnp1tqsz2jZY3lM_DRr$AUzWuN%RMW(%h2&Jy-j zZJ2`YNL65UN5S-IncR0jIciavtYI=i8 zx+C$i&>bEtlkP|iEyf+HbWwM_GoU*td_Z?l)G%w`8P*-I|Er`sez~eU-Wk^&?-&TA zJKphh#~{r@ccc>6bVpHm)*Y$PMO6<1D0N3Dbyati#a^!7@pQ)^-BNeFGg)`MGg)`E zVG6nconuM-SJLr;f3x%jA>m)cf2z+?il2F&>cNJt2-QGq&p&+=?yCB zj>N}8cX+H!x+5{P&>gCDQFq)L&>a*$pgSmPn6ms(;RCvZqJ~*}b5M7jEWdR5Qqms(VON{A+#J^)Hw_5V z9ycBBQKMSuk5uZK{wNs0`Xd!QukIRzQiFt&S2ajk^yTWNqd{tvOC54^vJSa9S%w^|~HRdNhax=E}LXRNEv@@eeZVu>?8sCE^=_y)G;*cXv5(%|5t)xp5 zHw#_jF*NCt#MWGw*b+u22}KPv_y)9zzchVv`>R@;{9jR-RN= zQqf9DA^izuP5KMKEd2>+QAJw=EhY8FL4vd9~j!i;f28$!&$Qt4${EcPMQ#vS!(es@Ep5B64k#v0iDDcIGQ> z63La?q$HU3JZ=p2`xU-NZ4xPF+N2~W+N8a7TAM^-jy5R?T5aO5%-S{`waN8?exJez z`hAKrf@}s>*N6N4qqnp+`Dam^JpUcsC7m;ninMJZ{Rw4F`U}7;{RwEH@CP7F2U<$% z^~wGI^~wGIbx(f`U?=tkNli?%l3K7SNNPKyh**-;>#-#jl8TsGLmKG!DX0Kzy*||MR|q9ZP24Ob)njOq)Wp`J-#3Jlr275-_2GV>qG}8t?Dx<9f|k^un%DaM z>*M|YbpwL>{p()8U!m$qepHZk$3T0QDOziiS zHW}&nTT%7eBvwSOO)}OiZPLzsrA;EaQk#?nQ@;;g;+oiwPfqtK&j3AqSpWJ2!6!wST)Y|0lM{V-_f52Vp_XkqB z{eD7Oll}rQOMe1d^!o!4rUNY{_1ffq|Jvk!|C*;i2C%DsKQYZpYQd%;sqKui{ryn=_pqKms zf z+N30?8+&_GkJ=9jV9#2jr>613W6N(rMjA=e}Frp>LSeQzbUlJ>ln z5`%}ml}^5MptZ?g`&?}n5&Z0G+Qf0Q^R!8YYN1V1scYJ#U;t~ARPbUPQGrlulL;P% z%d+UpmFLh`V|l4fCc7Cfr@9%oqYBz2RfN?h1?z)0c{S!IZPNPy7TUyd1JsRuK-MZX z9<)hM(P|Ti9BGs2+1S#wk~T@)EVPNo(40 zV!?A=jY|GyRgZ*DqNYde*ppTxmRgTI|9?OLKK#!Op+a?}BGyz#QCe0Vsg!;F`czA8 z5z1Fxb8rf{GTw+ju~I=yc8jDT#w52$h>sow`9OkBNF260q2OuI36r^+)Ijfv{=7fX6UDc=(A z&OIc`pWH3DY{lFo(tQ5G4^##Si*dnTkmn!E;l|GnR&I++QnlDfm-|{2)D9@EZUH1&}yz6+pr3pa7b= zofJVo>@F06GxFBWIa37n+6@Y!CuS9bLy5%H8ROR~Gbx6|zCtm0988KK@v&D7dAVZG zA5Yz~>jaBsTK3VjSwT>gX|Jfg#8G$E5#@dBYe_*YK3^LFj4wDY@>RFRDqC=@5iAr$ zDr-$a6vbu*k&0^-#9(nt1u?$Ni0Uv57X^_m=+%l`DhTXXOj=B$PB0Z>p7iSt%L z6ub@!qM6%CK@6=cqJZ`0>?w%B+6@Y#CuS9dLx~i`H5xGMsQ?S>AdRFT68p4}!fRUO z*R&aMFe!+{N2?$d&8Q&Aw!j-f44NY>mc!-7*cjy{aI_EfE&^cKjl@ zM1Zsm5-b!%Dr-$a6vbu*k&0^-#31!jL5$lUfaj*NML}dc{k0;O3Ic{q6BWcX(*v%0 zJ$2wlKFEcjAQI=Tf+%<$6ht$(lY+QDIF&$*;jZcL9D{=zql1FziCG2VP!f^x6vQC! zl7dL=D-?vs!K5G(AFYB=G?Rkx&PgII5ch>OZ5}~*22*JSL9~mlVes_!Zc-3`_6uPI z@%$%nN5%z1320B#5$K4mF3{QjbuZ8Y&kFRb!*hji(%DGha_XHc-UGhyxrm8hz3@dY z<-(WoMG45a>zDO(+zM)bzl}QUrwcKr@6hrV%$GqksHY`a{mAb^B}=O zm{VD6!dw)ag*g@13iBZKvUeW$3INYd{~^6|W`AERa;YHTUNo_Hp5_q1RbTYZgIov- zB5~d-h=SKaK{RtaDTo_`y)$AAcTMl?xB=7{9TY@Q%qj?nl8B7gI}h?MDTu_rLP2;O zObR0L(e}=YW>OG-@9euVaqsN8F(s8tv_0i?^nOwh|2is&=YO1fXEy<95J#Y+;;ajF zrmuT}_Vl$&eG)uZ_$KzwO87>4=TaNEh>2gl@I@}=!k6(y3EyPS5FI6aky6n+J1%y* zsZ4GtL@x?oB$f%^P^p^Aq=hfiafGj=Wrc5~Tv7PQb=T{ieQ#eDKF`}Xan$wpg+e>K zn}qMt7i)`a<6irV+;x4Cd+pZ<7Q&p$S`+4?*euMcxVCp5EN1&tzBzUgyP3)bO@Qw7&rSQ3kRqvd*lnYQ00QN43dEEB$xk_cZ@nY8f5LOH@$(z3!gQm!O?H*Wg9 z^NrAJXxgE7zF|8HGua^FyRo{Nz9tCED;rqA06c?`E#a%7Ifbd0Zb>Yik_QEId ztS)?Yc&_l>xH;hyGN$Ld0YM!2gpA+wxrmMMMK0ySm+?gj-(=2Y!WSu(!dKGL!Z*30 zXyJ>*GT|#JiSRX*Nef@3qXmE$u5P|p(z3!gQm!a`bV8OVeEy+YEPURfT8X3Xp;{Ov z{oF+ozF&>PM?5VSuEvkUTjb}$E%M{=Y6Od+aVl#~n2TbwFsI^LVIC}QIW!(W2yd}0 z3tSw8S1WRVE8!a%8kfT7 zA|`(I!WX%e3tz?;C47@PLv)nzMM|acm9(_*O>QVeFA85ImI+@;NrbPdOj`IN9Y^>| zT2}Z*$`yr=&c5|}XaBfd?w!5kauY}0<8q;FzVja>;rqoXe8khDcOF0JdXb;_yvPr_ zt`RJRIhD00%tf(Tm{W0W?>t!CvUeUo;(DV@$}1a`2Lr07l!X{0vcjC z0v)l{1v-P-3$(Y~;!=M;1)eK>6BpN%@Qp04mBQyDCVut87rB%RU&a?De3Lmtbd>N# zN~Q3Xw6yR|ZYV@A3ST6a313M`gs-VgTKFOzNBBxwR`^EB6@`z!cjxua6h0t)!=K2b z($XgnJ%#pn{_`Y!|1=68@w6DehcCrd{IwVPhvF9b_wk_J1_>6zoXT1g=Azgv%&EAx zcOIl(_Riy9##XYEHBYQ=ilv*>}!9)mN*7pdb?Gt%4|c9TY?} zx08Z+H@4?OK_F(hFL6GIS1VUg5Ir%gARI~}G9oY&TToIEiG78F@Hm(hMB=0EomB%$ z3c_DpOJ9!Fw0Zbmd@dHXmsBp%_SP2u?k^_=as3Bl@BHuLF7(cB0@5IkK*x2DxA;Pmxvje^C(HFybf=WMlW-U zeYwoJ9E>tIsof`;b2~f`@Z_C3JdUby)bH?q<5!c+{c$gI^RM(B-k(x}LHU^0Cu#Yp z_DP<6xJ4pBy?jI_=knocZ>d*Le-F}8@)0SO@=?-?eG*ahboU^=C?AnnCLbjwk&mV_ zY59nB9Qi0|S@{?#SCkJrPr#Wm?)pa%uzYw&5G0Nc9YOG$e=o_$V@L%bQTY7ll6<^c z0>4k1aP-D*dGy9^e&inJ1}-XJ<|ZG#u{-tXjV3@r=2FF3ne%FmT4$;++b0bcJjon7 z1R1szGKZL94N6i+Uhj6yGDt7TTu;o(oI^=U<@HH}G?L6E_7yVcaWKhT;^SbslFa#i z((Z7dL{T-4`hC)G{d$tQf6~j`_mj;1DJ2+`kBNPfl8=!-sXUs-Et2Y!5|eZJC^;PE z!_(h`bd-EV^NaErC}!`=r5wCzrC}!`=r5wCzwCZSQbIGL-IE-gAD!q*_SJ9M((W+R(Dnxydbpm z>C1;NgUqQ#SORxG0PcJ%aOW4};LaUzYB%;pw|AhheN{0|L)*X6!Z&(n4HAE!tP35*D zoKm|_R$l!oTR1enJDP<`G7zpf*eV&wJ;uO0CHth7%}1pO;aW98jc~mc!u14%YezgT z-cA+V?P=~Q@i5G56^}aaARbUDo_LtAL4t9I8k}Mr!ndeebxZI>}a4u5xzx*BKH{2 zj>-yUSzZ6p?-4Bpbb`;00#*b3L--c>kb8`Ot0Def`UB0s)d2qx zz74){{;h`ir|WmVx4O^(Rc}TS3Snz+M%l+%cu|6cglI3@84xPTRayn%3SX;MLGCH= z%5k1P9cR9Ge?7oHics)c*+<#O@ZDdnUG`}=s2LFY>_fQ1*UCQRo&v9ApRHTNJyo}s zd9C0k@XqI)uG?-;GfwpwhHtGsMxAZwF)%!_;{eEmJ}z;-ce*#w|=F$ z3WQ!)t5@h}Kv?@^4i%RQ}(L+&xgJt+t9s8#KR0&oLTi|{RK6}iX3dEKn`U+wmu zs1~Pc^@)boTB}d0$WW_KrU~q`2YU3R1ePKc>sketvXAlZ+3Eoeqx1@G{H7z8@18x- zb!w2AN^M6rUaN$xs8903I00IKm79v;cWld*TWR9@U^lJxyRrgqpv8z>E)Ad zU-z-9$(bIuwaL}{SJbPwLh<<@NIdKI{V6tr6~|g(jZCrk%PDpt2@muPM`;g)D`2fv ziQHpV`GBT5MLV-%YDOg*+*Ya$Zyg6$^rq6^zx;7MQ1AA&AgIP>tcY$1{tvW z&7DN-56rG9e2c0bon7yvVh6ZqcRag&-S!msOw()SUcKdkdy{6@-M;Qs6*j}WR&4c# z2W;S*ty##ca(H>s?d#=@@e$Jp_&k?CU>ZzwW_$ou_kxu$m;7qnC3LI zgL`_Aq$(8QTks6IYr;SkdavY}*Rgg7_k70P)A(8$cdrVM(Ydl}N5AufBV$yT=J_0< z_}4hk=j>w)JVMXv3G7GzEY&X|)D>(Hni_6LI9|nsu$V?bFzzScGf3@#r5J@P4z}vM zQA@D{Y=0H(lNNYorZqBnXeP0mhlo%Zn|U}ojU|xI(mHskjR3(zJ&9FPjBtgonTPdh zEJ-oJ%LXa{XO;jCj&%!E;1IqAIOHCakmIuTaRslnDcc-{&;V8SQiMX-TD_Eg4C2b$ zgcXo~_&Z6CI}Ey#Q-JC|%<6Tk7OXE`qjpz$_aVrPrQ*ST%{^7U2v^K&ZF|T)#=H9i z)q9dz036)+d3RsqYvtYjDm?J+zRSCld?c#JQ>tFgaH_l(wS#)+8b*z_`rYHnr~r4?I! z5e3)=EIM*g_|WIuhuiS&!!f>nnDY&TCS%@w@X0`fL--aA4!Oq~+$Uv&%ZHnHjHg|a z1`2<5aFn|a?hfV?7zo*QF@Q7c*mw4{BxrC(6dFa9-Z~Br;!uDy)q3ZS)^7?N!nfcY za*u(#LrSgyr)Lq}9p9A*!3tWVm?Cox8D?OfE0JEJ=!{QY(jExj0@lb7>CVs)>Azo@ zso|YR=UPtF+<_w$zQ(x&XRk5t3OM%&lIl&btvEc=09A`axWd;e4#+(PUfJR_xcTAU z0Q)#X!E0n6XRqTUD-MT!(tp`LVushLP9pJ;!WGCy9#ZZp7&9I^gC=7NlO)7i!ZZr* zh#`zv!4!igv#WFHZ%-gtF|8F=y^jE_Vtc}`(t$mS!>#rxDEC;E4(?H8vsSYWpeog@ zinVgD4o`LfY^4hK?7VAsXuv6f*lLf0-a5uTe~&^pJAfOI)~&Vy=&j@6Jaw$Wb%*{o z0D`xWiIHu9L)2?IzcKqdhXdOH6s~}^YPivDfWvYdpf_pm4*ivX1S?3b5-_szPk=IB zi3Hdw&FpYs)tbT;x>kmbu38@suUcnLS7xV9>5pxOO?YQb2GGv@m8JEY|1wRcyF-6v z1i^}Pt@S#xGIBVyGGaAbXLN_+nh}FmY<0~6uK6n?*%=}`T6O%H{s0l9Irgr%oF0NV zj#THxuZ$jT(jEG&r)?F_|>r?bCqj%U3IH_f!W==df7Mi zpA@cuHEIvaT|;&SbFI7OHoEAyvmenDo7vqHzZ0eKEf6C27{U{GPNR<{>+YVY;kc^R z6Ai6VNb$}ZGBEBW?-;Q1pj~ihca0N-s@1K|M4-3UkWsBV4iKSM|AMa74s&g97YV_t zPFoo_vWrCM+#WR-RV@;#QjJ8kVyg>;NP{=t{X2V_Z?n6n1JZzS#kp2_MeebhJuRid z8;^8%ecN;dD}1fot6N8cdjsy@)=FY_7pCN?*(td|xI)*;J>(wao^POTjvcuB&@7Oo z6&#LG@EVsOIQtmBhrEW9P4M%jV7$p^AHo&BR`wzH6nG^#?T|LRx2HE(Q{7VdtAnH5 zb#V8ve1jcUyP(OEvDW)Zz^B!U#%J_OBlGC3q(Bnhwv@8)c3eXBYxz1=;3e1~AgyhgQ$%r#_Sn>U@du>6(u zd)us}Bl8HXVkO-h1I+HhD#g>r6t0-oDiO$CgLegN^N$<&%~_fn&h8x#s1t;50S>vx zz#W(BBpcs#_l_0g(g+2?3R-JpJFX%F*N)xMlhGm_zK@rxR3S4ut`%8b#Q|A1*G~&K zW-&>@F%7I0PQ85rPBDo_{aLAe>T~JoHud*(tp1+5^_SZL9qsLTHHhF>Z(GP*YxR)F zz15yK`ps6NkM<6HYzNz5I~c`w;9<+QW~>2j>YXTDp=;D;l)DD+3iHml9<`Erw0G$9 z?ogp?6a~Dq29B{Edc4bKTt|CnKDM)Mu$_%!J9DtDU;kIB8|aSq9{R{0ZiDRMD6)qh zGBcjE=G3~q8Rgd8-s;*-+FP-?Amd$ajS0@VIu60xaIPv0+}_+7{)gYxBS~O;>euSi zZLmEZt<|Sqt!fkC&MfAq4$H3Pw@PVUg@9|&A09Go_dCOwNmZz7Z(FS?(OYY5qxR;k zDWOBv#|U*t{&Et6x2VvOH5 zdb)CZQFG?<(F0>8ot9ELLg}~0rBu#d;~jNZ4`7R243M&(VTL#Py(z*KzShwja!-Mm zt+oN2whisfx{Mlxn1N-hpw|0&@U56NJA=w&-;fKzifN6=kh#V)EPE7&Tp7b=#{)K8 z6s~|Z)+XhyA-e)-jtv*UnZ<@<|JW=9D`>4et0QAz<=DvVJRh4@md2A5u7I`jY;^VS zSelw$ZwAk_IcRt64~`J5ptbUBWN>us4vv1|&#Bp{IVvj&radXE71oHC5ucJ}2S*vV zX2%b86H`@*aK*3IszmOw=KqkUE=5)9??23sae$CgwW%-Q2nDaPFW~Is_{JwMV4t47 zX!e=uOEdfG^B2+{4`~Whuuo5608VpHgWF0>M-P4?a9%HZdpF6$?ARD>D{u%`HQUNL zXiPmnZLJ_Q>HC8Ax*O0-)r&yCgg&HTB6Tgo_@D{K} z`lu7Pk9zGVQdM@wTuX7wRAei+>h%b2dCgx};_PJLplJ$M{AyGcl)F}sR{+ibo|sXx zD|0k_(qk0<>fk7M9o!1C=^dPCR%Fcge^Q0o&;K-5=*ZW9&@Fk*-&E+z?CmL@ZDlA< zZyn>Ab6!j~BI;J!mO}B&m{PRztZqpGo)re;8Lav0_?hm_(^!ZjR7-0d3vu=_wjJa2 zX0J!r1MeB$qy}rMRuQi7HHs;{bqc(4EMz6Y*SM=~G%hmNkfBzy&23&X{oW5JjXPTn zoQ^=@Tkvf3bcEHwfiU`v$@%J`aamJMjv^Gi)+R^UYn;0R);)xN^O~Ghz7O?Im1=Sb zSNK|+9CA;AS2j7b6l3NtN|6}WwJMT2T8#$q{=oK?`sov#SJqPXyrzIB7jO7ILCT*o@${Vynv?uz9`F|E#_zJYUl*c);7TI;@oRzyc17WUPUJbiKm zA@uu8j@SxeoqZ8urnvgmsu=(%rH~XBg)3Z*{Uqg{!Z@!hIDskZz2@2- zo$FEU`m;ULT>{|%56yh9nTPcWpHyvOI*+EOyGyXoNUdg{Jr}Q;eWM5C5&N8@@qo}Q z{sG|t`?fK)rnina!NPL`;C|`n)#Pf8MU>QOYWXkVLSelWcnlZ~-51b56 z;oHb>-R)KI6(@s(d1es49@rP9@GZcN?u)LWlZ$br^xW1sWwthYSyk^=A3UPBj)6;}O=pMV9k(E^t3@Xa2d(i&SGB)lFyNO&z9eMJk? z9e%g=or4g(MGG5o4kBO~&&s~4Tl?#$2;KtO$V6|A`pl4_?d$pHY(21kO5qAvt1=s1 zKV1*3pXzOnZtWi|i(mzjIV@ zI0BX$bn8morg_!JWL$|^s}~)n4RU8|}#gP%um@{n_b&l@5g~bnFj08*z9y*3QXY&SS!y)r@*JfQ{Yej9kZx=>d!I}tnjrmZe*58=rW}t z({t;nH#;>a?T7M4zqDo%)ATAb1N{BZpF);*g*c)^Gi~=9WJ_Io)P@ zg3Ps+hKA-%PrmoxC0O&*A!injP#kMqz~$^Ua3lsp&MewUVTL!UafgzDt(;lttyAEY zV6$C5RwaUQAOa(q?PGkEQXQ@`ZQ@yO5x_AU{0js{KjOr}5`5>BB2DCO) zu#7Tm9AoMg^QZ-uR8A)aDP?#vvo^HFAWi z*v77kv)60(0a#Z!Ww5QJ>8kK1x2vLXg|Cr)lzR%ivTk)(HGeQ;j2wurP1MX~Kszu?i4vuoy!JQ3Gwd}0^OzXVVw<1`f zYwTN*xdsm75Pza&PPv(#4NPJvTw!ahR?1xicLnI2NsRRUnN`%8Ka)YQ!q>{Xk(msk z^E%lRyN5gn2(46-*5e3;uTg9{`#1wH{CS|#%c$QAS8OR<;cKqniwX66;fSqSxH;3t zGfFJX48OH%>l1u5JkM7`yI0N52EJrU;al(wxyP#1|B|U0qMQxbz*6`&;Kl{kw}CZV zR%iaEErJ!a)(Rcjv^{e-ZO!WCnX#o$BPR-1z*>a>xyLHh_W{;je~0;^w-1A01+A55 zBc{1$u4%6AQjKk{;+ZwhZRHtqkMWERbc>4${`2XMkEg_qoJgvfbbRV&FqAnnd(&F5WWRCf^n`@QOQLni(&u7k8y8hnt**1I6$Xt_AG__*y zS+HfZzz_Tm0l}|cugF}*_5mpmNAsTi;SXr#G5_GHS(!_-K#oxO8fSr=y@v40>I1OP z_pLT-UwD%mWTv)9;R;`4+oRl5;AILJovIlCKlCT~2v*PSiE0c)hiJuF)sVExvYQcpE|_`sjgQ@8@wSe2B!#;_~k7%T(*zSNH0=I2;VRIM$E z14k%~jpD%B>mbjuROnB+^t!_gZ&Co0I8eC4*T_T4Jq2DV4rZ`)KJc{=3f~4?z3E*+ zm%mpImNKCL=XBL-&YAH@Gw1395&>7t8~{#R|99v6s#eob3BihQjfw=BYjp~)?dN?2 zVCf3&&VBPF1aARr#60QTHBZv|ZFX+HX|1Z#e$=|PDv`U!Fse$&Yf}3B-~Wp4SG#k6 z)f~ZFFm7bkoX~lFzHz6XogaSxMOw5`yhFIcc5tKRONib1;ftLb@4&jl^=p^yhy<<8 z_)VPqy(xkfuvQ@$=}mzvXIchpetvjgvrKgg6rrHqx!J-q)WrQd)2P86uI__x#T?Zt z4}UHCe4DjsWFDzcZ!KCcUCz&s%m$6(8%1co-D=^Rytf99_;v)&d0JNw-)2Cl)UJ{R zge!cldIY(rz$-gbvx<3cj!IMD>{)58;E;O^9G{nFo17>)bIibt?p%Aos!q!|z_!Y3 z-TxJJ3g_2CjeNLH!_4m7AN?X&)oClNI@bVeV7~RypVR%q?A**4RHfP}Lu;ju%o#`^ zc-mkqwdn1A>#p-{th$yT&-G(hJwRKzqu}&mRxzV2V)iS|>D=eGK2@NjmuPfDT5u!q>_^DOb>A?7Isk|MxeNUg<7;M+XEeXpLPhGS}D!V4kCcuF&q{$o<9+g13Nm zRR6}#1$0UFjU7mWUZ3tR{Ew+4cneq~A5*_@Kc;TErI!iQcnQm(TfnL>5~31|Q`1EA z>hV%{;m;Znyalq6S;K`pYcTdd7g{0}!;C<-w)(m}f?>t10nJO-|)^be+u7%XQQY8Utp5u@k|dX zy9XB&izTRDS7ur)xwXCW8b*rz|JEDE!nUb z|E)$FmJ#e;Q-==)(QNAc7T>8dVxH*LXypWcCY#J)HTY zr^e1$i6uoSNUiOPve!V7SU$ywu@FmH(aOBU?P1hu4v?Ki-P*WDjcVM3s0E=l1ntaW z)Jg5yv#49^b;PKK&}ChfV6!{*vq#2mMR5<|s)}2=humW|?Axs9*>U$so2)3t8H<%x z#?=j0(Da_=jLXN8j|aB?C|vWbZR_vx*w!DG0llq1vxQ|A0TajU8ek*GMwS54zZYA7 z($wrXXXlTHx_ORJjBC^u7b2?K>Ie2v0Dxu?J@yLs)BGJpJF z;3!v)Q1DvWNADfO_W%qm)G_2j56Nc$;D1{Z;1suj-2#>NwOV?*~- zvnS?D0jho34+XTguhH)WJn_B~AeuIt2tM%*%n-Z<<3s8ID?B?G=hvF9>!|w4PNwGitU~KI>W*z`QM(-+UwOht8fDV_wBGYt7rrGvprQ z8C&!gJkwh+05_oj5xzx*BKJ5rZxEz6VmkBnQdOY_T5E;Yk)c8XtB_6I&UUn)U0OLc zZg!0;rz2i=I6c*0IsMSzJVvmpyG8~fbFJ!DAG({zdRjMsI^+h!5ei!46os?bz+J)W z-;f)OUR0RjP44W3!WF(onWWrP;FSYLGn#$6r~ONl!l3YNz}0*HG4SV9H!*<`M>|?<9FXa!5w|~4c)&=@L~p}ssyTKB3u=qRcw%Z3jVTX zs@=Bd-|5kRH=$PvUZ4U7R!%rV;cu>h(XD-|0B7X{{56Yp05ZVeZ5B=Ft>gSHzPki) zdW*k%sg-y_ma$aPxV+q zAv1%8R-TQF7M@}ZlZ{{mnc>-Yzx!Qp-h*Hz2#v^)xz^5B-=%+gY}L=LFRKsnynf}Q zC!3GHz4_KR^k;b9-<|H{^X1F+Z}2?(Wp5vP_H1B(i^3IC8eQ9-jqPteEB3b{TR#5e zb5}n62S0l05_Ypcy1IMqz2$P_-(GqDJw$BotuMYo2{+mEd+#ro-~8!K_71#_LU2Jo z8@HQC<+t|LyBVq7L`r8AQoB7V6}L>J@>@%4nUPv1QaYoMTK1$;-16P`t_KFnt$BYn z66xQ+E-W-}!TUbCx_lQGW}%6ra#;%5W07F_u1!HyL&f11uj9&JzRN}AOQhPz-7a2w z+rG0*u*^~{ZzrmpTBzO@s&o;mD(;N}QdnP8cvSiX~}a%!Raj!>nGP*ria3aYm( z)iS{{OR>C_sB&tddP}I%MX0K{n+4UImTH+`nWb3XOjJ3wP`xQs=^|8B+>O+9`PMY7 zYUJ`pYPve1G~FA0)75cB5pUQc-Y60*vlK)%HeF6FMZ6(Jq>B_$#a&NDtgixg4CT}wseTT{ep{#}y^W`UUP!41{Htf~dwKrru{sT?W)%-*X@tLZtYt+09GyE~0?7%u*~ig%!d@nIIF>MG{lG?WwYuBBZCPQ9JRN+?B){fUVy zdc=k85Eo^Ftjk=aE|YHiB663BkiLjIE`hsAx26_3M2c8O60ul|I-wNtCN9!Yb=-S5 zZU&a!q}z;GC6b8UxJjdPDp^X1I|{)i66@oNam~UGYZhgKY~Zs<10TBW`N;zxg!KH> zafzR|3Vw2k@Ux60Vv(OZq44uo&rcOs3>X)7ytpV6WFyK&8d1`1Uql{JBBU>(iYo@k z3p+MmlnJuY^CFF&>9(iJqi2NlRCQdc_1i_;;SgbL8A-%q+tCT7?cDC$j*8=XglV02 z(y=HLWYdyGnwHRQUqqgkAfzv%j!SKa=UEm&Es}`Ew$o41Kt2`!h1}X#XJZT`>1#;8LkiT7AnZ${ z+C=E!ZAP`1DwBt$YWG@{Djk;w54-uTeRVc`LF&FhI-?Y*ADrlyrcQh}zqO>YVFXh5 zq;y6h)ejQnrF#c=E;f7kMj?La4+dWJOV8M;!Oxn0@COqq{80E^{2kHL5k0Nw4*L@L z!FK}a7eDuLOfvoAhwtd-6xMe1OF#HK!`}y-;{(cpg?0Sk@0{OyenhwUV>}G!37(!k zpf^2(O)CA;58qvE_89_xaf`3h;|G6-poO1D_&r8qxJ+;ML3;lI=Jo?^6g} z0cHOY9u5fO0f9Uq7zcRM!5$DCfJq0$7-HK2@#FwTU-+R!hxmgr4Sw))AN z&K)GWgLqb%12>0+m5Ou-`cx{4 z1l7B^-o1|dxAfzbU0&gIP{brz_Yu=+`A8nI({!U_x4b*dpOo_b8jE7zelgU zhj-lr+Iz%-d&iXE7=M(80-j!Mj`sHOcYr^jIodnK-x>ZM;twf~P?n>;ryGI_CmQ;} z-~Gp%BfR416j@J^^%S{Ik?Rz>0PN@#8R%Pc^ot+d9D^Un#E)b8;}E=nn#%D*3c)@O z|I!cL5i_akPKf6xR5>R|hI5iO#FGcG!4{Ll@q5Ip))JAUv7s`Qy~{NN7_0$-oT-wJxEIB>&X=%ZiU;@$W*+=f~aN{o+-ZSWbd z4Sh!oKa`f3$lpn#U)(YW>3cmJ`hpF9@J9sj%@6vMJKTaWebNFy6okUj_Ym-dKjJ4H zvX39Wqj0(b06J-WLnnIU2Y(cU|AFX?Y6|E5Zg8&dhR?30--`{-RodXx)D4|6y5U1S z>6dO1NC!%8aLD2Y$02U$NJ9MJ51S46p&OhIx4}7T8$Jk)esN393g>2Ra2nNy4uirE z{^&(G@Mpuv_0TVFsmah0FB>}a1V5CBPVd<8*&Fmrw|EWCR@mSagbj`y*ucMk15f%5 zyxBM8B90&YQ8R~w@rImvH*kF2u!kxA;+9!Xo{kuO(Ex12{&V<6CThFnX@#GQ4Y>*7 z2RGypL%;YTCk*5`~g4NK;j2~$NTuB z>&4y%24NerzQPYh)8EAg_AMJWB%xorMIDm)0e$l$8|NWo3bm~$xXzkdJt(Vf-ZCySHA2Ujol&%gV@vwLUjheuBj z_C9=k`sNo;E`0%vk`0}=haZrRd?S&fgBE-f7i4+c4gLD1%dcI24@q{G%dcPh6a4p; zol9>b=jVDVpBIwLB|_)C?L(yT;y#6dq7f#=aPsoOBfsl{+O2^KFBVW3i3%vW5m1IS z4e5JO<%0)m>4E}xhB*~pETAyn7f^B|pfqWoazs$_P~ezfrFqFnq7FMq3D)(z0wW!U zMH3%}6>b<-Ou==A2Ouwy>|A}f3?z77VnS4=wm6H1CWKEe1)PC>G#{k$Q$vd>1Sida zOCmd0Z(z8P;knP;0!4QCoOIwiFzo6YJPP>BEY(lV3pz> zULj(G^;3Z*Hv%go;KVKHA9Z*~bq~>zj}Wu&&kE7hWN-u#YJ0lN*7R5dp>m$<9@0Tr$5(OEhI- zLga@goF)7CU6FlQ=?OT6W8Arf6e6!YdT?+$Llq2$hHyHmfxb4d;qA1(n&ZHRw$!LH z8K)lD@D^gpjGe0v-_Tlya5|}hvo_Wd!jYeGtb=R9sm408|LEXcIF#qS?O7)7@D@LG zxZVR{!HEZk2LcIapMvULb}UOGI}4{K=e$u`CI(I?HHFr2hFT>#Ldu9U)q8*@x=!{# zOVT?FM>6KTwOS?yA}2M4)^I90;yqWAqj*E@6ZfL1grBUnN;z6M3UJPwu`W(0HE=4m zp36J!kTMU2pQ0s!GpWlyMa0>wONzlm0h;iQCbF>d-X^>{HpkH0AXMJV>@!6C{L zbiZ@n=q+Ibk&~K2Yt^heYov_LQEsG~LkeM^8et&$0Q)8+vam|_g;z+ehOrI^D)t#7 z{^)OK;SB!fyov0x&q)oOm7yYS#H!X8hKdN~Kw+O6DpGRQu=v4geG?K{SS9Z|yp>(T1|lalh1P^ZO;mV~TiBN-DhSlNkG7+G_VI&Ls}mAgSY@q-R|xyC8y;W@ zan>n@h(E>LSvWJyId7A@>~m5BXJtMro9MtMIKzCDH`0koj8n}=W%s)zy|Zv;>~r2& zFB1cilbS+n)vV_CyyGtXO!NByEeZy0j#CL(O8CL4<_U=`tWrwCD};U6n-8#*lo%rZ z%FNEfS(usgroGEPCpB=Y<)*UdWx}zVW%UNqoR)EDuU!-&b4)F8$u4|}gYYR);)jCA z7FH=G;T6KZunGo(N=h^l-lUJU>O45)cbzdqhaLG!Q;RQVP#Eip=!P2>iI{?07akHD z#vWXR2}{AC_`ZOJ31NtfArrBI#51N4ENU7e)&V`Y2Bt$uRaPw+R2vqvX#rj=pyIH2 zR}G6}iU>+Ehztf4sQkfWkit?jD7-IV;n#sdFi_|jWGL!!Fk2M#SUAQb?~ccJYvb|w zVgVKAwJ?Q9BaN6s7(_M<3P<(9MVMMpp`qBI0WS|&f`%f4hn_)(d>En&u=2qp?@k1E zYZC!Beds~Oi2y1s)tVu#hqY|W&~wWli=zR%!|UDJ@H)O&I2DK2yJ~nHQ_RSc0uXRL zr)!7Zd0ggfQW0)AVn&7)oDe&KoG?6M!;6El-NnIoF*AAu*d^wY7GRoj+*k$k)TVfplP~yozgTrB? z!QtT%n|2(G-8T+?LYFz4Y=oPT5QZC^5Zi^E@EIp$3l0h=BM!b|lbYgT%E6DYV8C_G z1|1xLje3q3F2b^dLt%d)*N|I?k(CE0=GYFl9{eOFB#RHqLq;ERWme!>lEL~zg1JZ? zY(V%?s<8{zPR1Y{j4eyKhRlcZhtK7rp@C_ES!9I5!J*B=6onrHvtTyB zkHVTxINQN81)-f}+2I@=OjIZgRw|T%3|06Fy9^FKkw+1k4n`{+8WO?ifFGsu$$$lq zbGBi@&5X=g=t`C>a+Q2!&%)0EJFHsp*uk)cLxYr%c?$<0%Z2lHp?olPp*UE($c1)* zXJqptkB4$OlgmSi6tFOXkJL#(6B%L^fw+M}ycoo6>MHI3LTEUp6C~ z8a#K>#%E+%L(ybhL&31G;fuUfYI8=0Hk62LZ74P;GcxDl=b$WM&cctYgXa#`J#vvJ zR@^f(^WjiwnlOUltU-amPv_MW~YD5+!5XB}zu-OLCP2WW+@2VaLQ5sYtSB;z!{V zech8E`Q7s2N`98+%=S%q=I<%;6;@6hFG>=&P8=Gb!QzP{nedG4p71DND&u4@G2&|w zP_ludXEKALglq{V0sIE}77+))BucJA9)?kPqz}jNg?oz*7E=5q&|oLUIf8V+T8baT zumUzy{0Ort&ch-g$Np0|*-zm*XA>$8koJY6*(o_@*Bnd7hI4GFz@UK0u8NaMz0ons z^eCm5Lx(9BnOWf~$LMkZjIHDF5FLQgIba4#DW0ZeePUMvapOuu?)t56}e*6LiHUeQ*^aOQZA_azsE#a73_iMAuTt9*YE-Hw?Wl77@3xi0lSK zRAUi!94$~us%v<<=2Hb3)SeWM#&H&akM*QUus?Q z*sjPX$UF{VOO&Yc>%yCbDz<_`SydeET?GJqYZ_KHGC5VkG)KKfnlARo0x=y|6wx|- zz%(i6!7@uhRHJ)0rfK;j&?Ug5&6~>u^O3NW5qTozD0_N9n?U~yd*Dy zb)SLxP@W+3{v}d<5jnLK5z9wZM7l^3RUFy71aN$7idc;#2WRnBgNciJixlxQC;hUv zG7&5jWKx{mYCs{F#$JF*bAKPty|Fujif;w<3#iT4LjpEb{cph(|x6qAaODTCu zf99nBnUnr!PWqoY>3`;=|Cy6Mx=HFO|NrTv|C7;4e}96L{yMn8v$5as!xz`GQ-=$t zfW4Ex7Yft6FIS!P*Ww)*tp9?OK1k!m!AU>jU=z*Z2M-jCHyu!9FgXY+P$4U~tHEXy zpvZVLf-*R098WQvynOJ;!{pWhMJBg{pu&p<6juCbH;=cHdQh4)PgWu*c_=6bC;fnY zAQAlO$Z9&k%8g59Qwek!mUYq(yvmUPd4YtT^mB$pC;dE}5S6d6ICJZ6!pW5sa0d3V zb$7zaDYzPW|EMIwPWm~X=%k;A0}+h)z0kzZ5+@t+M}CU!J{%zFCgKb!1ShQzltkD` zKc^g>^z(4wgj0kUTEoeNBhKIy!CPTH&X7WI(yCBNgq`$r%F#(b4+l>8zIdTEoJ=_4 zG*0@FpCN_dq~*Jk2s`QLl%tb=9uAyvIPyYkIGJ$7DGpbtce;r4WTyaOE(o8Y*HEJB?0vk*^2eD=ZAIA;jK^AZ!HGPT87iVeRjvM(4W z<3);nA%$>^Hrsmk@q>eJLL$H-Bkn==g;xmsg4-mrDE4JUJdUuFe#t&I|1Mw?BA0y% zXURT(S7cu>Hs@`^zV(F^!amyM>)FQ-1rG9pA58?Xi*$4N8 zl6~ULkcShZGPT87vM-F40#1OSzL`#T?%AhDQ{pRMK-#(L3{|3&zJt?A4V<-sjS!C2 zEY2vvsRlMNg;X;SC>)%QhQw=zq}fRgoVBrzIO#{6ajZkzoIO9)SSNVGmpI8uKj#}f zx_q2?OPLzJSrwdtu;9dl)VthB`|MK?KZ7TH0g0XTOPu13l!pV6SMLZ-a+J5vKse$I z^^VY5B$C>F0Q&lYSl!oSqyZw1!j35mH8eCOJYN)t>Y=!4ux$r=tL)lfHw~ zNe%QBbr}dpeg<`kP{mKBE-87h3ByAHIymX4k|9Tt$im9U;yoQwLwLX&poZioHb;ZR z?|<1zKW9^P($B+z$m^^TTB~N&StDhv=G0lszH?vAYOF&s9%l%j;<2BIz$REF`@$=P zePOJFEb?BAbpr8NM*~Aea?;P)6rJ?*a3FG0Q)t3jO0ya&B4uP>8Y&`CO9?yAC(u6o zCM2@3O7?|U2>Xnaer$ai5%||7Sa@*RHk!!7DxCXx#~XA4EcWROPWlO!A~G;hAt(L3 z_M(%19u7oKY6`8@s+y=|PWln2ny8S+zH0CM;NlxiWMP%H8t4f7jFWzXrHBm7N6AS) zXH#_2&%=SpNll?O_Nn6TX1NPWm~X=%k;A1CcksM`#VFn%^U3 z6y7wy56}RbwK%)Rn}-54;ZqHmABsc-Ho+>TB)meZ**NJ(_8B6)noWk<~{Q6u$Z0n2N|T+c|j#INDYgHS|V)_Rv%o1H3qQ@e(0ux zZ+>vnj|>Vaq_XrlSUlw;N`LTYK)J(fcG4dNrH9wSHy@l*!|O;|ob=bhNgoQDoSfIuNndW@7eooj&xo&ZTB3yE zk-VWOn7p7U817H>NWP(b4Y|oDm7d8viC)W2`Wyf^I|^VYeF`8iK)R9(BE66w=lrz< z4kssl3Wxh2UEsV#+1W{-vXPTMUCGIb;^E^&@$95e;pC)G;Q<#pbx|<6&{8nGpC~zf zS0UVlgyf`83CZ`262kWk3B^et;q0VOSMobWJUQvpBYAsMI{NAY2aqE$#S0h7NuQFD zk2POIZXw1_`jnVs*-4+Cq=f9Gk38(8&sS!JIO!u9Iq7pS7m1zp=~1eYo%HE3R3Ck` zfm4TS#HSnhk-XUGUGQQPc7frKJdV(x+Fz`;5ZLf0rKN zibt0~R&ukGK812gI&zVvC*d4@^MN1XOGu%iSa8y(*M7p0;-rsfcG9OSIq4%cIqB0y zYE_){DVjV0fl{3G5x`FRNGR3DPWluYm=>7DPWluam_<(d^ca{$zPt1&BEU}i^hPO@ zWFaSg3X?LBlRh%AlRjO^tsAlUrUVCz$gq<>g$l>+o`yuyfY?bN1raBGdI>q{mOnp+~|-cG9O{_$$(d^RkmZJ;99@7jn|)%K_zNCw+cAl+ZJ| zJd{WQOHTTn<|$u9MA%86Lb-u-H=?PBye36%*%FE%T&w=vNQ+jD|(kDRV z6iv}Wnw<0z%1-(SB`1A)jIlyZWK*2<@h)-Fr)1=$&sSj&JL%I~aa?+=ZVDvAdbwpr;lRhAblRjR_PWl`m4PTt}IY9D=lRl>u z^~O&6^c?yU`s@awAct=XmNqF)`V=f}6JO!rM69^QNuMI6X_AjPWep01ob)MDgpHi^ z=?PByd|Asya){`&lRiaCYau6ndJ-nGlRh5FNgqVmNuM4CE<5Q{a1bSO(x+HaHRPlZ zUWk)Er3&qlob)M`Fju6Qob)M7bQM1Ifu|We>GM^JNMHP*H;R)!BG^fv0_Zywl!Lzh zL05Lt$NR`hpB@7~c;{1oank2-?nu~4pB{teW+#2hE&OIDeR>oTU?+V_9qNpo^!Zt; zlDzRLwWuZfYzRY$!BTj9KLnxVq)$nuxM$>lOpl^n$Vney`HLdB5hr~_lP5e~geUBz zk7VMck7Vqm&sRynPWnhsPWp6_iaeKopd-I)3MB_}zS3iG(x+#UNpaGr2z-Zx69mb| z*GM>9AQhmIlRjmZI$jTpfR(gz}O(x(7v zU*x2Zh~NXJh4e3f=1?CipLj-B)=HjHc7Ngr<^Cw;m|cgIfp^vD&>PWtpDY-T5Y zdK4bAlRmvsDz=jWBRT0K4LRwf5d3i!0?$tReC0MSPWnhkPWqINo%Gd>IO$Uca? Date: Thu, 26 Mar 2026 10:27:21 +0100 Subject: [PATCH 019/107] =?UTF-8?q?Bump=20version:=201.3.0=20=E2=86=92=201?= =?UTF-8?q?.4.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- HISTORY.rst | 2 +- SECURITY.md | 4 ++-- dateparser/__init__.py | 2 +- pyproject.toml | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/HISTORY.rst b/HISTORY.rst index 361072705..f854f5767 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,7 +3,7 @@ History ======= -1.4.0 (unreleased) +1.4.0 (2026-03-26) ------------------ Security fixes: diff --git a/SECURITY.md b/SECURITY.md index 5435d6213..ce5a8b780 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -4,8 +4,8 @@ | Version | Supported | | --------- | ------------------ | -| 1.3.x | :white_check_mark: | -| < 1.3.x | :x: | +| 1.4.x | :white_check_mark: | +| < 1.4.x | :x: | ## Reporting a Vulnerability diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 634f2748d..669317a0b 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,4 +1,4 @@ -__version__ = "1.3.0" +__version__ = "1.4.0" from .conf import apply_settings from .date import DateDataParser diff --git a/pyproject.toml b/pyproject.toml index 0e4da89c2..f6650e0d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [tool.bumpversion] -current_version = "1.3.0" +current_version = "1.4.0" commit = true tag = true From 3b4a8163c0c0bc5c205ae34a5ced785bdb189e1f Mon Sep 17 00:00:00 2001 From: Elias Dorneles Date: Tue, 31 Mar 2026 10:19:47 +0200 Subject: [PATCH 020/107] Update Read the Docs config to use ubuntu-24.04 (#1320) --- .readthedocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.readthedocs.yml b/.readthedocs.yml index e71d34f3a..eba4aed6b 100644 --- a/.readthedocs.yml +++ b/.readthedocs.yml @@ -5,7 +5,7 @@ sphinx: fail_on_warning: true build: - os: ubuntu-20.04 + os: ubuntu-24.04 tools: # For available versions, see: # https://docs.readthedocs.io/en/stable/config-file/v2.html#build-tools-python From b72ed09a7fd3fde2df9eac4bd6c34070b330b3d3 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 9 Apr 2026 09:22:23 +0200 Subject: [PATCH 021/107] Remove fastText support and enable numpy 2.x compatibility (#1315) * Remove fastText support and enable numpy 2.x compatibility FastText library has been archived since March 2024 and is no longer maintained. This dependency was blocking numpy 2.x adoption. Changes: - Remove fasttext extra from setup.py dependencies - Add deprecation warnings to fasttext.py module - Update documentation to recommend langdetect as primary option - Update CLI to deprecate --fasttext flag - Add comprehensive test suite for langdetect integration - Remove fasttext from tox.ini test configurations Users should migrate to langdetect: pip install dateparser[langdetect] Closes #1287 Closes #1251 * Update dateparser_cli/cli.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update dateparser/custom_language_detection/fasttext.py Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Simplify fasttext deprecation to always error The previous approach was confusing: - If fasttext was installed, it showed a warning but still worked - If fasttext wasn't installed, it raised an ImportError This creates inconsistent deprecation - users don't know if the feature is truly deprecated or not. Now the module: - Always shows deprecation warning on import - Always raises ImportError when detect_languages() is called - Provides clear migration path to langdetect - No functional fasttext code remains This makes the deprecation clear and consistent. * Remove unused module-level mock in test_language_detect The module-level 'detect_languages' mock was defined but never used. The MockLangDetectTest class defines its own mock as a class attribute, and other test classes use the actual lang_detect_detect_languages function. This cleanup removes the unused mock to avoid confusion. --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .../custom_language_detection/fasttext.py | 66 ++++---- dateparser_cli/cli.py | 18 ++- docs/custom_language_detection.rst | 44 +----- setup.py | 1 - tests/test_language_detect.py | 141 +++++++++++++----- tox.ini | 4 - 6 files changed, 154 insertions(+), 120 deletions(-) diff --git a/dateparser/custom_language_detection/fasttext.py b/dateparser/custom_language_detection/fasttext.py index 713b014c3..dd1e1b7c2 100644 --- a/dateparser/custom_language_detection/fasttext.py +++ b/dateparser/custom_language_detection/fasttext.py @@ -1,43 +1,35 @@ -import os +""" +Deprecated fastText language detection module. -import fasttext +This module is deprecated as the fastText library is archived and unmaintained. +Please use langdetect instead. +""" -from dateparser_cli.exceptions import FastTextModelNotFoundException -from dateparser_cli.fasttext_manager import fasttext_downloader -from dateparser_cli.utils import create_data_model_home, dateparser_model_home +import warnings -_supported_models = ["large.bin", "small.bin"] -_DEFAULT_MODEL = "small" - - -class _FastTextCache: - model = None - - -def _load_fasttext_model(): - if _FastTextCache.model: - return _FastTextCache.model - create_data_model_home() - downloaded_models = [ - file for file in os.listdir(dateparser_model_home) if file in _supported_models - ] - if not downloaded_models: - fasttext_downloader(_DEFAULT_MODEL) - return _load_fasttext_model() - model_path = os.path.join(dateparser_model_home, downloaded_models[0]) - if not os.path.isfile(model_path): - raise FastTextModelNotFoundException("Fasttext model file not found") - _FastTextCache.model = fasttext.load_model(model_path) - return _FastTextCache.model +warnings.warn( + "fastText support is deprecated and will be removed in a future version. " + "The fastText library is archived and unmaintained. " + "Please migrate to langdetect: from dateparser.custom_language_detection.langdetect import detect_languages", + DeprecationWarning, + stacklevel=2, +) def detect_languages(text, confidence_threshold): - _language_parser = _load_fasttext_model() - text = text.replace("\n", " ").replace("\r", "") - language_codes = [] - parser_data = _language_parser.predict(text) - for idx, language_probability in enumerate(parser_data[1]): - if language_probability > confidence_threshold: - language_code = parser_data[0][idx].replace("__label__", "") - language_codes.append(language_code) - return language_codes + """ + Deprecated function. FastText support has been removed. + + Args: + text: The text to detect languages from (unused) + confidence_threshold: Minimum confidence threshold (unused) + + Raises: + ImportError: Always, as fastText is no longer supported. + """ + raise ImportError( + "fastText is no longer supported as the library is archived and unmaintained. " + "Please use langdetect instead:\n" + " pip install dateparser[langdetect]\n" + " from dateparser.custom_language_detection.langdetect import detect_languages" + ) diff --git a/dateparser_cli/cli.py b/dateparser_cli/cli.py index f51a8c9cd..82acb3047 100644 --- a/dateparser_cli/cli.py +++ b/dateparser_cli/cli.py @@ -1,7 +1,7 @@ import argparse import logging +import warnings -from .fasttext_manager import fasttext_downloader from .utils import clear_cache @@ -12,7 +12,7 @@ def entrance(): dateparser_argparse.add_argument( "--fasttext", type=str, - help='To download a fasttext language detection models. Supported models are "small" and "large"', + help="[DEPRECATED] fastText is no longer supported. Please use langdetect instead.", ) dateparser_argparse.add_argument( "--clear", @@ -28,9 +28,17 @@ def entrance(): logging.info("dateparser-download: All cache deleted") if args.fasttext: - fasttext_downloader(args.fasttext) + warnings.warn( + "fastText support has been removed as the library is archived and unmaintained. " + "Please migrate to langdetect. Install with: pip install dateparser[langdetect]", + DeprecationWarning, + stacklevel=2, + ) + dateparser_argparse.error( + "fastText is no longer supported. Please use langdetect for language detection." + ) - if not (args.clear or args.fasttext): + if not args.clear: dateparser_argparse.error( - "dateparser-download: You need to specify the command (i.e.: --fasttext or --clear)" + "dateparser-download: You need to specify the command (i.e.: --clear)" ) diff --git a/docs/custom_language_detection.rst b/docs/custom_language_detection.rst index c20d829c9..6598ac4a8 100644 --- a/docs/custom_language_detection.rst +++ b/docs/custom_language_detection.rst @@ -3,8 +3,7 @@ Custom language detection ========================= `dateparser` allows to customize the language detection behavior by using the ``detect_languages_function`` parameter. -It currently supports two language detection libraries out of the box: `fastText `_ -and `langdetect `_, and allows you to implement your own custom language detection. +It supports the `langdetect `_ library out of the box, and allows you to implement your own custom language detection. .. warning:: @@ -14,51 +13,24 @@ and `langdetect `_, and allows you to i Built-in implementations ======================== -fastText -~~~~~~~~ -Language detection with fastText. - -Import the fastText wrapper and pass it as ``detect_languages_function`` -parameter. Example:: - - >>> from dateparser.custom_language_detection.fasttext import detect_languages - >>> dateparser.parse('12/12/12', detect_languages_function=detect_languages) - -The fastText integration currently supports the large and the small models. -Find more information about `fasttext `__ models. -You can download your model of choice using ``dateparser-download``. - -Downloading small model:: - - >>> dateparser-download --fasttext small - -Downloading large model:: - - >>> dateparser-download --fasttext large - -Deleting all cached models:: - - >>> dateparser-download --clear_cache - -.. note:: - - If no model has been downloaded, the fastText wrapper downloads and uses - the small model by default. - langdetect ~~~~~~~~~~ Language detection with langdetect. -Import the langdetect wrapper and pass it as ``detect_languages_function`` +To use langdetect, first install it:: + + pip install dateparser[langdetect] + +Then import the langdetect wrapper and pass it as ``detect_languages_function`` parameter. Example:: >>> from dateparser.custom_language_detection.langdetect import detect_languages >>> dateparser.parse('12/12/12', detect_languages_function=detect_languages) - .. note:: - From some tests we did, we recommend to use ``fastText`` for faster and more accurate results. + **Deprecated fastText support**: The fastText integration has been removed as the library + is archived and no longer maintained. If you were using fastText, please migrate to langdetect. Custom implementation ===================== diff --git a/setup.py b/setup.py index 6be5d3346..c46432f6b 100644 --- a/setup.py +++ b/setup.py @@ -39,7 +39,6 @@ }, extras_require={ "calendars": ["convertdate>=2.2.1", "hijridate"], - "fasttext": ["fasttext>=0.9.1", "numpy>=1.22.0,<2"], "langdetect": ["langdetect>=1.0.0"], }, license="BSD", diff --git a/tests/test_language_detect.py b/tests/test_language_detect.py index fe82c1db4..2ab1cda45 100644 --- a/tests/test_language_detect.py +++ b/tests/test_language_detect.py @@ -1,6 +1,6 @@ import pytest -pytest.importorskip("fasttext") +pytest.importorskip("langdetect") import unittest from datetime import datetime @@ -9,50 +9,117 @@ from parameterized import param, parameterized from dateparser import parse -from dateparser.custom_language_detection.fasttext import ( - detect_languages as fast_text_detect_languages, -) from dateparser.custom_language_detection.langdetect import ( detect_languages as lang_detect_detect_languages, ) from dateparser.date import DateDataParser from dateparser.search import search_dates -detect_languages = Mock() -detect_languages.return_value = ["en"] +class LangDetectBasicTest(unittest.TestCase): + """Tests for basic langdetect functionality""" -class CustomLangDetectParserTest(unittest.TestCase): - def check_is_returned_list(self): - self.assertEqual(type(self.result), list) + def test_returns_list(self): + result = lang_detect_detect_languages("14 June 2020", 0.0) + self.assertIsInstance(result, list) - @parameterized.expand( - [ - param(dt_string="14 June 2020", confidence_threshold=0.0), - param(dt_string="26 July 2021", confidence_threshold=0.0), - ] - ) - def test_custom_language_detect_fast_text(self, dt_string, confidence_threshold): - self.result = fast_text_detect_languages(dt_string, confidence_threshold) - self.check_is_returned_list() + def test_detects_english(self): + result = lang_detect_detect_languages( + "The meeting is scheduled for Tuesday, July 22, 2014", 0.5 + ) + self.assertIn("en", result) - @parameterized.expand( - [ - param(dt_string="14 June 2020", confidence_threshold=0.0), - ] - ) - def test_custom_language_detect_lang_detect(self, dt_string, confidence_threshold): - self.result = lang_detect_detect_languages(dt_string, confidence_threshold) - self.check_is_returned_list() + def test_detects_spanish(self): + result = lang_detect_detect_languages( + "La reunión está programada para el martes 22 de julio de 2014", 0.5 + ) + self.assertIn("es", result) - @parameterized.expand( - [ - param(dt_string="10-10-2021", confidence_threshold=0.5), - ] - ) - def test_lang_detect_doesnt_raise_error(self, dt_string, confidence_threshold): - result = lang_detect_detect_languages(dt_string, confidence_threshold) - assert result == [] + def test_detects_french(self): + result = lang_detect_detect_languages( + "La réunion est prévue pour le mardi 22 juillet 2014", 0.5 + ) + self.assertIn("fr", result) + + def test_detects_german(self): + result = lang_detect_detect_languages( + "Das Treffen ist für Dienstag, den 22. Juli 2014 geplant", 0.5 + ) + self.assertIn("de", result) + + def test_handles_numeric_only_input(self): + result = lang_detect_detect_languages("10-10-2021", 0.5) + self.assertEqual(result, []) + + def test_handles_empty_string(self): + result = lang_detect_detect_languages("", 0.5) + self.assertEqual(result, []) + + def test_confidence_threshold_filters_results(self): + # With low threshold, should detect language + result_low = lang_detect_detect_languages("14 June 2020", 0.0) + self.assertGreater(len(result_low), 0) + + # With very high threshold, might not detect anything on short strings + result_high = lang_detect_detect_languages("14 June", 0.99) + # Short strings may have uncertain detection, result_high might be empty + self.assertIsInstance(result_high, list) + + +class LangDetectIntegrationTest(unittest.TestCase): + """Tests for langdetect integration with dateparser""" + + def test_parse_with_langdetect_english(self): + result = parse( + "Tuesday Jul 22, 2014", + detect_languages_function=lang_detect_detect_languages, + ) + self.assertEqual(result, datetime(2014, 7, 22, 0, 0, 0)) + + def test_parse_with_langdetect_spanish(self): + result = parse( + "martes 22 de julio de 2014", + detect_languages_function=lang_detect_detect_languages, + ) + self.assertIsNotNone(result) + self.assertEqual(result.year, 2014) + self.assertEqual(result.month, 7) + self.assertEqual(result.day, 22) + + def test_parse_with_langdetect_french(self): + result = parse( + "mardi 22 juillet 2014", + detect_languages_function=lang_detect_detect_languages, + ) + self.assertIsNotNone(result) + self.assertEqual(result.year, 2014) + self.assertEqual(result.month, 7) + self.assertEqual(result.day, 22) + + def test_datedataparser_with_langdetect(self): + ddp = DateDataParser(detect_languages_function=lang_detect_detect_languages) + result = ddp.get_date_data("Tuesday Jul 22, 2014") + self.assertEqual(result["date_obj"], datetime(2014, 7, 22, 0, 0, 0)) + + def test_search_dates_with_langdetect(self): + result = search_dates( + "The event is on January 3, 2017 and ends February 1st", + detect_languages_function=lang_detect_detect_languages, + ) + self.assertIsNotNone(result) + self.assertEqual(len(result), 2) + # Check that dates are found + self.assertEqual(result[0][1], datetime(2017, 1, 3, 0, 0)) + self.assertEqual(result[1][1], datetime(2017, 2, 1, 0, 0)) + + def test_parse_without_langdetect_still_works(self): + # Ensure dateparser works without custom language detection + result = parse("Tuesday Jul 22, 2014") + self.assertEqual(result, datetime(2014, 7, 22, 0, 0, 0)) + + +class MockLangDetectTest(unittest.TestCase): + """Tests with mocked language detection""" # Mock test for parse, search_dates and DateDataParser @@ -62,7 +129,7 @@ def test_lang_detect_doesnt_raise_error(self, dt_string, confidence_threshold): # parse def when_date_is_parsed_using_parse(self, dt_string): - self.result = parse(dt_string, detect_languages_function=detect_languages) + self.result = parse(dt_string, detect_languages_function=self.detect_languages) def then_date_obj_exactly_is(self, expected_date_obj): self.assertEqual(expected_date_obj, self.result) @@ -79,7 +146,7 @@ def test_custom_language_detect_mock_parse(self, dt_string, expected_date_obj): # DateDataParser def when_date_is_parsed_using_with_datedataparser(self, dt_string): - ddp = DateDataParser(detect_languages_function=detect_languages) + ddp = DateDataParser(detect_languages_function=self.detect_languages) self.result = ddp.get_date_data(dt_string)["date_obj"] @parameterized.expand( @@ -97,7 +164,7 @@ def test_custom_language_detect_mock_datedataparser( def when_date_is_parsed_using_with_search_dates(self, dt_string): self.result = search_dates( - dt_string, detect_languages_function=detect_languages + dt_string, detect_languages_function=self.detect_languages ) @parameterized.expand( diff --git a/tox.ini b/tox.ini index ec567268b..ad2c5610e 100644 --- a/tox.ini +++ b/tox.ini @@ -19,7 +19,6 @@ passenv = TZ basepython = python3.14 extras = calendars - fasttext langdetect [testenv:min] @@ -39,9 +38,6 @@ deps = convertdate==2.2.1 hijridate==2.3.0 langdetect==1.0.0 - numpy==1.22.0 - # fasttext excluded due to - # https://github.com/facebookresearch/fastText/issues/512 [testenv:scripts] deps = From 373ede9e7f5671ebe472977271df8bb06a656bd8 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Tue, 28 Apr 2026 12:55:56 +0200 Subject: [PATCH 022/107] fix: preserve whitespace when removing translation tokens (fix #1302) (#1324) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: preserve whitespace when removing translation tokens (fix #1302) - Fixed whitespace collapsing when skip tokens (like 'klo' in Finnish) are removed - When a skip token is removed between spaces, preserve the maximum of surrounding spaces - Added comprehensive tests in test_whitespace_preservation.py - Updated existing affected test expectations to match corrected behavior - Fixes issue where double spaces were created when skip tokens were removed * fix: update remaining test expectations for whitespace preservation - Fixed 6 edge case tests related to _clear_future_words method - Most cases now correctly expect single spaces (he, nl, pl, vi-lúc, da) - Vietnamese pipe case ('|') correctly expects double space preservation - All 1,342 language and whitespace tests now passing * Fix the issue --- dateparser/languages/locale.py | 49 +++++++++++- tests/test_languages.py | 74 ++++++++++-------- tests/test_whitespace_preservation.py | 103 ++++++++++++++++++++++++++ 3 files changed, 195 insertions(+), 31 deletions(-) create mode 100644 tests/test_whitespace_preservation.py diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 33c14ea96..bf33f4375 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -152,8 +152,53 @@ def translate(self, date_string, keep_formatting=False, settings=None): date_string_tokens[i] = dictionary[word] or fallback if "in" in date_string_tokens: date_string_tokens = self._clear_future_words(date_string_tokens) + + # Remove empty tokens (skip words) and handle adjacent whitespace + # When a skip token is removed between spaces, keep the maximum number of spaces + filtered_tokens = [] + i = 0 + while i < len(date_string_tokens): + token = date_string_tokens[i] + + # Skip empty tokens (removed skip words) + if not token: + # Count preceding spaces already in filtered_tokens + prev_spaces = 0 + j = len(filtered_tokens) - 1 + while j >= 0 and filtered_tokens[j] == " ": + prev_spaces += 1 + j -= 1 + + # Count following spaces in the remaining tokens + next_spaces = 0 + j = i + 1 + while j < len(date_string_tokens) and date_string_tokens[j] == " ": + next_spaces += 1 + j += 1 + + # If surrounded by spaces, keep max(prev_spaces, next_spaces) + if prev_spaces > 0 and next_spaces > 0: + # Remove prev_spaces from filtered_tokens + for _ in range(prev_spaces): + filtered_tokens.pop() + + # Add back the maximum number of spaces + max_spaces = max(prev_spaces, next_spaces) + for _ in range(max_spaces): + filtered_tokens.append(" ") + + # Skip the empty token and all following spaces + i += next_spaces + 1 + continue + + i += 1 + continue + + filtered_tokens.append(token) + i += 1 + return self._join( - list(filter(bool, date_string_tokens)), + filtered_tokens, separator="" if keep_formatting else " ", settings=settings, ) @@ -511,7 +556,7 @@ def _generate_simplifications(self, normalize=False): def _clear_future_words(self, words): freshness_words = {"day", "week", "month", "year", "hour", "minute", "second"} if set(words).isdisjoint(freshness_words): - words.remove("in") + words[words.index("in")] = "" return words def _join(self, tokens, separator=" ", settings=None): diff --git a/tests/test_languages.py b/tests/test_languages.py index 070b9babe..52b9f2179 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -80,7 +80,7 @@ def setUp(self): # French param("fr", "20 Février 2012", "20 february 2012"), param("fr", "Mercredi 19 Novembre 2013", "wednesday 19 november 2013"), - param("fr", "18 octobre 2012 à 19 h 21 min", "18 october 2012 19:21"), + param("fr", "18 octobre 2012 à 19 h 21 min", "18 october 2012 19:21"), # German param("de", "29. Juni 2007", "29. june 2007"), param("de", "Montag 5 Januar, 2015", "monday 5 january 2015"), @@ -109,49 +109,57 @@ def setUp(self): param("it", "Giovedi Maggio 29 2013", "thursday may 29 2013"), param("it", "19 Luglio 2013", "19 july 2013"), # Portuguese - param("pt", "22 de dezembro de 2014 às 02:38", "22 december 2014 02:38"), + param("pt", "22 de dezembro de 2014 às 02:38", "22 december 2014 02:38"), # Russian - param("ru", "5 августа 2014 г. в 12:00", "5 august 2014 year. 12:00"), + param("ru", "5 августа 2014 г. в 12:00", "5 august 2014 year. 12:00"), # Turkish param("tr", "2 Ocak 2015 Cuma, 16:49", "2 january 2015 friday 16:49"), # Czech - param("cs", "22. prosinec 2014 v 2:38", "22. december 2014 2:38"), + param( + "cs", "22. prosinec 2014 v 2:38", "22. december 2014 2:38" + ), # Issue #1302: "v" → "in" → cleared, whitespace preserved # Dutch param( "nl", "maandag 22 december 2014 om 2:38", - "monday 22 december 2014 2:38", + "monday 22 december 2014 2:38", ), # Romanian - param("ro", "22 Decembrie 2014 la 02:38", "22 december 2014 02:38"), + param("ro", "22 Decembrie 2014 la 02:38", "22 december 2014 02:38"), # Polish - param("pl", "4 stycznia o 13:50", "4 january 13:50"), - param("pl", "29 listopada 2014 o 08:40", "29 november 2014 08:40"), + param("pl", "4 stycznia o 13:50", "4 january 13:50"), + param( + "pl", "29 listopada 2014 o 08:40", "29 november 2014 08:40" + ), # Issue #1302: "o" removed, whitespace preserved # Ukrainian - param("uk", "30 листопада 2013 о 04:27", "30 november 2013 04:27"), - param("uk", "22 верес 2021 о 07:37", "22 september 2021 07:37"), - param("uk", "28 лютого 2020 року об 11:57", "28 february 2020 year 11:57"), + param("uk", "30 листопада 2013 о 04:27", "30 november 2013 04:27"), + param("uk", "22 верес 2021 о 07:37", "22 september 2021 07:37"), + param("uk", "28 лютого 2020 року об 11:57", "28 february 2020 year 11:57"), param( "uk", "середу, 28 лютого 2020 року об 11:57", - "wednesday 28 february 2020 year 11:57", + "wednesday 28 february 2020 year 11:57", ), param( "uk", "понед, 12 вересня 2022 року об 09:22", - "monday 12 september 2022 year 09:22", + "monday 12 september 2022 year 09:22", ), # Belarusian - param("be", "5 снежня 2015 г. у 12:00", "5 december 2015 year. 12:00"), - param("be", "11 верасня 2015 г. у 12:11", "11 september 2015 year. 12:11"), - param("be", "3 стд 2015 г. у 10:33", "3 january 2015 year. 10:33"), + param("be", "5 снежня 2015 г. у 12:00", "5 december 2015 year. 12:00"), + param("be", "11 верасня 2015 г. у 12:11", "11 september 2015 year. 12:11"), + param("be", "3 стд 2015 г. у 10:33", "3 january 2015 year. 10:33"), # Arabic param("ar", "6 يناير، 2015، الساعة 05:16 مساءً", "6 january 2015 05:16 pm"), param("ar", "7 يناير، 2015، الساعة 11:00 صباحاً", "7 january 2015 11:00 am"), # Vietnamese param("vi", "Thứ Năm, ngày 8 tháng 1 năm 2015", "thursday 8 january 2015"), - param("vi", "Thứ Tư, 07/01/2015 | 22:34", "wednesday 07/01/2015 22:34"), - param("vi", "9 Tháng 1 2015 lúc 15:08", "9 january 2015 15:08"), + param( + "vi", "Thứ Tư, 07/01/2015 | 22:34", "wednesday 07/01/2015 22:34" + ), # Pipe between spaces preserved + param( + "vi", "9 Tháng 1 2015 lúc 15:08", "9 january 2015 15:08" + ), # Issue #1302: "lúc" removed, whitespace preserved # Thai param( "th", @@ -184,11 +192,13 @@ def setUp(self): param("en", "2014-12-12T12:33:39-08:00", "2014-12-12 12:33:39-08:00"), param("en", "2014-10-15T16:12:20+00:00", "2014-10-15 16:12:20+00:00"), param("en", "28 Oct 2014 16:39:01 +0000", "28 october 2014 16:39:01 +0000"), - param("es", "13 Febrero 2015 a las 23:00", "13 february 2015 23:00"), + param("es", "13 Febrero 2015 a las 23:00", "13 february 2015 23:00"), # Danish param("da", "Sep 03 2014", "september 03 2014"), param("da", "fredag, 03 september 2014", "friday 03 september 2014"), - param("da", "fredag d. 3 september 2014", "friday 3 september 2014"), + param( + "da", "fredag d. 3 september 2014", "friday 3 september 2014" + ), # Issue #1302: 'd.' removed, whitespace preserved # Finnish param("fi", "maanantai tammikuu 16, 2015", "monday january 16 2015"), param("fi", "ma tammi 16, 2015", "monday january 16 2015"), @@ -216,7 +226,9 @@ def setUp(self): param("fi", "su joulu 16, 2015", "sunday december 16 2015"), param("fi", "1. tammikuuta, 2016", "1. january 2016"), param("fi", "tiistaina, 27. lokakuuta 2015", "tuesday 27. october 2015"), - param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param( + "fi", "28 maalis klo 9:37", "28 march 9:37" + ), # Issue #1302: preserve single space # Japanese param("ja", "午後3時", "pm 3:00"), param("ja", "2時", "2:00"), @@ -239,7 +251,7 @@ def setUp(self): # Hebrew param("he", "20 לאפריל 2012", "20 april 2012"), param("he", "יום רביעי ה-19 בנובמבר 2013", "wednesday 19 november 2013"), - param("he", "18 לאוקטובר 2012 בשעה 19:21", "18 october 2012 19:21"), + param("he", "18 לאוקטובר 2012 בשעה 19:21", "18 october 2012 19:21"), param("he", "יום ה' 6/10/2016", "thursday 6/10/2016"), param("he", "חצות", "12 am"), param("he", "1 אחר חצות", "1 am"), @@ -497,7 +509,7 @@ def setUp(self): param("hr", "2 ožujak 1980 pet", "2 march 1980 friday"), param("hr", "nedjelja 3 lis 1879", "sunday 3 october 1879"), param("hr", "06. travnja 2021.", "06. april 2021."), - param("hr", "13. svibanj 2022. u 14:34", "13. may 2022. 14:34"), + param("hr", "13. svibanj 2022. u 14:34", "13. may 2022. 14:34"), param("hr", "20. studenoga 2010. @ 07:28", "20. november 2010. 07:28"), param("hr", "13. studenog 1989.", "13. november 1989."), param("hr", "u listopadu 2056.", " october 2056."), @@ -1210,7 +1222,9 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("ar", "اليوم", "0 day ago"), # Polish param("pl", "2 godz.", "2 hour."), - param("pl", "Wczoraj o 07:40", "1 day ago 07:40"), + param( + "pl", "Wczoraj o 07:40", "1 day ago 07:40" + ), # Issue #1302: fixed double space # Vietnamese param("vi", "2 tuần 3 ngày", "2 week 3 day"), param("vi", "21 giờ trước", "21 hour ago"), @@ -1249,10 +1263,10 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("id", "hari ini", "0 day ago"), param("id", "kemarin", "1 day ago"), param("id", "kemarin lusa", "2 day ago"), - param("id", "sehari yang lalu", "1 day ago"), - param("id", "seminggu yang lalu", "1 week ago"), - param("id", "sebulan yang lalu", "1 month ago"), - param("id", "setahun yang lalu", "1 year ago"), + param("id", "sehari yang lalu", "1 day ago"), + param("id", "seminggu yang lalu", "1 week ago"), + param("id", "sebulan yang lalu", "1 month ago"), + param("id", "setahun yang lalu", "1 year ago"), # Finnish param("fi", "1 vuosi sitten", "1 year ago"), param("fi", "2 vuotta sitten", "2 year ago"), @@ -1320,7 +1334,9 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("ja", "明後日", "in 2 day"), # Hebrew param("he", "אתמול", "1 day ago"), - param("he", "אתמול בשעה 3", "1 day ago 3"), + param( + "he", "אתמול בשעה 3", "1 day ago 3" + ), # Issue #1302: "בשעה" removed, whitespace preserved param("he", "היום", "0 day ago"), param("he", "לפני יומיים", "2 day ago"), param("he", "לפני שבועיים", "2 week ago"), diff --git a/tests/test_whitespace_preservation.py b/tests/test_whitespace_preservation.py new file mode 100644 index 000000000..8c90a42a3 --- /dev/null +++ b/tests/test_whitespace_preservation.py @@ -0,0 +1,103 @@ +""" +Tests for issue #1302: Whitespace preservation during translation +""" + +from parameterized import param, parameterized + +from dateparser.conf import settings +from dateparser.languages import default_loader +from tests import BaseTestCase + + +class TestWhitespacePreservation(BaseTestCase): + """ + Tests to ensure that whitespace is preserved exactly when translating + date strings, even when tokens are removed from the skip list (e.g., "klo" in Finnish). + + Issue #1302: Extra whitespace handling during date translation + """ + + def setUp(self): + super().setUp() + self.language = NotImplemented + self.datetime_string = NotImplemented + self.translation = NotImplemented + self.settings = settings + + @parameterized.expand( + [ + # Finnish: "klo" is a skip word + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param( + "fi", "tiistaina 27. lokakuuta 2015", "tuesday 27. october 2015" + ), + # Czech: "v" translates to "in", then cleared by _clear_future_words + param("cs", "22. prosinec 2014 v 2:38", "22. december 2014 2:38"), + param("cs", "22. prosinec 2014 v 2:38", "22. december 2014 2:38"), + # Polish: "o" is a skip word + param("pl", "4 stycznia o 13:50", "4 january 13:50"), + param("pl", "29 listopada 2014 o 08:40", "29 november 2014 08:40"), + # Russian: "в" is a skip word + param("ru", "5 августа 2014 г. в 12:00", "5 august 2014 year. 12:00"), + # Ukrainian: "о"/"об" are skip words + param("uk", "30 листопада 2013 о 04:27", "30 november 2013 04:27"), + # Croatian: "u" translates to "in", then cleared + param("hr", "13. svibanj 2022. u 14:34", "13. may 2022. 14:34"), + ] + ) + def test_whitespace_preservation_during_translation( + self, shortname, datetime_string, expected_translation + ): + """Test that exact whitespace is preserved when translating date strings.""" + self.given_bundled_language(shortname) + self.given_string(datetime_string) + self.when_datetime_string_translated() + self.then_string_translated_to(expected_translation) + + @parameterized.expand( + [ + # Finnish: keep_formatting=True + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + param("fi", "28 maalis klo 9:37", "28 march 9:37"), + # Czech: keep_formatting=True + param("cs", "22. prosinec 2014 v 2:38", "22. december 2014 2:38"), + # Polish: keep_formatting=True + param("pl", "4 stycznia o 13:50", "4 january 13:50"), + ] + ) + def test_whitespace_preservation_keep_formatting( + self, shortname, datetime_string, expected_translation + ): + """Test whitespace preservation with keep_formatting=True.""" + self.given_bundled_language(shortname) + self.given_string(datetime_string) + self.when_datetime_string_translated_keep_formatting() + self.then_string_translated_to(expected_translation) + + def given_bundled_language(self, shortname): + self.language = default_loader.get_locale(shortname) + + def given_string(self, datetime_string): + self.datetime_string = datetime_string + + def when_datetime_string_translated(self): + self.translation = self.language.translate( + self.datetime_string, settings=self.settings + ) + + def when_datetime_string_translated_keep_formatting(self): + self.translation = self.language.translate( + self.datetime_string, keep_formatting=True, settings=self.settings + ) + + def then_string_translated_to(self, expected_string): + self.assertEqual( + expected_string, + self.translation, + f"\nExpected: |{expected_string}|\nGot: |{self.translation}|\n" + f"Input: |{self.datetime_string}|", + ) From 33ec7ef98c215a565c4b44fcae58b1396034db61 Mon Sep 17 00:00:00 2001 From: honza Date: Thu, 7 May 2026 12:50:35 +0200 Subject: [PATCH 023/107] Better cs translation (#1325) --- dateparser/data/date_translation_data/cs.py | 358 +++++++++++++++++- .../date_translation_data/cs.yaml | 166 +++++++- tests/test_languages.py | 16 + 3 files changed, 518 insertions(+), 22 deletions(-) diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index 93a93367b..ed7e1ae90 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -37,8 +37,7 @@ "července", "červenec", "čvc", - "Črc", - "črv" + "Črc" ], "august": [ "srp", @@ -78,7 +77,8 @@ "st", "středa", "Stř", - "Středu" + "Středu", + "Středy" ], "thursday": [ "čt", @@ -88,13 +88,15 @@ "friday": [ "pá", "pátek", - "Pát" + "Pát", + "Pátku" ], "saturday": [ "so", "sobota", "Sob", - "Sobotu" + "Sobotu", + "Soboty" ], "sunday": [ "ne", @@ -112,14 +114,19 @@ "r", "rok", "roků", - "roky" + "roky", + "let", + "léta", + "lety" ], "month": [ "měs", "měsíc", "měsíců", "měsíce", - "měsícem" + "měsícem", + "měsícemi", + "měsícema" ], "week": [ "týd", @@ -131,7 +138,9 @@ "day": [ "den", "dnů", - "dny" + "dny", + "dnem", + "dní" ], "hour": [ "h", @@ -140,23 +149,27 @@ "hodiny", "hodinou", "hodinu", - "hodinami" + "hodinami", + "hodinama" ], "minute": [ "min", "minuta", "minut", "minutami", - "minuty" + "minuty", + "minutama" ], "second": [ "s", "sekunda", "sekundy", "sekund", + "sekundami", "vteřina", "vteřin", - "vteřiny" + "vteřiny", + "vteřinami" ], "relative-type": { "0 day ago": [ @@ -172,7 +185,11 @@ "tento měsíc" ], "0 second ago": [ - "nyní" + "nyní", + "teď hned", + "teď", + "okamžitě", + "právě teď" ], "0 week ago": [ "tento týd", @@ -195,7 +212,9 @@ "minulý rok" ], "in 1 day": [ - "zítra" + "zítra", + "zítřek", + "zítřka" ], "in 1 month": [ "příští měsíc" @@ -209,6 +228,15 @@ ], "2 day ago": [ "předevčírem" + ], + "3 day ago": [ + "předpředevčírem" + ], + "in 2 day": [ + "pozítří" + ], + "in 3 day": [ + "popozítří" ] }, "relative-type-regex": { @@ -281,12 +309,41 @@ "za (\\d+[.,]?\\d*) let", "za (\\d+[.,]?\\d*) r", "za (\\d+[.,]?\\d*) rok" + ], + "\\1 decade ago": [ + "před (\\d+[.,]?\\d*) desetiletími", + "před (\\d+[.,]?\\d*) dekádami", + "před (\\d+[.,]?\\d*) dekádou", + "před (\\d+[.,]?\\d*) desetiletím" + ], + "in \\1 decade": [ + "za (\\d+[.,]?\\d*) desetiletí", + "za (\\d+[.,]?\\d*) dekád", + "za (\\d+[.,]?\\d*) dekády", + "za (\\d+[.,]?\\d*) dekádu" + ], + "\\1 century ago": [ + "před (\\d+[.,]?\\d*) staletími", + "před (\\d+[.,]?\\d*) stoletími", + "před (\\d+[.,]?\\d*) stoletím" + ], + "in \\1 century": [ + "za (\\d+[.,]?\\d*) staletí", + "za (\\d+[.,]?\\d*) století" ] }, "locale_specific": {}, "skip": [ "přibližně", "v", + "ve", + "přibližně", + "asi", + "zhruba", + "cca", + "kolem", + "okolo", + "někdy", " ", "'", ",", @@ -305,12 +362,281 @@ "před" ], "in": [ - "ve", - "v" + "za" ], "simplifications": [ { - "teď": "0 sekunda" + "(o )?půlnoc(i|í)?": "0:00" + }, + { + "ráno": "AM" + }, + { + "dopoledne": "AM" + }, + { + "odpoledne": "PM" + }, + { + "(pod)?večer": "PM" + }, + { + "budoucí(ho)?": "příští" + }, + { + "nadcházející(ho)?": "příští" + }, + { + "tenhle": "tento" + }, + { + "tohle": "tento" + }, + { + "letos": "tento rok" + }, + { + "vloni": "minulý rok" + }, + { + "loni": "minulý rok" + }, + { + "jed(en|na|no|ním|ným|nou|noho|né|ný)": "1" + }, + { + "dv(a|ě|ou|ěma)": "2" + }, + { + "tř(i|ech|em|emi)": "3" + }, + { + "čty(r|ř)(i|ech|em|mi)": "4" + }, + { + "pět(i)?": "5" + }, + { + "šest(i)?": "6" + }, + { + "sed(u)?m(i)?": "7" + }, + { + "osm(i)?": "8" + }, + { + "devět|devíti": "9" + }, + { + "deset(i)?": "10" + }, + { + "jedenáct(i)?": "11" + }, + { + "dvanáct(i)?": "12" + }, + { + "čtrnáct(i)?": "14" + }, + { + "dvacet(i)?": "20" + }, + { + "třicet(i)?": "30" + }, + { + "první(ho|mu|m)?": "1." + }, + { + "druh(ý|á|é|ého|ému|ým|ou|ýho)": "2." + }, + { + "třet(í|ího|ímu|ím)": "3." + }, + { + "čtvrt(ý|á|é|ého|ému|ým|ou|ýho)": "4." + }, + { + "pát(ý|á|é|ého|ému|ým|ou|ýho)": "5." + }, + { + "šest(ý|á|é|ého|ému|ým|ou|ýho)": "6." + }, + { + "sedm(ý|á|é|ého|ému|ým|ou|ýho)": "7." + }, + { + "osm(ý|á|é|ého|ému|ým|ou|ýho)": "8." + }, + { + "devát(ý|á|é|ého|ému|ým|ou|ýho)": "9." + }, + { + "desát(ý|á|é|ého|ému|ým|ou|ýho)": "10." + }, + { + "jedenáct(ý|á|ého|ému|ým|ou|ýho|é)": "11." + }, + { + "dvanáct(ý|á|ého|ému|ým|ou|ýho|é)": "12." + }, + { + "čtrnáct(ý|á|ého|ému|ým|ou|ýho|é)": "14." + }, + { + "dvacát(ý|á|ého|ému|ým|ou|ýho|é)": "20." + }, + { + "třicát(ý|á|ého|ému|ým|ou|ýho|é)": "30." + }, + { + "(?<=(za|před)\\s)hodin(u|ou)\\b": "1 hodinu" + }, + { + "(?<=(za|před)\\s)minut(u|ou)\\b": "1 minutu" + }, + { + "(?<=(za|před)\\s)(?:vteřin(u|ou)|sekund(u|ou))\\b": "1 sekundu" + }, + { + "(?<=(za|před)\\s)týdn(em)\\b": "1 týden" + }, + { + "(?<=(za|před)\\s)měsíc(em)\\b": "1 měsíc" + }, + { + "(?<=(za|před)\\s)rok(em)\\b": "1 rok" + }, + { + "(?<=(za|před)\\s)den(em)\\b": "1 den" + }, + { + "čtvrt\\s*hodin(y|u)": "15 minut" + }, + { + "čtvrt\\s*hodinou": "15 minutami" + }, + { + "půl\\s*hodin(y|u)": "30 minut" + }, + { + "půl\\s*hodinou": "30 minutami" + }, + { + "tři\\s*čtvrtě\\s*hodin(y|u)": "45 minut" + }, + { + "tři\\s*čtvrtě\\s*hodinou": "45 minutami" + }, + { + "čtvrt na 1\\.?": "12:15" + }, + { + "čtvrt na 2\\.?": "1:15" + }, + { + "čtvrt na 3\\.?": "2:15" + }, + { + "čtvrt na 4\\.?": "3:15" + }, + { + "čtvrt na 5\\.?": "4:15" + }, + { + "čtvrt na 6\\.?": "5:15" + }, + { + "čtvrt na 7\\.?": "6:15" + }, + { + "čtvrt na 8\\.?": "7:15" + }, + { + "čtvrt na 9\\.?": "8:15" + }, + { + "čtvrt na 10\\.?": "9:15" + }, + { + "čtvrt na 11\\.?": "10:15" + }, + { + "čtvrt na 12\\.?": "11:15" + }, + { + "půl 1\\.?": "12:30" + }, + { + "půl 2\\.?": "1:30" + }, + { + "půl 3\\.?": "2:30" + }, + { + "půl 4\\.?": "3:30" + }, + { + "půl 5\\.?": "4:30" + }, + { + "půl 6\\.?": "5:30" + }, + { + "půl 7\\.?": "6:30" + }, + { + "půl 8\\.?": "7:30" + }, + { + "půl 9\\.?": "8:30" + }, + { + "půl 10\\.?": "9:30" + }, + { + "půl 11\\.?": "10:30" + }, + { + "půl 12\\.?": "11:30" + }, + { + "tři\\s*čtvrtě na 1\\.?": "12:45" + }, + { + "tři\\s*čtvrtě na 2\\.?": "1:45" + }, + { + "tři\\s*čtvrtě na 3\\.?": "2:45" + }, + { + "tři\\s*čtvrtě na 4\\.?": "3:45" + }, + { + "tři\\s*čtvrtě na 5\\.?": "4:45" + }, + { + "tři\\s*čtvrtě na 6\\.?": "5:45" + }, + { + "tři\\s*čtvrtě na 7\\.?": "6:45" + }, + { + "tři\\s*čtvrtě na 8\\.?": "7:45" + }, + { + "tři\\s*čtvrtě na 9\\.?": "8:45" + }, + { + "tři\\s*čtvrtě na 10\\.?": "9:45" + }, + { + "tři\\s*čtvrtě na 11\\.?": "10:45" + }, + { + "tři\\s*čtvrtě na 12\\.?": "11:45" } ] } diff --git a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml index 610478020..569841a6d 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml @@ -1,4 +1,5 @@ -skip: ["přibližně", "v"] +skip: ["přibližně", "v", "ve", "přibližně", "asi", "zhruba", "cca", "kolem", "okolo", "někdy"] + sentence_splitter_group : 1 @@ -9,13 +10,16 @@ tuesday: wednesday: - Stř - Středu + - Středy thursday: - Čtv friday: - Pát + - Pátku saturday: - Sob - Sobotu + - Soboty sunday: - Ned - Neděli @@ -26,15 +30,18 @@ june: - Čer july: - Črc - - črv - year: - roků - roky + - let + - léta + - lety month: - měsíců - měsíce - měsícem + - měsícemi + - měsícema week: - týdnů - týdny @@ -42,32 +49,179 @@ week: day: - dnů - dny + - dnem + - dní + hour: - hodin - hodiny - hodinou - hodinu - hodinami + - hodinama minute: - minut - minutami - minuty + - minutama second: - sekundy - sekund + - sekundami - vteřina - vteřin - vteřiny + - vteřinami ago: - před in: - - ve - - v + # "v" and "ve" is literal translations, but in context of time cz works diferently and uses "za". + - za relative-type: 2 day ago: - předevčírem + 3 day ago: + - předpředevčírem + in 1 day: + - zítřek + - zítřka + in 2 day: + - pozítří + in 3 day: + - popozítří + 0 second ago: + - teď hned + - teď + - okamžitě + - právě teď + +relative-type-regex: + \1 decade ago: + - před (\d+[.,]?\d*) desetiletími + - před (\d+[.,]?\d*) dekádami + - před (\d+[.,]?\d*) dekádou + - před (\d+[.,]?\d*) desetiletím + in \1 decade: + - za (\d+[.,]?\d*) desetiletí + - za (\d+[.,]?\d*) dekád + - za (\d+[.,]?\d*) dekády + - za (\d+[.,]?\d*) dekádu + \1 century ago: + - před (\d+[.,]?\d*) staletími + - před (\d+[.,]?\d*) stoletími + - před (\d+[.,]?\d*) stoletím + in \1 century: + - za (\d+[.,]?\d*) staletí + - za (\d+[.,]?\d*) století simplifications: - - teď: 0 sekunda + # 12-hour modificators + - (o )?půlnoc(i|í)?: 0:00 + - ráno: AM + - dopoledne: AM + - odpoledne: PM + - (pod)?večer: PM + + + # Synonyms + - budoucí(ho)?: příští + - nadcházející(ho)?: příští + - tenhle: tento + - tohle: tento + - letos: tento rok + - vloni: minulý rok + - loni: minulý rok + + # Numbers (Normal) + - jed(en|na|no|ním|ným|nou|noho|né|ný): '1' + - dv(a|ě|ou|ěma): '2' + - tř(i|ech|em|emi): '3' + - čty(r|ř)(i|ech|em|mi): '4' + - pět(i)?: '5' + - šest(i)?: '6' + - sed(u)?m(i)?: '7' + - osm(i)?: '8' + - devět|devíti: '9' + - deset(i)?: '10' + - jedenáct(i)?: '11' + - dvanáct(i)?: '12' + - čtrnáct(i)?: '14' + - dvacet(i)?: '20' + - třicet(i)?: '30' + + # Numbers (Ordinal) + - první(ho|mu|m)?: '1.' + - druh(ý|á|é|ého|ému|ým|ou|ýho): '2.' + - třet(í|ího|ímu|ím): '3.' + - čtvrt(ý|á|é|ého|ému|ým|ou|ýho): '4.' + - pát(ý|á|é|ého|ému|ým|ou|ýho): '5.' + - šest(ý|á|é|ého|ému|ým|ou|ýho): '6.' + - sedm(ý|á|é|ého|ému|ým|ou|ýho): '7.' + - osm(ý|á|é|ého|ému|ým|ou|ýho): '8.' + - devát(ý|á|é|ého|ému|ým|ou|ýho): '9.' + - desát(ý|á|é|ého|ému|ým|ou|ýho): '10.' + - jedenáct(ý|á|ého|ému|ým|ou|ýho|é): '11.' + - dvanáct(ý|á|ého|ému|ým|ou|ýho|é): '12.' + - čtrnáct(ý|á|ého|ému|ým|ou|ýho|é): '14.' + - dvacát(ý|á|ého|ému|ým|ou|ýho|é): '20.' + - třicát(ý|á|ého|ému|ým|ou|ýho|é): '30.' + + # Variant of "1" in places, where czechs would not use the nuber. (e.g. "za 1 hodinu" vs "za hodinu") + - '(?<=(za|před)\s)hodin(u|ou)\b': '1 hodinu' + - '(?<=(za|před)\s)minut(u|ou)\b': '1 minutu' + - '(?<=(za|před)\s)(?:vteřin(u|ou)|sekund(u|ou))\b': '1 sekundu' + - '(?<=(za|před)\s)týdn(em)\b': '1 týden' + - '(?<=(za|před)\s)měsíc(em)\b': '1 měsíc' + - '(?<=(za|před)\s)rok(em)\b': '1 rok' + - '(?<=(za|před)\s)den(em)\b': '1 den' + + # Fractions of hours (For relative time) + - 'čtvrt\s*hodin(y|u)': 15 minut + - 'čtvrt\s*hodinou': 15 minutami + - 'půl\s*hodin(y|u)': 30 minut + - 'půl\s*hodinou': 30 minutami + - 'tři\s*čtvrtě\s*hodin(y|u)': 45 minut + - 'tři\s*čtvrtě\s*hodinou': 45 minutami + + + # Fraction variant of absolute time + - 'čtvrt na 1\.?': '12:15' + - 'čtvrt na 2\.?': '1:15' + - 'čtvrt na 3\.?': '2:15' + - 'čtvrt na 4\.?': '3:15' + - 'čtvrt na 5\.?': '4:15' + - 'čtvrt na 6\.?': '5:15' + - 'čtvrt na 7\.?': '6:15' + - 'čtvrt na 8\.?': '7:15' + - 'čtvrt na 9\.?': '8:15' + - 'čtvrt na 10\.?': '9:15' + - 'čtvrt na 11\.?': '10:15' + - 'čtvrt na 12\.?': '11:15' + + - 'půl 1\.?': '12:30' + - 'půl 2\.?': '1:30' + - 'půl 3\.?': '2:30' + - 'půl 4\.?': '3:30' + - 'půl 5\.?': '4:30' + - 'půl 6\.?': '5:30' + - 'půl 7\.?': '6:30' + - 'půl 8\.?': '7:30' + - 'půl 9\.?': '8:30' + - 'půl 10\.?': '9:30' + - 'půl 11\.?': '10:30' + - 'půl 12\.?': '11:30' + + - 'tři\s*čtvrtě na 1\.?': '12:45' + - 'tři\s*čtvrtě na 2\.?': '1:45' + - 'tři\s*čtvrtě na 3\.?': '2:45' + - 'tři\s*čtvrtě na 4\.?': '3:45' + - 'tři\s*čtvrtě na 5\.?': '4:45' + - 'tři\s*čtvrtě na 6\.?': '5:45' + - 'tři\s*čtvrtě na 7\.?': '6:45' + - 'tři\s*čtvrtě na 8\.?': '7:45' + - 'tři\s*čtvrtě na 9\.?': '8:45' + - 'tři\s*čtvrtě na 10\.?': '9:45' + - 'tři\s*čtvrtě na 11\.?': '10:45' + - 'tři\s*čtvrtě na 12\.?': '11:45' diff --git a/tests/test_languages.py b/tests/test_languages.py index 52b9f2179..406e087ab 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1189,6 +1189,22 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("cs", "40 sekunda", "40 second"), param("cs", "4 týden", "4 week"), param("cs", "14 roků", "14 year"), + param("cs", "20 let", "20 year"), + param("cs", "pět minut", "5 minute"), + param("cs", "před šesti minutami", "6 minute ago"), + param("cs", "sedmého ledna loni", "7. january 1 year ago"), + param("cs", "včera", "1 day ago"), + param("cs", "předevčírem", "2 day ago"), + param("cs", "dnes", "0 day ago"), + param("cs", "teď", "0 second ago"), + param("cs", "před rokem", "ago 1 year"), + param("cs", "prvního ledna 2021 v půl šesté", "1. january 2021 5:30"), + param("cs", "desátého šestý", "10. 6."), + param("cs", "za dvacet let", "in 20 year"), + param("cs", "za čtrnáct dní", "in 14 day"), + param("cs", "čtvrt na tři", "2:15"), + param("cs", "zítra o půlnoci", "in 1 day 0:00"), + param("cs", "v sedum třicet odpoledne", " 7 30 pm"), # Chinese param("zh", "昨天", "1 day ago"), param("zh", "前天", "2 day ago"), From 075712f2364edc877586f2a4eb2a5d66f8e9b2e4 Mon Sep 17 00:00:00 2001 From: Prashant Sharma <31796326+gutsytechster@users.noreply.github.com> Date: Fri, 8 May 2026 17:38:30 +0530 Subject: [PATCH 024/107] Handle spaces around operators (#1327) * tests(tests/freshness_date_parser.py): add tests for operations with spaces * fix(dateparser/freshness_date_parser.py): handle spaces around operator --- dateparser/freshness_date_parser.py | 4 ++-- tests/test_freshness_date_parser.py | 10 ++++++++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 8dc8f489e..efb14a2c6 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -10,7 +10,7 @@ from .timezone_parser import pop_tz_offset_from_string _UNITS = r"decade|year|month|week|day|hour|minute|second" -PATTERN = re.compile(r"([+-]?\d+[.,]?\d*)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) +PATTERN = re.compile(r"([+-]?\s*\d+[.,]?\d*)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) class FreshnessDateDataParser: @@ -161,7 +161,7 @@ def get_kwargs(self, date_string): for num, unit in m: has_explicit_sign = num.startswith("+") or num.startswith("-") explicit_signs[unit + "s"] = has_explicit_sign - kwargs[unit + "s"] = float(num.replace(",", ".")) + kwargs[unit + "s"] = float(num.replace(",", ".").replace(" ", "")) if "decades" in kwargs: kwargs["years"] = 10 * kwargs["decades"] + kwargs.get("years", 0) diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 5f790dc66..ad73de63c 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -116,6 +116,11 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) period="day", ), param("just now", ago={"seconds": 0}, period="day"), + # now - offset with explicit spaced '-' operator + param("now - 1hour", ago={"hours": 1}, period="day"), + param("now - 2 hours", ago={"hours": 2}, period="day"), + param("now - 30 minutes", ago={"minutes": 30}, period="day"), + param("now - 1 day", ago={"days": 1}, period="day"), # Fix for #291, work till one to twelve only param("nine hours ago", ago={"hours": 9}, period="day"), param("three week ago", ago={"weeks": 3}, period="week"), @@ -1824,6 +1829,11 @@ def test_normalized_relative_dates(self, date_string, ago, period): in_future={"years": 1, "months": 2}, period="month", ), + # now + offset with explicit spaced '+' operator + param("now + 1hour", in_future={"hours": 1}, period="day"), + param("now + 2 hours", in_future={"hours": 2}, period="day"), + param("now + 30 minutes", in_future={"minutes": 30}, period="day"), + param("now + 1 day", in_future={"days": 1}, period="day"), # Fractional units param("in 2.5 hours", in_future={"hours": 2.5}, period="day"), param("in 10.75 minutes", in_future={"minutes": 10.75}, period="day"), From 85af00e90f27aaffee57ffb525be888ad79040f7 Mon Sep 17 00:00:00 2001 From: Tine <119507611+tine1117@users.noreply.github.com> Date: Mon, 1 Jun 2026 15:09:35 +0900 Subject: [PATCH 025/107] Document region usage and stabilize current-month parsing (#1332) * Document region usage for supported locales * Use parser-relative month for incomplete dates --- dateparser/parser.py | 7 +------ docs/supported_locales.rst | 6 ++++++ tests/test_date_parser.py | 17 +++++++++++++++++ 3 files changed, 24 insertions(+), 6 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 67a586e9b..f123ab33a 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -598,16 +598,11 @@ def _correct_for_day(self, dateobj): return dateobj def _correct_for_month(self, dateobj): - relative_base = getattr(self.settings, "RELATIVE_BASE", None) - relative_base_month = ( - relative_base.month if hasattr(relative_base, "month") else relative_base - ) - if getattr(self, "_token_month", None): return dateobj dateobj = set_correct_month_from_settings( - dateobj, self.settings, relative_base_month + dateobj, self.settings, current_month=self.now.month ) return dateobj diff --git a/docs/supported_locales.rst b/docs/supported_locales.rst index 9b48b5ed5..49b8503cf 100644 --- a/docs/supported_locales.rst +++ b/docs/supported_locales.rst @@ -3,6 +3,12 @@ Supported languages and locales =============================== +The ``region`` argument accepts the region subtag from one of the locale +codes listed below. For example, ``languages=['en'], region='IN'`` uses the +``en-IN`` locale, while ``languages=['fr'], region='CA'`` uses ``fr-CA``. +If you already know the full locale code, pass it directly through +``locales=['en-IN']`` instead. + ============ ================================================================ Language Locales ============ ================================================================ diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 212e0220d..87a5a871c 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1346,6 +1346,23 @@ def test_dates_with_no_day_or_month( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) + def test_dates_with_no_day_or_month_use_same_current_date_for_month_and_day(self): + class ParserDateTime(datetime): + @classmethod + def now(cls, tz=None): + return datetime(2026, 5, 31, 12, 0, tzinfo=tz) + + class UtilsDateTime(datetime): + @classmethod + def now(cls, tz=None): + return datetime(2026, 6, 1, 12, 0, tzinfo=tz) + + with ( + patch("dateparser.parser.datetime", ParserDateTime), + patch("dateparser.utils.datetime", UtilsDateTime), + ): + self.assertEqual(parse("2014"), datetime(2014, 5, 31)) + @parameterized.expand( [ param( From 24bfa9e008c8172c31790c195edffa0d5fb9d908 Mon Sep 17 00:00:00 2001 From: Kill1ngPig <12312601@mail.sustech.edu.cn> Date: Mon, 1 Jun 2026 14:19:19 +0800 Subject: [PATCH 026/107] Fix search_dates language fallback (#1331) * Fix search_dates language fallback * Apply ruff formatting --- dateparser/search/search.py | 33 +++++++++++++++++++++++++++++---- tests/test_search.py | 6 ++++++ 2 files changed, 35 insertions(+), 4 deletions(-) diff --git a/dateparser/search/search.py b/dateparser/search/search.py index 3d38d2792..6d39c7570 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -218,6 +218,21 @@ def __init__(self): self.available_language_map = self.loader.get_locale_map() self.search = _ExactLanguageSearch(self.loader) + def _get_candidate_languages(self, detected_language, languages): + candidates = [] + if detected_language: + candidates.append(detected_language) + + if isinstance(languages, (list, tuple, Set)) and len(languages) > 1: + candidates.extend(languages) + + seen = set() + return [ + language + for language in candidates + if not (language in seen or seen.add(language)) + ] + @apply_settings def detect_language( self, text, languages, settings=None, detect_languages_function=None @@ -304,13 +319,23 @@ def search_dates( settings=settings, detect_languages_function=detect_languages_function, ) - if not language_shortname: + + candidate_languages = self._get_candidate_languages( + language_shortname, languages + ) + if not candidate_languages: return {"Language": None, "Dates": None} + + for candidate_language in candidate_languages: + dates = self.search.search_parse( + candidate_language, text, settings=settings + ) + if dates: + return {"Language": candidate_language, "Dates": dates} + return { "Language": language_shortname, - "Dates": self.search.search_parse( - language_shortname, text, settings=settings - ), + "Dates": [], } def preprocess_text(self, text, languages): diff --git a/tests/test_search.py b/tests/test_search.py index 47e380cf7..eea9360f0 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1020,6 +1020,12 @@ def test_detection(self, shortname, text): settings={"STRICT_PARSING": True}, expected=None, ), + param( + text="Date de facture 23 juillet 2020 Condition Redevable livraison FR", + languages=["en", "fr", "es", "pt", "de", "it", "ar"], + settings={"STRICT_PARSING": True}, + expected=[("23 juillet 2020", datetime.datetime(2020, 7, 23, 0, 0))], + ), param(text="a Americ", languages=None, settings=None, expected=None), # Date with comma and apostrophe param( From b903e69c3de74a0569a58c35106554ef5d99ef96 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 4 Jun 2026 14:37:17 +0200 Subject: [PATCH 027/107] fix: Parse 1mon ago (#1329) --- dateparser/data/date_translation_data/en.py | 3 +++ .../date_translation_data/en.yaml | 1 + dateparser_scripts/write_complete_data.py | 20 +++++++++++++++++++ tests/test_freshness_date_parser.py | 10 +++++++--- 4 files changed, 31 insertions(+), 3 deletions(-) diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index f348598f8..39241c07c 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -800,6 +800,9 @@ "after" ], "simplifications": [ + { + "(\\d+[.,]?\\d*)\\s*mons?\\b": "\\1 month" + }, { "an": "1" }, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index ac07a0ef2..a4e9a1ad8 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -82,6 +82,7 @@ relative-type-regex: - (\d+[.,]?\d*) decades? ago simplifications: + - (\d+[.,]?\d*)\s*mons?\b: \1 month - an: '1' - a: '1' - (?:12\s+)?noon: '12:00' diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index 903b8f383..bb82d3fd9 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -28,6 +28,25 @@ RELATIVE_PATTERN = re.compile(r"\{0\}") +def _to_plain_types(obj): + """Recursively convert ruamel.yaml CommentedMap/CommentedSeq to plain + OrderedDict/list so that json.dumps produces stable output across all + Python versions. + + Python 3.14 changed the json C encoder to bypass the Python-level + ``__iter__``/``items()`` of dict subclasses and access the underlying C + dict directly. ruamel.yaml's CommentedMap relies on its Python-level + iteration for correct key ordering, so the C shortcut produces a + different (non-deterministic) key order on 3.14. Converting to plain + types before serialisation avoids the issue entirely. + """ + if isinstance(obj, dict): + return OrderedDict((k, _to_plain_types(v)) for k, v in obj.items()) + elif isinstance(obj, list): + return [_to_plain_types(v) for v in obj] + return obj + + def _modify_relative_data(relative_data): modified_relative_data = OrderedDict() for key, value in relative_data.items(): @@ -95,6 +114,7 @@ def write_complete_data(in_memory=False): for language in all_languages: date_translation_data = _get_complete_date_translation_data(language) date_translation_data = combine_dicts(date_translation_data, base_data) + date_translation_data = _to_plain_types(date_translation_data) _modify_data(date_translation_data) translation_data = json.dumps( date_translation_data, indent=4, separators=(",", ": "), ensure_ascii=False diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index ad73de63c..34dc6a634 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -2374,15 +2374,19 @@ def test_dates_not_supported_by_date_time(self, date_string): @parameterized.expand( [ - param("1mon ago"), # 1116 + param("1mon ago", ago={"months": 1}, period="month"), # 1123 + param("2mon ago", ago={"months": 2}, period="month"), # 1123 + param("3mons ago", ago={"months": 3}, period="month"), # 1123 ] ) - def test_known_issues(self, date_string): + def test_known_issues(self, date_string, ago, period): self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() self.then_error_was_not_raised() - self.assertEqual(None, self.result["date_obj"]) + self.then_date_was_parsed_by_freshness_parser() + self.then_date_obj_is_exactly_this_time_ago(ago) + self.then_period_is(period) @parameterized.expand( [ From b107ac3942bf1b33189b0bec34fb26ccc6d57b43 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 4 Jun 2026 14:46:06 +0200 Subject: [PATCH 028/107] Replace internal OrderedDict usage with dict (#1328) --- dateparser/calendars/jalali_parser.py | 55 +++++++++++------------ dateparser/languages/loader.py | 4 +- dateparser/languages/locale.py | 3 +- dateparser/parser.py | 19 ++++---- dateparser_scripts/get_cldr_data.py | 21 +++++---- dateparser_scripts/order_languages.py | 3 +- dateparser_scripts/utils.py | 5 +-- dateparser_scripts/write_complete_data.py | 7 ++- tests/test_date.py | 22 ++++----- 9 files changed, 61 insertions(+), 78 deletions(-) diff --git a/dateparser/calendars/jalali_parser.py b/dateparser/calendars/jalali_parser.py index ef437d5fb..602493ce4 100644 --- a/dateparser/calendars/jalali_parser.py +++ b/dateparser/calendars/jalali_parser.py @@ -1,5 +1,4 @@ import re -from collections import OrderedDict from functools import reduce from convertdate import persian @@ -40,35 +39,31 @@ class jalali_parser(non_gregorian_parser): "۹": 9, } - _months = OrderedDict( - [ - # pinglish : (persian literals, month index, number of days) - ("Farvardin", (1, 31, ["فروردین"])), - ("Ordibehesht", (2, 31, ["اردیبهشت"])), - ("Khordad", (3, 31, ["خرداد"])), - ("Tir", (4, 31, ["تیر"])), - ("Mordad", (5, 31, ["امرداد", "مرداد"])), - ("Shahrivar", (6, 31, ["شهریور", "شهريور"])), - ("Mehr", (7, 30, ["مهر"])), - ("Aban", (8, 30, ["آبان"])), - ("Azar", (9, 30, ["آذر"])), - ("Dey", (10, 30, ["دی"])), - ("Bahman", (11, 30, ["بهمن", "بهن"])), - ("Esfand", (12, 29, ["اسفند"])), - ] - ) - - _weekdays = OrderedDict( - [ - ("Sunday", ["یکشنبه"]), - ("Monday", ["دوشنبه"]), - ("Tuesday", ["سهشنبه", "سه شنبه"]), - ("Wednesday", ["چهارشنبه", "چهار شنبه"]), - ("Thursday", ["پنجشنبه", "پنج شنبه"]), - ("Friday", ["جمعه"]), - ("Saturday", ["روز شنبه", "شنبه"]), - ] - ) + _months = { + # pinglish : (persian literals, month index, number of days) + "Farvardin": (1, 31, ["فروردین"]), + "Ordibehesht": (2, 31, ["اردیبهشت"]), + "Khordad": (3, 31, ["خرداد"]), + "Tir": (4, 31, ["تیر"]), + "Mordad": (5, 31, ["امرداد", "مرداد"]), + "Shahrivar": (6, 31, ["شهریور", "شهريور"]), + "Mehr": (7, 30, ["مهر"]), + "Aban": (8, 30, ["آبان"]), + "Azar": (9, 30, ["آذر"]), + "Dey": (10, 30, ["دی"]), + "Bahman": (11, 30, ["بهمن", "بهن"]), + "Esfand": (12, 29, ["اسفند"]), + } + + _weekdays = { + "Sunday": ["یکشنبه"], + "Monday": ["دوشنبه"], + "Tuesday": ["سهشنبه", "سه شنبه"], + "Wednesday": ["چهارشنبه", "چهار شنبه"], + "Thursday": ["پنجشنبه", "پنج شنبه"], + "Friday": ["جمعه"], + "Saturday": ["روز شنبه", "شنبه"], + } _number_letters = { 0: ["صفر"], diff --git a/dateparser/languages/loader.py b/dateparser/languages/loader.py index 023e02eaa..e6d5225f2 100644 --- a/dateparser/languages/loader.py +++ b/dateparser/languages/loader.py @@ -158,7 +158,7 @@ def _load_data( use_given_order=False, allow_conflicting_locales=False, ): - locale_dict = OrderedDict() + locale_dict = {} if locales: invalid_locales = [] for locale in locales: @@ -198,7 +198,7 @@ def _load_data( ) if not use_given_order: - locale_dict = OrderedDict( + locale_dict = dict( sorted(locale_dict.items(), key=lambda x: language_order.index(x[1][0])) ) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index bf33f4375..553a54609 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -1,4 +1,3 @@ -from collections import OrderedDict from itertools import chain import regex as re @@ -226,7 +225,7 @@ def _get_relative_translations(self, settings=None): def _generate_relative_translations(self, normalize=False): relative_translations = self.info.get("relative-type-regex", {}) - relative_dictionary = OrderedDict() + relative_dictionary = {} for key, value in relative_translations.items(): if normalize: value = list(map(normalize_unicode, value)) diff --git a/dateparser/parser.py b/dateparser/parser.py index f123ab33a..54bde2ceb 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -1,5 +1,4 @@ import calendar -from collections import OrderedDict from datetime import datetime, timedelta, timezone from io import StringIO @@ -239,12 +238,10 @@ def _check_strict_parsing(missing, settings): class _parser: - alpha_directives = OrderedDict( - [ - ("weekday", ["%A", "%a"]), - ("month", ["%B", "%b"]), - ] - ) + alpha_directives = { + "weekday": ["%A", "%a"], + "month": ["%B", "%b"], + } num_directives = { "month": ["%m"], @@ -273,10 +270,10 @@ def __init__(self, tokens, settings): self._token_year = None self._token_time = None - self.ordered_num_directives = OrderedDict( - (k, self.num_directives[k]) - for k in (resolve_date_order(settings.DATE_ORDER, lst=True)) - ) + self.ordered_num_directives = { + k: self.num_directives[k] + for k in resolve_date_order(settings.DATE_ORDER, lst=True) + } skip_index = [] skip_component = None diff --git a/dateparser_scripts/get_cldr_data.py b/dateparser_scripts/get_cldr_data.py index 6e227c819..2e5b77185 100644 --- a/dateparser_scripts/get_cldr_data.py +++ b/dateparser_scripts/get_cldr_data.py @@ -1,7 +1,6 @@ import json import os import shutil -from collections import OrderedDict import regex as re @@ -49,17 +48,17 @@ def _retrieve_locale_data(locale): ca_gregorian_file = cldr_dates_full_dir + locale + "/ca-gregorian.json" dateFields_file = cldr_dates_full_dir + locale + "/dateFields.json" with open(ca_gregorian_file) as f: - cldr_gregorian_data = json.load(f, object_pairs_hook=OrderedDict) + cldr_gregorian_data = json.load(f) with open(dateFields_file) as g: - cldr_datefields_data = json.load(g, object_pairs_hook=OrderedDict) + cldr_datefields_data = json.load(g) gregorian_dict = cldr_gregorian_data["main"][locale]["dates"]["calendars"][ "gregorian" ] date_fields_dict = cldr_datefields_data["main"][locale]["dates"]["fields"] - json_dict = OrderedDict() + json_dict = {} field_keys_1 = ["stand-alone", "format"] field_keys_2 = [ @@ -292,7 +291,7 @@ def _retrieve_locale_data(locale): json_dict["second"] = [date_fields_dict[key]["displayName"] for key in second_keys] - json_dict["relative-type"] = OrderedDict() + json_dict["relative-type"] = {} json_dict["relative-type"]["1 year ago"] = [ date_fields_dict[key]["relative-type--1"] for key in year_keys @@ -354,7 +353,7 @@ def _retrieve_locale_data(locale): date_fields_dict[key]["relative-type-0"] for key in second_keys ] - json_dict["relative-type-regex"] = OrderedDict() + json_dict["relative-type-regex"] = {} json_dict["relative-type-regex"]["in \\1 year"] = list( filter( @@ -524,11 +523,11 @@ def _clean_dict(json_dict): """Remove duplicates and sort""" for key, value in json_dict.items(): if isinstance(value, list): - json_dict[key] = sorted(OrderedDict.fromkeys(map(_clean_string, value))) + json_dict[key] = sorted(dict.fromkeys(map(_clean_string, value))) elif isinstance(value, dict): - json_dict[key] = OrderedDict(sorted(value.items())) + json_dict[key] = dict(sorted(value.items())) json_dict[key] = _clean_dict(json_dict[key]) - return OrderedDict(filter(lambda x: x[1], json_dict.items())) + return dict(filter(lambda x: x[1], json_dict.items())) def main(): @@ -544,14 +543,14 @@ def main(): for language in language_locale_dict: json_language_dict = _clean_dict(_retrieve_locale_data(language)) - locale_specific_dict = OrderedDict() + locale_specific_dict = {} locales_list = language_locale_dict[language] for locale in locales_list: json_locale_dict = _clean_dict(_retrieve_locale_data(locale)) locale_specific_dict[locale] = _clean_dict( get_dict_difference(json_language_dict, json_locale_dict) ) - json_language_dict["locale_specific"] = OrderedDict( + json_language_dict["locale_specific"] = dict( sorted(locale_specific_dict.items()) ) filename = directory + language + ".json" diff --git a/dateparser_scripts/order_languages.py b/dateparser_scripts/order_languages.py index 39fa6affe..bdf67d7a7 100644 --- a/dateparser_scripts/order_languages.py +++ b/dateparser_scripts/order_languages.py @@ -1,6 +1,5 @@ import json import os -from collections import OrderedDict import regex as re import requests @@ -186,7 +185,7 @@ def main(): language_order, separators=(",", ": "), indent=4 ) - complete_language_locale_dict = OrderedDict() + complete_language_locale_dict = {} for key in language_order: if key in language_locale_dict.keys(): complete_language_locale_dict[key] = sorted(language_locale_dict[key]) diff --git a/dateparser_scripts/utils.py b/dateparser_scripts/utils.py index a8ba6d1c5..feae9fb3a 100644 --- a/dateparser_scripts/utils.py +++ b/dateparser_scripts/utils.py @@ -1,6 +1,5 @@ import os import shutil -from collections import OrderedDict from git import Repo @@ -36,7 +35,7 @@ def get_raw_data(): def get_dict_difference(parent_dict, child_dict): - difference_dict = OrderedDict() + difference_dict = {} for key, child_value in child_dict.items(): parent_value = parent_dict.get(key) child_specific_value = None @@ -54,7 +53,7 @@ def get_dict_difference(parent_dict, child_dict): def combine_dicts(primary_dict, supplementary_dict): - combined_dict = OrderedDict() + combined_dict = {} for key, value in primary_dict.items(): if key in supplementary_dict: if isinstance(value, list): diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index bb82d3fd9..5bb015f5e 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -1,7 +1,6 @@ import json import os import shutil -from collections import OrderedDict import regex as re from ruamel.yaml import YAML @@ -48,7 +47,7 @@ def _to_plain_types(obj): def _modify_relative_data(relative_data): - modified_relative_data = OrderedDict() + modified_relative_data = {} for key, value in relative_data.items(): for i, string in enumerate(value): string = RELATIVE_PATTERN.sub(r"(\\d+[.,]?\\d*)", string) @@ -71,11 +70,11 @@ def _get_complete_date_translation_data(language): supplementary_data = {} if language in cldr_languages: with open(cldr_date_directory + language + ".json") as f: - cldr_data = json.load(f, object_pairs_hook=OrderedDict) + cldr_data = json.load(f) if language in supplementary_languages: with open(supplementary_date_directory + language + ".yaml") as g: yaml = YAML() - supplementary_data = OrderedDict(yaml.load(g)) + supplementary_data = dict(yaml.load(g)) complete_data = combine_dicts(cldr_data, supplementary_data) if "name" not in complete_data: complete_data["name"] = language diff --git a/tests/test_date.py b/tests/test_date.py index 249919ae4..7c8759b89 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -3,7 +3,6 @@ import datetime as real_datetime import os import unittest -from collections import OrderedDict from datetime import datetime, timedelta from datetime import timezone as dttz from itertools import product @@ -615,18 +614,15 @@ def test_temporal_nouns_are_parsed(self, date_string, days_ago): self.then_date_is_n_days_ago(days=days_ago) def test_should_not_assume_language_too_early(self): - dates_to_parse = OrderedDict( - [ - ("07/07/2014", datetime(2014, 7, 7).date()), # any language - ("07.jul.2014 | 12:52", datetime(2014, 7, 7).date()), # en, es, pt, nl - ("07.ago.2014 | 12:52", datetime(2014, 8, 7).date()), # es, it, pt - ( - "07.feb.2014 | 12:52", - datetime(2014, 2, 7).date(), - ), # en, de, es, it, nl, ro - ("07.ene.2014 | 12:52", datetime(2014, 1, 7).date()), - ] - ) # es + dates_to_parse = { + "07/07/2014": datetime(2014, 7, 7).date(), # any language + "07.jul.2014 | 12:52": datetime(2014, 7, 7).date(), # en, es, pt, nl + "07.ago.2014 | 12:52": datetime(2014, 8, 7).date(), # es, it, pt + "07.feb.2014 | 12:52": datetime( + 2014, 2, 7 + ).date(), # en, de, es, it, nl, ro + "07.ene.2014 | 12:52": datetime(2014, 1, 7).date(), # es + } self.given_parser( restrict_to_languages=["en", "de", "fr", "it", "pt", "nl", "ro", "es", "ru"] From 5c437a12f8ba402754835f122451eb73431e66c9 Mon Sep 17 00:00:00 2001 From: Laurie O Date: Fri, 5 Jun 2026 00:21:50 +1000 Subject: [PATCH 029/107] Move project metadata and configuration to 'pyproject.toml' (#1311) --- README.rst | 217 +++++++++++++++++++++++++++++++-- docs/index.rst | 37 +----- docs/introduction.rst | 275 ------------------------------------------ pyproject.toml | 62 +++++++++- setup.py | 57 +-------- 5 files changed, 277 insertions(+), 371 deletions(-) delete mode 100644 docs/introduction.rst diff --git a/README.rst b/README.rst index 51a3ad7f1..aca3a0fd5 100644 --- a/README.rst +++ b/README.rst @@ -52,11 +52,10 @@ Key Features - Customizable behavior through `settings `__. - Support for `non-Gregorian calendar - systems `__. + systems <#supported-calendars>`__. - Support for dates with timezones abbreviations or UTC offsets (``"August 14, 2015 EST"``, ``"21 July 2013 10:15 pm +0500"``...) -- `Search - dates `__ +- `Search dates <#search-for-dates-in-longer-chunks-of-text>`__ in longer texts. - Time span detection for expressions like "past month", "last week". @@ -94,8 +93,7 @@ functionality of the module. >>> dateparser.parse('January 12, 2012 10:00 PM EST') datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) -As you can see, **dateparser** works with different date formats, but it -can also be used directly with strings in different languages: +**dateparser** also works with strings in different languages: .. code:: python @@ -117,6 +115,168 @@ can also be used directly with strings in different languages: >>> dateparser.parse('2小时前') # Chinese (2 hours ago), current time: 22:30 datetime.datetime(2018, 5, 31, 20, 30) +You can specify the language(s), if known, using the ``languages`` argument. +In this case, given languages are used and language detection is skipped: + +.. code:: python + + >>> dateparser.parse('2015, Ago 15, 1:08 pm', languages=['pt', 'es']) + datetime.datetime(2015, 8, 15, 13, 8) + +If you know the possible formats of the dates, you can use the +``date_formats`` argument: + +.. code:: python + + >>> dateparser.parse('22 Décembre 2010', date_formats=['%d %B %Y']) + datetime.datetime(2010, 12, 22, 0, 0) + +Relative Dates +^^^^^^^^^^^^^^ + +.. code:: python + + >>> from dateparser import parse + >>> parse('1 hour ago') + datetime.datetime(2015, 5, 31, 23, 0) + >>> parse('Il ya 2 heures') # French (2 hours ago) + datetime.datetime(2015, 5, 31, 22, 0) + >>> parse('1 anno 2 mesi') # Italian (1 year 2 months) + datetime.datetime(2014, 4, 1, 0, 0) + >>> parse('yaklaşık 23 saat önce') # Turkish (23 hours ago) + datetime.datetime(2015, 5, 31, 1, 0) + >>> parse('Hace una semana') # Spanish (a week ago) + datetime.datetime(2015, 5, 25, 0, 0) + >>> parse('2小时前') # Chinese (2 hours ago) + datetime.datetime(2015, 5, 31, 22, 0) + +.. note:: Testing above code might return different values depending on your environment's current date and time. + +.. note:: For the ``Finnish`` language, please specify ``settings={'SKIP_TOKENS': []}`` to correctly parse relative dates. + +Date Order +^^^^^^^^^^ + +.. code:: python + + >>> # parsing ambiguous date + >>> parse('02-03-2016') # assumes english language, uses MDY date order + datetime.datetime(2016, 2, 3, 0, 0) + >>> parse('le 02-03-2016') # detects french, uses DMY date order + datetime.datetime(2016, 3, 2, 0, 0) + +.. note:: Ordering is not locale-based — do not expect ``DMY`` order for UK/Australia English. + You can specify date order explicitly: + + .. code:: python + + >>> parse('18-12-15 06:00', settings={'DATE_ORDER': 'DMY'}) + datetime.datetime(2015, 12, 18, 6, 0) + +For more on date order, see the `settings documentation `__. + +Timezone and UTC Offset +^^^^^^^^^^^^^^^^^^^^^^^ + +By default, `dateparser` returns a timezone-aware ``datetime`` if a timezone is +present in the date string. Otherwise it returns a naive ``datetime`` object. + +.. code:: python + + >>> parse('January 12, 2012 10:00 PM EST') + datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) + + >>> parse('January 12, 2012 10:00 PM -0500') + datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) + + >>> parse('2 hours ago EST') + datetime.datetime(2017, 3, 10, 15, 55, 39, 579667, tzinfo=) + +If the date has no timezone name/abbreviation or offset, you can specify it +using the ``TIMEZONE`` setting: + +.. code:: python + + >>> parse('January 12, 2012 10:00 PM', settings={'TIMEZONE': 'US/Eastern'}) + datetime.datetime(2012, 1, 12, 22, 0) + + >>> parse('January 12, 2012 10:00 PM', settings={'TIMEZONE': 'US/Eastern', 'RETURN_AS_TIMEZONE_AWARE': True}) + datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) + + >>> parse('10:00 am', settings={'TIMEZONE': 'EST', 'TO_TIMEZONE': 'EDT'}) + datetime.datetime(2016, 9, 25, 11, 0) + + >>> parse('10:00 am EST', settings={'TO_TIMEZONE': 'EDT'}) + datetime.datetime(2017, 3, 12, 11, 0, tzinfo=) + +For more on timezones, see the `settings documentation `__. + +Incomplete Dates +^^^^^^^^^^^^^^^^ + +.. code:: python + + >>> from dateparser import parse + >>> parse('December 2015') # default behavior + datetime.datetime(2015, 12, 16, 0, 0) + >>> parse('December 2015', settings={'PREFER_DAY_OF_MONTH': 'last'}) + datetime.datetime(2015, 12, 31, 0, 0) + >>> parse('December 2015', settings={'PREFER_DAY_OF_MONTH': 'first'}) + datetime.datetime(2015, 12, 1, 0, 0) + + >>> parse('March') + datetime.datetime(2015, 3, 16, 0, 0) + >>> parse('March', settings={'PREFER_DATES_FROM': 'future'}) + datetime.datetime(2016, 3, 16, 0, 0) + + >>> import dateparser + >>> dateparser.parse("2015") # default behavior + datetime.datetime(2015, 3, 27, 0, 0) + >>> dateparser.parse("2015", settings={"PREFER_MONTH_OF_YEAR": "last"}) + datetime.datetime(2015, 12, 27, 0, 0) + >>> dateparser.parse("2015", settings={"PREFER_MONTH_OF_YEAR": "current"}) + datetime.datetime(2015, 3, 27, 0, 0) + +You can also ignore incomplete dates by setting the ``STRICT_PARSING`` flag: + +.. code:: python + + >>> parse('December 2015', settings={'STRICT_PARSING': True}) + None + +For more on handling incomplete dates, see the `settings documentation `__. + +Search for Dates in Longer Chunks of Text +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +.. warning:: Support for date searching is limited and needs improvement. + Contributions are welcome — see `contributing `__. + +You can extract dates from longer strings of text. Results are returned as a +list of ``(substring, datetime)`` tuples: + +.. code:: python + + >>> from dateparser.search import search_dates + >>> search_dates('Today is 25 of October 2017, so the 27th is in 2 days.') + [('25 of October 2017', datetime.datetime(2017, 10, 25, 0, 0)), ('the 27th is in 2 days', datetime.datetime(2017, 10, 27, 0, 0))] + +Time Span Detection +^^^^^^^^^^^^^^^^^^^ + +The ``search_dates`` function can also detect time spans such as +"past month" or "last week". When ``RETURN_TIME_SPAN`` is enabled it +returns start and end dates for the detected period: + +.. code:: python + + >>> search_dates("Messages from the past month", settings={'RETURN_TIME_SPAN': True}) + [('past month (start)', datetime.datetime(2024, 11, 7, 0, 0)), + ('past month (end)', datetime.datetime(2024, 12, 7, 23, 59, 59, 999999))] + +Settings +^^^^^^^^ + You can control multiple behaviors by using the ``settings`` parameter: .. code:: python @@ -133,9 +293,8 @@ You can control multiple behaviors by using the ``settings`` parameter: >>> dateparser.parse('tomorrow', settings={'RELATIVE_BASE': datetime.datetime(1992, 1, 1)}) datetime.datetime(1992, 1, 2, 0, 0) -To see more examples on how to use the ``settings``, check the `settings -section `__ -in the docs. +To see all available settings, check the `settings +documentation `__. False positives ^^^^^^^^^^^^^^^ @@ -170,6 +329,48 @@ If you want to use the jalali or hijri calendar, you need to install the $ pip install dateparser[calendars] +Supported Calendars +------------------- + +Apart from the Gregorian calendar, `dateparser` supports the +`Persian Jalali calendar` and the `Hijri/Islamic calendar`. +To use them, install the ``calendars`` extra (see `Installation`_). + +Example using the `Persian Jalali calendar +`_: + +.. code:: python + + >>> from dateparser.calendars.jalali import JalaliCalendar + >>> JalaliCalendar('جمعه سی ام اسفند ۱۳۸۷').get_date() + DateData(date_obj=datetime.datetime(2009, 3, 20, 0, 0), period='day', locale=None) + +Example using the `Hijri/Islamic calendar +`_: + +.. code:: python + + >>> from dateparser.calendars.hijri import HijriCalendar + >>> HijriCalendar('17-01-1437 هـ 08:30 مساءً').get_date() + DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None) + +Dependencies +------------ + +`dateparser` relies on the following libraries: + +* dateutil_'s module ``relativedelta`` for its freshness parser. +* convertdate_ to convert *Jalali* dates to *Gregorian*. +* hijridate_ to convert *Hijri* dates to *Gregorian*. +* tzlocal_ to reliably get local timezone. +* ruamel.yaml_ (optional) for operations on language files. + +.. _dateutil: https://pypi.python.org/pypi/python-dateutil +.. _convertdate: https://pypi.python.org/pypi/convertdate +.. _hijridate: https://pypi.python.org/pypi/hijridate +.. _tzlocal: https://pypi.python.org/pypi/tzlocal +.. _ruamel.yaml: https://pypi.python.org/pypi/ruamel.yaml + Common use cases ---------------- diff --git a/docs/index.rst b/docs/index.rst index 0159b6adc..54c646594 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,42 +2,10 @@ dateparser -- python parser for human readable dates ==================================================== -.. image:: https://img.shields.io/pypi/dm/dateparser - :target: https://pypi.python.org/pypi/dateparser - :alt: pypi downloads - -.. image:: https://img.shields.io/pypi/v/dateparser.svg - :target: https://pypi.python.org/pypi/dateparser - :alt: pypi version - -.. image:: https://codecov.io/gh/scrapinghub/dateparser/branch/master/graph/badge.svg - :target: https://codecov.io/gh/scrapinghub/dateparser - :alt: Code Coverage - -.. image:: https://github.com/scrapinghub/dateparser/workflows/Build/badge.svg - :target: https://github.com/scrapinghub/dateparser/actions - :alt: Github Build - -.. image:: https://readthedocs.org/projects/dateparser/badge/?version=latest - :target: http://dateparser.readthedocs.org/en/latest/?badge=latest - :alt: Documentation Status - - -`dateparser` provides modules to easily parse localized dates in almost -any string formats commonly found on web pages. - - -Documentation -============= - -This documentation is built automatically and can be found on -`Read the Docs `_. - - -.. include:: introduction.rst +.. include:: ../README.rst Indices and tables -================== +------------------ Contents: @@ -45,7 +13,6 @@ Contents: .. toctree:: :maxdepth: 2 - introduction installation usage settings diff --git a/docs/introduction.rst b/docs/introduction.rst deleted file mode 100644 index bc3445f8d..000000000 --- a/docs/introduction.rst +++ /dev/null @@ -1,275 +0,0 @@ -========================== -Introduction to dateparser -========================== - - -Features -======== - -* Generic parsing of dates in over 200 language locales plus numerous formats in a language agnostic fashion. -* Generic parsing of relative dates like: ``'1 min ago'``, ``'2 weeks ago'``, ``'3 months, 1 week and 1 day ago'``, ``'in 2 days'``, ``'tomorrow'``. -* Generic parsing of dates with time zones abbreviations or UTC offsets like: ``'August 14, 2015 EST'``, ``'July 4, 2013 PST'``, ``'21 July 2013 10:15 pm +0500'``. -* Date lookup in longer texts. -* Support for non-Gregorian calendar systems. See `Supported Calendars`_. -* Extensive test coverage. - - -Basic Usage -=========== - -The most straightforward way is to use the `dateparser.parse <#dateparser.parse>`_ function, -that wraps around most of the functionality in the module. - -.. automodule:: dateparser - :members: parse - :noindex: - - -Popular Formats ---------------- - - >>> import dateparser - >>> dateparser.parse('12/12/12') - datetime.datetime(2012, 12, 12, 0, 0) - >>> dateparser.parse('Fri, 12 Dec 2014 10:55:50') - datetime.datetime(2014, 12, 12, 10, 55, 50) - >>> dateparser.parse('Martes 21 de Octubre de 2014') # Spanish (Tuesday 21 October 2014) - datetime.datetime(2014, 10, 21, 0, 0) - >>> dateparser.parse('Le 11 Décembre 2014 à 09:00') # French (11 December 2014 at 09:00) - datetime.datetime(2014, 12, 11, 9, 0) - >>> dateparser.parse('13 января 2015 г. в 13:34') # Russian (13 January 2015 at 13:34) - datetime.datetime(2015, 1, 13, 13, 34) - >>> dateparser.parse('1 เดือนตุลาคม 2005, 1:00 AM') # Thai (1 October 2005, 1:00 AM) - datetime.datetime(2005, 10, 1, 1, 0) - -This will try to parse a date from the given string, attempting to -detect the language each time. - -You can specify the language(s), if known, using ``languages`` argument. In this case, given languages are used and language detection is skipped: - - >>> dateparser.parse('2015, Ago 15, 1:08 pm', languages=['pt', 'es']) - datetime.datetime(2015, 8, 15, 13, 8) - -If you know the possible formats of the dates, you can -use the ``date_formats`` argument: - - >>> dateparser.parse('22 Décembre 2010', date_formats=['%d %B %Y']) - datetime.datetime(2010, 12, 22, 0, 0) - - -Relative Dates --------------- - - >>> parse('1 hour ago') - datetime.datetime(2015, 5, 31, 23, 0) - >>> parse('Il ya 2 heures') # French (2 hours ago) - datetime.datetime(2015, 5, 31, 22, 0) - >>> parse('1 anno 2 mesi') # Italian (1 year 2 months) - datetime.datetime(2014, 4, 1, 0, 0) - >>> parse('yaklaşık 23 saat önce') # Turkish (23 hours ago) - datetime.datetime(2015, 5, 31, 1, 0) - >>> parse('Hace una semana') # Spanish (a week ago) - datetime.datetime(2015, 5, 25, 0, 0) - >>> parse('2小时前') # Chinese (2 hours ago) - datetime.datetime(2015, 5, 31, 22, 0) - -.. note:: Testing above code might return different values for you depending on your environment's current date and time. - -.. note:: For `Finnish` language, please specify ``settings={'SKIP_TOKENS': []}`` to correctly parse relative dates. - -OOTB Language Based Date Order Preference ------------------------------------------ - - >>> # parsing ambiguous date - >>> parse('02-03-2016') # assumes english language, uses MDY date order - datetime.datetime(2016, 2, 3, 0, 0) - >>> parse('le 02-03-2016') # detects french, uses DMY date order - datetime.datetime(2016, 3, 2, 0, 0) - -.. note:: Ordering is not locale based, that's why do not expect `DMY` order for UK/Australia English. You can specify date order in that case as follows using :ref:`settings`: - - >>> parse('18-12-15 06:00', settings={'DATE_ORDER': 'DMY'}) - datetime.datetime(2015, 12, 18, 6, 0) - -For more on date order, please look at :ref:`settings`. - - -Timezone and UTC Offset ------------------------ - -By default, `dateparser` returns tzaware `datetime` if timezone is present in date string. Otherwise, it returns a naive `datetime` object. - - >>> parse('January 12, 2012 10:00 PM EST') - datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) - - >>> parse('January 12, 2012 10:00 PM -0500') - datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) - - >>> parse('2 hours ago EST') - datetime.datetime(2017, 3, 10, 15, 55, 39, 579667, tzinfo=) - - >>> parse('2 hours ago -0500') - datetime.datetime(2017, 3, 10, 15, 59, 30, 193431, tzinfo=) - - If date has no timezone name/abbreviation or offset, you can specify it using `TIMEZONE` setting. - - >>> parse('January 12, 2012 10:00 PM', settings={'TIMEZONE': 'US/Eastern'}) - datetime.datetime(2012, 1, 12, 22, 0) - - >>> parse('January 12, 2012 10:00 PM', settings={'TIMEZONE': '+0500'}) - datetime.datetime(2012, 1, 12, 22, 0) - -``TIMEZONE`` option may not be useful alone as it only attaches given timezone to -resultant ``datetime`` object. But can be useful in cases where you want conversions from and to different -timezones or when simply want a tzaware date with given timezone info attached. - - >>> parse('January 12, 2012 10:00 PM', settings={'TIMEZONE': 'US/Eastern', 'RETURN_AS_TIMEZONE_AWARE': True}) - datetime.datetime(2012, 1, 12, 22, 0, tzinfo=) - - - >>> parse('10:00 am', settings={'TIMEZONE': 'EST', 'TO_TIMEZONE': 'EDT'}) - datetime.datetime(2016, 9, 25, 11, 0) - -Some more use cases for conversion of timezones. - - >>> parse('10:00 am EST', settings={'TO_TIMEZONE': 'EDT'}) # date string has timezone info - datetime.datetime(2017, 3, 12, 11, 0, tzinfo=) - - >>> parse('now EST', settings={'TO_TIMEZONE': 'UTC'}) # relative dates - datetime.datetime(2017, 3, 10, 23, 24, 47, 371823, tzinfo=) - -In case, no timezone is present in date string or defined in :ref:`settings`. You can still -return tzaware ``datetime``. It is especially useful in case of relative dates when uncertain -what timezone is relative base. - - >>> parse('2 minutes ago', settings={'RETURN_AS_TIMEZONE_AWARE': True}) - datetime.datetime(2017, 3, 11, 4, 25, 24, 152670, tzinfo=) - -In case, you want to compute relative dates in UTC instead of default system's local timezone, you can use `TIMEZONE` setting. - - >>> parse('4 minutes ago', settings={'TIMEZONE': 'UTC'}) - datetime.datetime(2017, 3, 10, 23, 27, 59, 647248, tzinfo=) - -.. note:: In case, when timezone is present both in string and also specified using :ref:`settings`, string is parsed into tzaware representation and then converted to timezone specified in :ref:`settings`. - - >>> parse('10:40 pm PKT', settings={'TIMEZONE': 'UTC'}) - datetime.datetime(2017, 3, 12, 17, 40, tzinfo=) - - >>> parse('20 mins ago EST', settings={'TIMEZONE': 'UTC'}) - datetime.datetime(2017, 3, 12, 21, 16, 0, 885091, tzinfo=) - -For more on timezones, please look at :ref:`settings`. - - -Incomplete Dates ----------------- - - >>> from dateparser import parse - >>> parse('December 2015') # default behavior - datetime.datetime(2015, 12, 16, 0, 0) - >>> parse('December 2015', settings={'PREFER_DAY_OF_MONTH': 'last'}) - datetime.datetime(2015, 12, 31, 0, 0) - >>> parse('December 2015', settings={'PREFER_DAY_OF_MONTH': 'first'}) - datetime.datetime(2015, 12, 1, 0, 0) - - >>> parse('March') - datetime.datetime(2015, 3, 16, 0, 0) - >>> parse('March', settings={'PREFER_DATES_FROM': 'future'}) - datetime.datetime(2016, 3, 16, 0, 0) - >>> # parsing with preference set for 'past' - >>> parse('August', settings={'PREFER_DATES_FROM': 'past'}) - datetime.datetime(2015, 8, 15, 0, 0) - - >>> import dateparser - >>> dateparser.parse("2015") # default behavior - datetime.datetime(2015, 3, 27, 0, 0) - >>> dateparser.parse("2015", settings={"PREFER_MONTH_OF_YEAR": "last"}) - datetime.datetime(2015, 12, 27, 0, 0) - >>> dateparser.parse("2015", settings={"PREFER_MONTH_OF_YEAR": "first"}) - datetime.datetime(2015, 1, 27, 0, 0) - >>> dateparser.parse("2015", settings={"PREFER_MONTH_OF_YEAR": "current"}) - datetime.datetime(2015, 3, 27, 0, 0) - -You can also ignore parsing incomplete dates altogether by setting `STRICT_PARSING` flag as follows: - - >>> parse('December 2015', settings={'STRICT_PARSING': True}) - None - -For more on handling incomplete dates, please look at :ref:`settings`. - - -Search for Dates in Longer Chunks of Text ------------------------------------------ - -.. warning:: Support for searching dates is really limited and needs a lot of improvement, we look forward to community's contribution to get better on that part. See ":ref:`contributing`". - - -You can extract dates from longer strings of text. They are returned as list of tuples with text chunk containing the date and parsed datetime object. - - -.. automodule:: dateparser.search - :members: search_dates - :noindex: - -Time Span Detection -------------------- - -The `search_dates` function can detect time spans from expressions like "past month", "last week", etc. When `RETURN_TIME_SPAN` is enabled, it returns start and end dates for the detected period. - -.. code-block:: python - - >>> search_dates("Messages from the past month", settings={'RETURN_TIME_SPAN': True}) - [('past month (start)', datetime.datetime(2024, 11, 7, 0, 0)), - ('past month (end)', datetime.datetime(2024, 12, 7, 23, 59, 59, 999999))] - -Advanced Usage -============== -If you need more control over what is being parser check the :ref:`settings` section as well as the :ref:`using-datedataparser` section. - - -Dependencies -============ - -`dateparser` relies on following libraries in some ways: - - * dateutil_'s module ``relativedelta`` for its freshness parser. - * convertdate_ to convert *Jalali* dates to *Gregorian*. - * hijridate_ to convert *Hijri* dates to *Gregorian*. - * tzlocal_ to reliably get local timezone. - * ruamel.yaml_ (optional) for operations on language files. - -.. _dateutil: https://pypi.python.org/pypi/python-dateutil -.. _convertdate: https://pypi.python.org/pypi/convertdate -.. _hijridate: https://pypi.python.org/pypi/hijridate -.. _tzlocal: https://pypi.python.org/pypi/tzlocal -.. _ruamel.yaml: https://pypi.python.org/pypi/ruamel.yaml - -Supported languages and locales -=============================== -You can check the supported locales by visiting the ":ref:`supported-locales`" section. - - -Supported Calendars -=================== - -Apart from the Georgian calendar, `dateparser` supports the `Persian Jalali calendar` and the `Hijri/Islami calendar` - -To be able to use them you need to install the `calendar` extra by typing: - - pip install dateparser[calendars] - - -* Example using the `Persian Jalali calendar`. For more information, refer to `Persian Jalali Calendar `_. - - >>> from dateparser.calendars.jalali import JalaliCalendar - >>> JalaliCalendar('جمعه سی ام اسفند ۱۳۸۷').get_date() - DateData(date_obj=datetime.datetime(2009, 3, 20, 0, 0), period='day', locale=None) - - -* Example using the `Hijri/Islamic Calendar`. For more information, refer to `Hijri Calendar `_. - - >>> from dateparser.calendars.hijri import HijriCalendar - >>> HijriCalendar('17-01-1437 هـ 08:30 مساءً').get_date() - DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None) - -.. note:: `HijriCalendar` only works with Python ≥ 3.7. diff --git a/pyproject.toml b/pyproject.toml index f6650e0d4..c4e55aa5d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,8 +1,68 @@ +[build-system] +build-backend = "setuptools.build_meta" +requires = [ + "setuptools >= 77.0", +] + +[project] +name = "dateparser" +version = "1.4.0" +description = "Date parsing library designed to parse dates from HTML pages" +authors = [ + { name = "Scrapinghub", email = "opensource@zyte.com" }, +] +license = "BSD-3-Clause" +keywords = ["dateparser"] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Natural Language :: English", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: Implementation :: CPython", +] +requires-python = ">=3.10" +dynamic = ["readme"] + +dependencies = [ + "python-dateutil>=2.7.0", + "pytz>=2024.2", + "regex>=2024.9.11", + "tzlocal>=0.2", +] + +[project.optional-dependencies] +calendars = ["convertdate>=2.2.1", "hijridate"] +langdetect = ["langdetect>=1.0.0"] + +[project.urls] +Source = "https://github.com/scrapinghub/dateparser" +History = "https://dateparser.readthedocs.io/en/latest/history.html" + +[project.scripts] +dateparser-download = "dateparser_cli.cli:entrance" + +[tool.setuptools] +include-package-data = true +zip-safe = false + +[tool.setuptools.packages.find] +namespaces = false +exclude = ["tests", "tests.*"] + [tool.bumpversion] -current_version = "1.4.0" commit = true tag = true +[[tool.bumpversion.files]] +filename = "pyproject.toml" +search = 'version = "{current_version}"' +replace = 'version = "{new_version}"' + [[tool.bumpversion.files]] filename = "dateparser/__init__.py" diff --git a/setup.py b/setup.py index c46432f6b..eb2dfebe2 100644 --- a/setup.py +++ b/setup.py @@ -1,61 +1,14 @@ import re -from setuptools import find_packages, setup +from setuptools import setup -__version__ = re.search( - r"__version__.*\s*=\s*[\"]([^\"]+)[\"]", open("dateparser/__init__.py").read() -).group(1) - -introduction = re.sub( - r":members:.+|..\sautomodule::.+|:class:|:func:|:ref:", - "", - open("docs/introduction.rst", encoding="utf-8").read(), -) +readme = open("README.rst", encoding="utf-8").read() +# Remove `.. raw:: html` blocks, which are not supported by PyPI. +readme = re.sub(r"(?ms)^\.\. raw:: html\n(?:^[ \t].*\n|^[ \t]*\n)*", "", readme) history = re.sub( r":mod:|:class:|:func:", "", open("HISTORY.rst", encoding="utf-8").read() ) setup( - name="dateparser", - version=__version__, - description="Date parsing library designed to parse dates from HTML pages", - long_description=introduction + "\n\n" + history, - author="Scrapinghub", - author_email="opensource@zyte.com", - url="https://github.com/scrapinghub/dateparser", - project_urls={ - "History": "https://dateparser.readthedocs.io/en/latest/history.html", - }, - packages=find_packages(exclude=("tests", "tests.*")), - include_package_data=True, - install_requires=[ - "python-dateutil>=2.7.0", - "pytz>=2024.2", - "regex>=2024.9.11", - "tzlocal>=0.2", - ], - entry_points={ - "console_scripts": ["dateparser-download = dateparser_cli.cli:entrance"], - }, - extras_require={ - "calendars": ["convertdate>=2.2.1", "hijridate"], - "langdetect": ["langdetect>=1.0.0"], - }, - license="BSD", - zip_safe=False, - keywords="dateparser", - python_requires=">=3.10", - classifiers=[ - "Development Status :: 5 - Production/Stable", - "Intended Audience :: Developers", - "License :: OSI Approved :: BSD License", - "Natural Language :: English", - "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", - "Programming Language :: Python :: 3.12", - "Programming Language :: Python :: 3.13", - "Programming Language :: Python :: 3.14", - "Programming Language :: Python :: Implementation :: CPython", - ], + long_description=readme + "\n\n" + history, ) From 333e519717cfd249da0144f6c497950158fd92a4 Mon Sep 17 00:00:00 2001 From: Adrian Date: Fri, 5 Jun 2026 11:53:22 +0200 Subject: [PATCH 030/107] Fix merge issue (#1333) --- dateparser_scripts/write_complete_data.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index 5bb015f5e..7e71ef227 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -29,7 +29,7 @@ def _to_plain_types(obj): """Recursively convert ruamel.yaml CommentedMap/CommentedSeq to plain - OrderedDict/list so that json.dumps produces stable output across all + dict/list so that json.dumps produces stable output across all Python versions. Python 3.14 changed the json C encoder to bypass the Python-level @@ -40,7 +40,7 @@ def _to_plain_types(obj): types before serialisation avoids the issue entirely. """ if isinstance(obj, dict): - return OrderedDict((k, _to_plain_types(v)) for k, v in obj.items()) + return {k: _to_plain_types(v) for k, v in obj.items()} elif isinstance(obj, list): return [_to_plain_types(v) for v in obj] return obj From 081d2518062e0325979f99af0f3c0f8697246223 Mon Sep 17 00:00:00 2001 From: terhoy <70033666+terhoy@users.noreply.github.com> Date: Fri, 5 Jun 2026 13:00:30 +0200 Subject: [PATCH 031/107] =?UTF-8?q?fix(nb):=20improve=20Norwegian=20Bokm?= =?UTF-8?q?=C3=A5l=20date=20parsing=20(#1334)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dateparser/data/date_translation_data/nb.py | 61 ++++++++++++++++--- .../date_translation_data/nb.yaml | 27 +++++++- tests/test_languages.py | 7 +++ 3 files changed, 84 insertions(+), 11 deletions(-) diff --git a/dateparser/data/date_translation_data/nb.py b/dateparser/data/date_translation_data/nb.py index 921cfb084..e3dd32447 100644 --- a/dateparser/data/date_translation_data/nb.py +++ b/dateparser/data/date_translation_data/nb.py @@ -88,7 +88,8 @@ "month": [ "md", "mnd", - "måned" + "måned", + "måneder" ], "week": [ "u", @@ -108,12 +109,14 @@ "minute": [ "m", "min", - "minutt" + "minutt", + "minutter" ], "second": [ "s", "sek", - "sekund" + "sekund", + "sekunder" ], "relative-type": { "0 day ago": [ @@ -238,13 +241,11 @@ "name": "nb-SJ" } }, - "ago": [ - "siden" - ], - "in": [ - "om" - ], "skip": [ + "cirka", + "d.", + "kl", + "kl.", " ", "'", ",", @@ -257,5 +258,47 @@ "]", "|", "," + ], + "sentence_splitter_group": 1, + "ago": [ + "siden" + ], + "in": [ + "om" + ], + "simplifications": [ + { + "en": "1" + }, + { + "ett": "1" + }, + { + "to": "2" + }, + { + "tre": "3" + }, + { + "fire": "4" + }, + { + "fem": "5" + }, + { + "seks": "6" + }, + { + "sju": "7" + }, + { + "åtte": "8" + }, + { + "ni": "9" + }, + { + "ti": "10" + } ] } diff --git a/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml b/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml index 70518b040..e9fe0ed04 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml @@ -1,9 +1,19 @@ +skip: ["cirka", "d.", "kl", "kl."] + +sentence_splitter_group: 1 + +month: + - måneder week: - uker day: - dager hour: - timer +minute: + - minutter +second: + - sekunder ago: - siden @@ -11,5 +21,18 @@ in: - om relative-type-regex: - \1 day ago: - - for (\d+[.,]?\d*) dager siden \ No newline at end of file + \1 day ago: + - for (\d+[.,]?\d*) dager siden + +simplifications: + - en: '1' + - ett: '1' + - to: '2' + - tre: '3' + - fire: '4' + - fem: '5' + - seks: '6' + - sju: '7' + - åtte: '8' + - ni: '9' + - ti: '10' \ No newline at end of file diff --git a/tests/test_languages.py b/tests/test_languages.py index 406e087ab..e9870575a 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1849,6 +1849,13 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("nb", "2 uker siden", "2 week ago"), param("nb", "1 uke siden", "1 week ago"), param("nb", "10 timer siden", "10 hour ago"), + param("nb", "3 måneder siden", "3 month ago"), + param("nb", "2 dager siden", "2 day ago"), + param("nb", "5 uker siden", "5 week ago"), + param("nb", "30 minutter siden", "30 minute ago"), + param("nb", "45 sekunder siden", "45 second ago"), + param("nb", "om 3 uker", "in 3 week"), + param("nb", "om 2 måneder", "in 2 month"), # nd param("nd", "kusasa", "in 1 day"), param("nd", "izolo", "1 day ago"), From 0d11d82dffe96b4366d8a1f8a384412608c323f1 Mon Sep 17 00:00:00 2001 From: Mircea Darius Chira Date: Mon, 8 Jun 2026 09:33:45 +0100 Subject: [PATCH 032/107] Locale order support (#789) * new USE_GIVEN_LANGUAGE_ORDER setting * remove use_given_order param and use USE_GIVEN_LANGUAGE_ORDER setting in DateDataParser * docs for USE_GIVEN_LANGUAGE_ORDER * fix date order parsing with empty languages or locales * added empty locales case in docs * removed use_given_order tests from init date tests * added USE_GIVEN_LANGUAGE_ORDER tests * flake8 fix for tests and conf.py * add mandatory locales or languages when USE_GIVEN_LANGUAGES is set and fixed tests * Finalize USE_GIVEN_LANGUAGE_ORDER: keep use_given_order, no-op on empty (#770) Reconcile the rebased work onto current master with the agreed design: - Keep the public ``use_given_order`` constructor argument (non-breaking); the new ``USE_GIVEN_LANGUAGE_ORDER`` setting is OR-ed with it rather than replacing it, and also reaches the top-level ``dateparser.parse()``. - When the setting is True but no languages/locales are given, it is a no-op (fall back to the default order) instead of raising. - Register ``USE_GIVEN_LANGUAGE_ORDER`` in ``check_settings`` so it is a valid setting, document it under "Language Order" in docs/settings.rst, and add settings-validation and parsing tests. - Revert the unneeded loader change: DateDataParser already normalizes an empty languages list to None. Co-Authored-By: Claude Opus 4.8 (1M context) --------- Co-authored-by: Serhii A Co-authored-by: Claude Opus 4.8 (1M context) --- dateparser/conf.py | 2 + dateparser/date.py | 17 +++++-- dateparser_data/settings.py | 1 + docs/settings.rst | 30 ++++++++++++ tests/test_date_parser.py | 95 +++++++++++++++++++++++++++++++++++++ tests/test_settings.py | 1 + 6 files changed, 143 insertions(+), 3 deletions(-) diff --git a/dateparser/conf.py b/dateparser/conf.py index 8dab177df..6f80b72a1 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -32,6 +32,7 @@ class Settings: * `DEFAULT_DAYS_IN_MONTH` * `PARSERS` * `DEFAULT_LANGUAGES` + * `USE_GIVEN_LANGUAGE_ORDER` * `LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD` * `CACHE_SIZE_LIMIT` """ @@ -227,6 +228,7 @@ def check_settings(settings): "FUZZY": {"type": bool}, "PREFER_LOCALE_DATE_ORDER": {"type": bool}, "DEFAULT_LANGUAGES": {"type": list, "extra_check": _check_default_languages}, + "USE_GIVEN_LANGUAGE_ORDER": {"type": bool}, "LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD": { "type": float, "extra_check": _check_between_0_and_1, diff --git a/dateparser/date.py b/dateparser/date.py index 12b05d4ba..094591707 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -411,7 +411,9 @@ class DateDataParser: :param use_given_order: If True, locales are tried for translation of date string - in the order in which they are given. + in the order in which they are given. This is equivalent to the + ``USE_GIVEN_LANGUAGE_ORDER`` setting; the given order is preserved if + either is enabled. :type use_given_order: bool :param settings: @@ -556,6 +558,15 @@ def get_date_tuple(self, *args, **kwargs): return date_tuple(**date_data.__dict__) def _get_applicable_locales(self, date_string): + # The given order is preserved if requested either through the + # ``use_given_order`` constructor argument or the + # ``USE_GIVEN_LANGUAGE_ORDER`` setting (which also reaches the + # top-level :func:`dateparser.parse`). When no languages or locales are + # given there is nothing to order, so the default order is used. + use_given_order = ( + self.use_given_order or self._settings.USE_GIVEN_LANGUAGE_ORDER + ) + pop_tz_cache = [] def date_strings(): @@ -593,7 +604,7 @@ def date_strings(): languages=self.languages, locales=self.locales, region=self.region, - use_given_order=self.use_given_order, + use_given_order=use_given_order, ): for s in date_strings(): if self._is_applicable_locale(locale, s): @@ -604,7 +615,7 @@ def date_strings(): languages=self._settings.DEFAULT_LANGUAGES, locales=None, region=self.region, - use_given_order=self.use_given_order, + use_given_order=use_given_order, ): yield locale diff --git a/dateparser_data/settings.py b/dateparser_data/settings.py index edf3c4a71..833aff105 100644 --- a/dateparser_data/settings.py +++ b/dateparser_data/settings.py @@ -24,6 +24,7 @@ "SKIP_TOKENS": ["t"], "NORMALIZE": True, "DEFAULT_LANGUAGES": [], + "USE_GIVEN_LANGUAGE_ORDER": False, # Optional language detection "LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD": 0.5, # Time span settings diff --git a/docs/settings.rst b/docs/settings.rst index c2d5bd724..7a8f558a4 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -185,6 +185,36 @@ languages for parsing when language detection fails. eg. ["en", "fr"]: .. note:: When using this setting, these languages will be tried after trying with the detected languages with no success. It is especially useful when using ``detect_languages_function``. +Language Order +++++++++++++++ + +``USE_GIVEN_LANGUAGE_ORDER``: defaults to ``False``. By default, the languages and +locales passed through the ``languages`` and ``locales`` arguments are tried in the +order of the most common languages, regardless of the order in which they are given. +Set this to ``True`` to instead try them in the order in which they are given, which +is useful when that order already reflects a preference (for example, the output of a +language detector ordered by confidence): + + >>> import dateparser + >>> dateparser.parse('11/12/2020', languages=['es', 'en']) + datetime.datetime(2020, 11, 12, 0, 0) + >>> dateparser.parse('11/12/2020', languages=['es', 'en'], settings={'USE_GIVEN_LANGUAGE_ORDER': True}) + datetime.datetime(2020, 12, 11, 0, 0) + +It also applies to the languages given through the ``DEFAULT_LANGUAGES`` setting when +they are used as a fallback. + +.. note:: This setting only reorders the languages and locales that are given. If + neither ``languages`` nor ``locales`` is provided, it has no effect and the default + order is used: + + >>> dateparser.parse('11/12/2020', settings={'USE_GIVEN_LANGUAGE_ORDER': True}) + datetime.datetime(2020, 11, 12, 0, 0) + +.. note:: This setting does not affect :func:`dateparser.search.search_dates`, which + detects a single most likely language and normalizes the text before parsing, so it + does not use the given language order to disambiguate values such as ``11/12``. + Optional language detection +++++++++++++++++++++++++++ diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 87a5a871c..2233ec8d1 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1478,6 +1478,101 @@ def test_yesterday_plus_and_minus_expected_values(self): f"'yesterday -1h' should be {expected_minus}, got {minus_result}", ) + @parameterized.expand( + [ + # USE_GIVEN_LANGUAGE_ORDER=True preserves the given order of `languages`. + param( + "11/12/2020", + expected=datetime(2020, 12, 11, 0, 0), + languages=["es", "en"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + languages=["en", "es"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + # ... and the given order of `locales`. + param( + "11/12/2020", + expected=datetime(2020, 12, 11, 0, 0), + locales=["es", "en"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + locales=["en", "es"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + # Default (False): the most-common-language order is used, regardless + # of the order in which languages/locales are given. + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + languages=["es", "en"], + settings={"USE_GIVEN_LANGUAGE_ORDER": False}, + ), + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + locales=["es", "en"], + settings={"USE_GIVEN_LANGUAGE_ORDER": False}, + ), + # No-op (no error) when no languages/locales are given: there is + # nothing to reorder, so the default order is used. + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + languages=[], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + param( + "11/12/2020", + expected=datetime(2020, 11, 12, 0, 0), + languages=None, + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + ] + ) + def test_use_given_language_order_setting( + self, date_string, expected=None, languages=None, locales=None, settings=None + ): + self.given_parser(languages=languages, locales=locales, settings=settings) + self.when_date_is_parsed(date_string) + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(expected) + + def test_use_given_order_parameter_still_preserves_order_without_setting(self): + # The pre-existing ``use_given_order`` constructor argument must keep working + # on its own (the new setting is OR-ed with it, not a replacement). + self.given_parser(languages=["es", "en"], use_given_order=True) + self.when_date_is_parsed("11/12/2020") + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(datetime(2020, 12, 11, 0, 0)) + + def test_use_given_language_order_setting_fixes_top_level_parse(self): + # Regression test for https://github.com/scrapinghub/dateparser/issues/770 + # The top-level ``parse`` must honour the given language order through the + # ``USE_GIVEN_LANGUAGE_ORDER`` setting. + self.assertEqual( + datetime(2020, 12, 11, 0, 0), + parse( + "11/12/2020", + languages=["es", "en"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + ) + self.assertEqual( + datetime(2020, 11, 12, 0, 0), + parse( + "11/12/2020", + languages=["en", "es"], + settings={"USE_GIVEN_LANGUAGE_ORDER": True}, + ), + ) + def given_parser(self, *args, **kwds): def collecting_get_date_data(parse): @wraps(parse) diff --git a/tests/test_settings.py b/tests/test_settings.py index 8fc3550e0..bc4a5a7cc 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -204,6 +204,7 @@ def test_check_settings_wrong_setting_name(self): param("FUZZY", "true", "", False), param("PREFER_LOCALE_DATE_ORDER", "false", "", True), param("DEFAULT_LANGUAGES", "en", "", ["en"]), + param("USE_GIVEN_LANGUAGE_ORDER", "yes", "", True), param("LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD", "1", "", 0.5), ] ) From 5c6d97f09b7563a0d2dddf0c6584a1fb491ec6c9 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Mon, 8 Jun 2026 11:54:46 +0200 Subject: [PATCH 033/107] fix: Preserve explicit signs for years when combined with decades (#1330) --- dateparser/freshness_date_parser.py | 20 +++++++++++--------- tests/test_freshness_date_parser.py | 11 +++++++++++ 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index efb14a2c6..37596afae 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -123,9 +123,9 @@ def _parse_date(self, date_string, now, prefer_dates_from): return None, None period = "day" if "days" not in kwargs: - for k in ["weeks", "months", "years"]: + for k in ["weeks", "months", "years", "decades"]: if k in kwargs: - period = k[:-1] + period = "year" if k == "decades" else k[:-1] break going_forward = ( @@ -144,6 +144,15 @@ def _parse_date(self, date_string, now, prefer_dates_from): else: adjusted_kwargs[key] = -value + # Fold ``decades`` into ``years`` after each component's sign has been + # resolved so that an unsigned component combined with an explicitly + # signed one still follows the default ago/future context (fixes + # #1304). + if "decades" in adjusted_kwargs: + adjusted_kwargs["years"] = adjusted_kwargs.get( + "years", 0 + ) + 10 * adjusted_kwargs.pop("decades") + td = relativedelta(**adjusted_kwargs) date = now + td @@ -163,13 +172,6 @@ def get_kwargs(self, date_string): explicit_signs[unit + "s"] = has_explicit_sign kwargs[unit + "s"] = float(num.replace(",", ".").replace(" ", "")) - if "decades" in kwargs: - kwargs["years"] = 10 * kwargs["decades"] + kwargs.get("years", 0) - if "decades" in explicit_signs: - explicit_signs["years"] = explicit_signs["decades"] - del kwargs["decades"] - explicit_signs.pop("decades", None) - return kwargs, explicit_signs def get_date_data(self, date_string, settings=None): diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 34dc6a634..60672f0f7 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -68,6 +68,13 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) param("last decade", ago={"years": 10}, period="year"), param("a decade ago", ago={"years": 10}, period="year"), param("100 decades", ago={"years": 1000}, period="year"), + # Regression tests for #1304: an explicit sign on a component is + # preserved when ``decades`` is folded into ``years`` instead of + # being overwritten by the decade's sign. Unsigned components still + # follow the ago/future context. + param("-1 decade", ago={"years": 10}, period="year"), + param("-1 decade 2 years", ago={"years": 12}, period="year"), + param("-1 decade +2 years", ago={"years": 8}, period="year"), param("yesterday", ago={"days": 1}, period="day"), param("the day before yesterday", ago={"days": 2}, period="day"), param("4 days before", ago={"days": 4}, period="day"), @@ -1743,6 +1750,10 @@ def test_normalized_relative_dates(self, date_string, ago, period): param("in 1 decade 12 years", in_future={"years": 22}, period="year"), param("next decade", in_future={"years": 10}, period="year"), param("in a decade", in_future={"years": 10}, period="year"), + # Regression tests for #1304: explicit signs preserved with decades + years + param("+2 years", in_future={"years": 2}, period="year"), + param("in 1 decade +2 years", in_future={"years": 12}, period="year"), + param("+1 decade -2 years", in_future={"years": 8}, period="year"), param("tomorrow", in_future={"days": 1}, period="day"), param("day after tomorrow", in_future={"days": 2}, period="day"), param("after 4 days", in_future={"days": 4}, period="day"), From 98b9c321ae6f6146fdbda94981d0ff6e46eb6f8e Mon Sep 17 00:00:00 2001 From: alhuda <50839256+alhudz@users.noreply.github.com> Date: Tue, 9 Jun 2026 12:54:58 +0530 Subject: [PATCH 034/107] make relative-date regex digit quantifiers possessive (#1335) * make relative-date regex digit quantifiers possessive * Address the issue at the root and add a test * Fix generation-time issue --------- Co-authored-by: alhudz Co-authored-by: Adrian Chaves --- dateparser/data/date_translation_data/af.py | 62 +-- dateparser/data/date_translation_data/am.py | 60 +-- dateparser/data/date_translation_data/ar.py | 28 +- dateparser/data/date_translation_data/ast.py | 92 ++-- .../data/date_translation_data/az-Latn.py | 28 +- dateparser/data/date_translation_data/az.py | 28 +- dateparser/data/date_translation_data/be.py | 86 +-- dateparser/data/date_translation_data/bg.py | 108 ++-- dateparser/data/date_translation_data/bn.py | 32 +- dateparser/data/date_translation_data/br.py | 52 +- .../data/date_translation_data/bs-Cyrl.py | 132 ++--- .../data/date_translation_data/bs-Latn.py | 84 +-- dateparser/data/date_translation_data/bs.py | 84 +-- dateparser/data/date_translation_data/ca.py | 74 +-- dateparser/data/date_translation_data/ce.py | 56 +- dateparser/data/date_translation_data/chr.py | 72 +-- dateparser/data/date_translation_data/cs.py | 110 ++-- dateparser/data/date_translation_data/cy.py | 32 +- dateparser/data/date_translation_data/da.py | 88 ++-- dateparser/data/date_translation_data/de.py | 86 +-- dateparser/data/date_translation_data/dsb.py | 100 ++-- dateparser/data/date_translation_data/dz.py | 28 +- dateparser/data/date_translation_data/ee.py | 60 +-- dateparser/data/date_translation_data/el.py | 98 ++-- dateparser/data/date_translation_data/en.py | 122 ++--- dateparser/data/date_translation_data/es.py | 110 ++-- dateparser/data/date_translation_data/et.py | 60 +-- dateparser/data/date_translation_data/eu.py | 28 +- dateparser/data/date_translation_data/fa.py | 28 +- dateparser/data/date_translation_data/fi.py | 72 +-- dateparser/data/date_translation_data/fil.py | 40 +- dateparser/data/date_translation_data/fo.py | 88 ++-- dateparser/data/date_translation_data/fr.py | 98 ++-- dateparser/data/date_translation_data/fur.py | 52 +- dateparser/data/date_translation_data/fy.py | 48 +- dateparser/data/date_translation_data/ga.py | 58 +- dateparser/data/date_translation_data/gd.py | 84 +-- dateparser/data/date_translation_data/gl.py | 84 +-- dateparser/data/date_translation_data/gu.py | 34 +- dateparser/data/date_translation_data/he.py | 56 +- dateparser/data/date_translation_data/hi.py | 44 +- dateparser/data/date_translation_data/hr.py | 112 ++-- dateparser/data/date_translation_data/hsb.py | 100 ++-- dateparser/data/date_translation_data/hu.py | 30 +- dateparser/data/date_translation_data/hy.py | 52 +- dateparser/data/date_translation_data/id.py | 62 +-- dateparser/data/date_translation_data/is.py | 70 +-- dateparser/data/date_translation_data/it.py | 86 +-- dateparser/data/date_translation_data/ja.py | 66 +-- dateparser/data/date_translation_data/jgo.py | 24 +- dateparser/data/date_translation_data/ka.py | 38 +- dateparser/data/date_translation_data/kea.py | 48 +- dateparser/data/date_translation_data/kk.py | 48 +- dateparser/data/date_translation_data/kl.py | 28 +- dateparser/data/date_translation_data/km.py | 34 +- dateparser/data/date_translation_data/kn.py | 58 +- dateparser/data/date_translation_data/ko.py | 28 +- dateparser/data/date_translation_data/ksh.py | 8 +- dateparser/data/date_translation_data/ky.py | 64 +-- dateparser/data/date_translation_data/lb.py | 56 +- dateparser/data/date_translation_data/lkt.py | 28 +- dateparser/data/date_translation_data/lo.py | 48 +- dateparser/data/date_translation_data/lt.py | 86 +-- dateparser/data/date_translation_data/lv.py | 92 ++-- dateparser/data/date_translation_data/mk.py | 56 +- dateparser/data/date_translation_data/ml.py | 28 +- dateparser/data/date_translation_data/mn.py | 42 +- dateparser/data/date_translation_data/mr.py | 64 +-- dateparser/data/date_translation_data/ms.py | 50 +- dateparser/data/date_translation_data/mt.py | 4 +- dateparser/data/date_translation_data/my.py | 28 +- dateparser/data/date_translation_data/mzn.py | 34 +- dateparser/data/date_translation_data/nb.py | 76 +-- dateparser/data/date_translation_data/ne.py | 28 +- dateparser/data/date_translation_data/nl.py | 60 +-- dateparser/data/date_translation_data/nn.py | 48 +- dateparser/data/date_translation_data/os.py | 10 +- .../data/date_translation_data/pa-Guru.py | 48 +- dateparser/data/date_translation_data/pa.py | 48 +- dateparser/data/date_translation_data/pl.py | 90 ++-- dateparser/data/date_translation_data/pt.py | 496 +++++++++--------- dateparser/data/date_translation_data/ro.py | 82 +-- dateparser/data/date_translation_data/ru.py | 88 ++-- dateparser/data/date_translation_data/sah.py | 30 +- dateparser/data/date_translation_data/se.py | 56 +- dateparser/data/date_translation_data/si.py | 28 +- dateparser/data/date_translation_data/sk.py | 98 ++-- dateparser/data/date_translation_data/sl.py | 76 +-- dateparser/data/date_translation_data/sq.py | 56 +- .../data/date_translation_data/sr-Cyrl.py | 96 ++-- .../data/date_translation_data/sr-Latn.py | 96 ++-- dateparser/data/date_translation_data/sr.py | 96 ++-- dateparser/data/date_translation_data/sv.py | 90 ++-- dateparser/data/date_translation_data/sw.py | 46 +- dateparser/data/date_translation_data/ta.py | 100 ++-- dateparser/data/date_translation_data/te.py | 72 +-- dateparser/data/date_translation_data/th.py | 54 +- dateparser/data/date_translation_data/to.py | 28 +- dateparser/data/date_translation_data/tr.py | 44 +- dateparser/data/date_translation_data/ug.py | 28 +- dateparser/data/date_translation_data/uk.py | 106 ++-- dateparser/data/date_translation_data/ur.py | 72 +-- .../data/date_translation_data/uz-Cyrl.py | 28 +- .../data/date_translation_data/uz-Latn.py | 28 +- dateparser/data/date_translation_data/uz.py | 28 +- dateparser/data/date_translation_data/vi.py | 30 +- dateparser/data/date_translation_data/wae.py | 50 +- dateparser/data/date_translation_data/yi.py | 16 +- dateparser/data/date_translation_data/yue.py | 28 +- .../data/date_translation_data/zh-Hans.py | 32 +- .../data/date_translation_data/zh-Hant.py | 100 ++-- dateparser/data/date_translation_data/zh.py | 44 +- dateparser/data/date_translation_data/zu.py | 24 +- dateparser/freshness_date_parser.py | 2 +- dateparser_scripts/write_complete_data.py | 18 +- tests/test_freshness_date_parser.py | 26 + 116 files changed, 3600 insertions(+), 3558 deletions(-) diff --git a/dateparser/data/date_translation_data/af.py b/dateparser/data/date_translation_data/af.py index a636d4ea8..b3bf8a8e6 100644 --- a/dateparser/data/date_translation_data/af.py +++ b/dateparser/data/date_translation_data/af.py @@ -161,63 +161,63 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) dae gelede", - "(\\d+[.,]?\\d*) dag gelede" + "(\\d++[.,]?\\d*+) dae gelede", + "(\\d++[.,]?\\d*+) dag gelede" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) uur gelede" + "(\\d++[.,]?\\d*+) uur gelede" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min gelede", - "(\\d+[.,]?\\d*) minute gelede", - "(\\d+[.,]?\\d*) minuut gelede" + "(\\d++[.,]?\\d*+) min gelede", + "(\\d++[.,]?\\d*+) minute gelede", + "(\\d++[.,]?\\d*+) minuut gelede" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) maand gelede", - "(\\d+[.,]?\\d*) maande gelede", - "(\\d+[.,]?\\d*) md gelede" + "(\\d++[.,]?\\d*+) maand gelede", + "(\\d++[.,]?\\d*+) maande gelede", + "(\\d++[.,]?\\d*+) md gelede" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sek gelede", - "(\\d+[.,]?\\d*) sekonde gelede", - "(\\d+[.,]?\\d*) sekondes gelede" + "(\\d++[.,]?\\d*+) sek gelede", + "(\\d++[.,]?\\d*+) sekonde gelede", + "(\\d++[.,]?\\d*+) sekondes gelede" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) w gelede", - "(\\d+[.,]?\\d*) week gelede", - "(\\d+[.,]?\\d*) weke gelede" + "(\\d++[.,]?\\d*+) w gelede", + "(\\d++[.,]?\\d*+) week gelede", + "(\\d++[.,]?\\d*+) weke gelede" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) jaar gelede" + "(\\d++[.,]?\\d*+) jaar gelede" ], "in \\1 day": [ - "oor (\\d+[.,]?\\d*) dae", - "oor (\\d+[.,]?\\d*) dag", - "oor (\\d+[.,]?\\d*) minuut" + "oor (\\d++[.,]?\\d*+) dae", + "oor (\\d++[.,]?\\d*+) dag", + "oor (\\d++[.,]?\\d*+) minuut" ], "in \\1 hour": [ - "oor (\\d+[.,]?\\d*) uur" + "oor (\\d++[.,]?\\d*+) uur" ], "in \\1 minute": [ - "oor (\\d+[.,]?\\d*) min", - "oor (\\d+[.,]?\\d*) minuut" + "oor (\\d++[.,]?\\d*+) min", + "oor (\\d++[.,]?\\d*+) minuut" ], "in \\1 month": [ - "oor (\\d+[.,]?\\d*) md", - "oor (\\d+[.,]?\\d*) minuut" + "oor (\\d++[.,]?\\d*+) md", + "oor (\\d++[.,]?\\d*+) minuut" ], "in \\1 second": [ - "oor (\\d+[.,]?\\d*) sek", - "oor (\\d+[.,]?\\d*) sekonde", - "oor (\\d+[.,]?\\d*) sekondes" + "oor (\\d++[.,]?\\d*+) sek", + "oor (\\d++[.,]?\\d*+) sekonde", + "oor (\\d++[.,]?\\d*+) sekondes" ], "in \\1 week": [ - "oor (\\d+[.,]?\\d*) w", - "oor (\\d+[.,]?\\d*) week", - "oor (\\d+[.,]?\\d*) weke" + "oor (\\d++[.,]?\\d*+) w", + "oor (\\d++[.,]?\\d*+) week", + "oor (\\d++[.,]?\\d*+) weke" ], "in \\1 year": [ - "oor (\\d+[.,]?\\d*) jaar" + "oor (\\d++[.,]?\\d*+) jaar" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/am.py b/dateparser/data/date_translation_data/am.py index 5a0abd00b..8dd44c142 100644 --- a/dateparser/data/date_translation_data/am.py +++ b/dateparser/data/date_translation_data/am.py @@ -146,62 +146,62 @@ }, "relative-type-regex": { "\\1 day ago": [ - "ከ (\\d+[.,]?\\d*) ቀን በፊት", - "ከ(\\d+[.,]?\\d*) ቀናት በፊት", - "ከ(\\d+[.,]?\\d*) ቀን በፊት", - "ከ(\\d+[.,]?\\d*) ቀኖች በፊት" + "ከ (\\d++[.,]?\\d*+) ቀን በፊት", + "ከ(\\d++[.,]?\\d*+) ቀናት በፊት", + "ከ(\\d++[.,]?\\d*+) ቀን በፊት", + "ከ(\\d++[.,]?\\d*+) ቀኖች በፊት" ], "\\1 hour ago": [ - "ከ(\\d+[.,]?\\d*) ሰዓት በፊት", - "ከ(\\d+[.,]?\\d*) ሰዓቶች በፊት" + "ከ(\\d++[.,]?\\d*+) ሰዓት በፊት", + "ከ(\\d++[.,]?\\d*+) ሰዓቶች በፊት" ], "\\1 minute ago": [ - "ከ(\\d+[.,]?\\d*) ደቂቃ በፊት", - "ከ(\\d+[.,]?\\d*) ደቂቃዎች በፊት" + "ከ(\\d++[.,]?\\d*+) ደቂቃ በፊት", + "ከ(\\d++[.,]?\\d*+) ደቂቃዎች በፊት" ], "\\1 month ago": [ - "ከ(\\d+[.,]?\\d*) ወራት በፊት", - "ከ(\\d+[.,]?\\d*) ወር በፊት" + "ከ(\\d++[.,]?\\d*+) ወራት በፊት", + "ከ(\\d++[.,]?\\d*+) ወር በፊት" ], "\\1 second ago": [ - "ከ(\\d+[.,]?\\d*) ሰከንድ በፊት", - "ከ(\\d+[.,]?\\d*) ሰከንዶች በፊት" + "ከ(\\d++[.,]?\\d*+) ሰከንድ በፊት", + "ከ(\\d++[.,]?\\d*+) ሰከንዶች በፊት" ], "\\1 week ago": [ - "ከ(\\d+[.,]?\\d*) ሳምንታት በፊት", - "ከ(\\d+[.,]?\\d*) ሳምንት በፊት" + "ከ(\\d++[.,]?\\d*+) ሳምንታት በፊት", + "ከ(\\d++[.,]?\\d*+) ሳምንት በፊት" ], "\\1 year ago": [ - "ከ(\\d+[.,]?\\d*) ዓመታት በፊት", - "ከ(\\d+[.,]?\\d*) ዓመት በፊት" + "ከ(\\d++[.,]?\\d*+) ዓመታት በፊት", + "ከ(\\d++[.,]?\\d*+) ዓመት በፊት" ], "in \\1 day": [ - "በ(\\d+[.,]?\\d*) ቀናት ውስጥ", - "በ(\\d+[.,]?\\d*) ቀን ውስጥ", - "በ(\\d+[.,]?\\d*) ቀኖች ውስጥ" + "በ(\\d++[.,]?\\d*+) ቀናት ውስጥ", + "በ(\\d++[.,]?\\d*+) ቀን ውስጥ", + "በ(\\d++[.,]?\\d*+) ቀኖች ውስጥ" ], "in \\1 hour": [ - "በ(\\d+[.,]?\\d*) ሰዓት ውስጥ", - "በ(\\d+[.,]?\\d*) ሰዓቶች ውስጥ" + "በ(\\d++[.,]?\\d*+) ሰዓት ውስጥ", + "በ(\\d++[.,]?\\d*+) ሰዓቶች ውስጥ" ], "in \\1 minute": [ - "በ(\\d+[.,]?\\d*) ደቂቃ ውስጥ", - "በ(\\d+[.,]?\\d*) ደቂቃዎች ውስጥ" + "በ(\\d++[.,]?\\d*+) ደቂቃ ውስጥ", + "በ(\\d++[.,]?\\d*+) ደቂቃዎች ውስጥ" ], "in \\1 month": [ - "በ(\\d+[.,]?\\d*) ወራት ውስጥ", - "በ(\\d+[.,]?\\d*) ወር ውስጥ" + "በ(\\d++[.,]?\\d*+) ወራት ውስጥ", + "በ(\\d++[.,]?\\d*+) ወር ውስጥ" ], "in \\1 second": [ - "በ(\\d+[.,]?\\d*) ሰከንድ ውስጥ", - "በ(\\d+[.,]?\\d*) ሰከንዶች ውስጥ" + "በ(\\d++[.,]?\\d*+) ሰከንድ ውስጥ", + "በ(\\d++[.,]?\\d*+) ሰከንዶች ውስጥ" ], "in \\1 week": [ - "በ(\\d+[.,]?\\d*) ሳምንታት ውስጥ", - "በ(\\d+[.,]?\\d*) ሳምንት ውስጥ" + "በ(\\d++[.,]?\\d*+) ሳምንታት ውስጥ", + "በ(\\d++[.,]?\\d*+) ሳምንት ውስጥ" ], "in \\1 year": [ - "በ(\\d+[.,]?\\d*) ዓመታት ውስጥ" + "በ(\\d++[.,]?\\d*+) ዓመታት ውስጥ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ar.py b/dateparser/data/date_translation_data/ar.py index db378974b..f5209bd43 100644 --- a/dateparser/data/date_translation_data/ar.py +++ b/dateparser/data/date_translation_data/ar.py @@ -159,46 +159,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "قبل (\\d+[.,]?\\d*) يوم" + "قبل (\\d++[.,]?\\d*+) يوم" ], "\\1 hour ago": [ - "قبل (\\d+[.,]?\\d*) ساعة" + "قبل (\\d++[.,]?\\d*+) ساعة" ], "\\1 minute ago": [ - "قبل (\\d+[.,]?\\d*) دقيقة" + "قبل (\\d++[.,]?\\d*+) دقيقة" ], "\\1 month ago": [ - "قبل (\\d+[.,]?\\d*) شهر" + "قبل (\\d++[.,]?\\d*+) شهر" ], "\\1 second ago": [ - "قبل (\\d+[.,]?\\d*) ثانية" + "قبل (\\d++[.,]?\\d*+) ثانية" ], "\\1 week ago": [ - "قبل (\\d+[.,]?\\d*) أسبوع" + "قبل (\\d++[.,]?\\d*+) أسبوع" ], "\\1 year ago": [ - "قبل (\\d+[.,]?\\d*) سنة" + "قبل (\\d++[.,]?\\d*+) سنة" ], "in \\1 day": [ - "خلال (\\d+[.,]?\\d*) يوم" + "خلال (\\d++[.,]?\\d*+) يوم" ], "in \\1 hour": [ - "خلال (\\d+[.,]?\\d*) ساعة" + "خلال (\\d++[.,]?\\d*+) ساعة" ], "in \\1 minute": [ - "خلال (\\d+[.,]?\\d*) دقيقة" + "خلال (\\d++[.,]?\\d*+) دقيقة" ], "in \\1 month": [ - "خلال (\\d+[.,]?\\d*) شهر" + "خلال (\\d++[.,]?\\d*+) شهر" ], "in \\1 second": [ - "خلال (\\d+[.,]?\\d*) ثانية" + "خلال (\\d++[.,]?\\d*+) ثانية" ], "in \\1 week": [ - "خلال (\\d+[.,]?\\d*) أسبوع" + "خلال (\\d++[.,]?\\d*+) أسبوع" ], "in \\1 year": [ - "خلال (\\d+[.,]?\\d*) سنة" + "خلال (\\d++[.,]?\\d*+) سنة" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ast.py b/dateparser/data/date_translation_data/ast.py index cf32fb3bc..a4dd66a42 100644 --- a/dateparser/data/date_translation_data/ast.py +++ b/dateparser/data/date_translation_data/ast.py @@ -188,78 +188,78 @@ }, "relative-type-regex": { "\\1 day ago": [ - "hai (\\d+[.,]?\\d*) d", - "hai (\\d+[.,]?\\d*) día", - "hai (\\d+[.,]?\\d*) díes" + "hai (\\d++[.,]?\\d*+) d", + "hai (\\d++[.,]?\\d*+) día", + "hai (\\d++[.,]?\\d*+) díes" ], "\\1 hour ago": [ - "hai (\\d+[.,]?\\d*) h", - "hai (\\d+[.,]?\\d*) hora", - "hai (\\d+[.,]?\\d*) hores" + "hai (\\d++[.,]?\\d*+) h", + "hai (\\d++[.,]?\\d*+) hora", + "hai (\\d++[.,]?\\d*+) hores" ], "\\1 minute ago": [ - "hai (\\d+[.,]?\\d*) min", - "hai (\\d+[.,]?\\d*) minutos", - "hai (\\d+[.,]?\\d*) minutu" + "hai (\\d++[.,]?\\d*+) min", + "hai (\\d++[.,]?\\d*+) minutos", + "hai (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "hai (\\d+[.,]?\\d*) m", - "hai (\\d+[.,]?\\d*) mes", - "hai (\\d+[.,]?\\d*) meses" + "hai (\\d++[.,]?\\d*+) m", + "hai (\\d++[.,]?\\d*+) mes", + "hai (\\d++[.,]?\\d*+) meses" ], "\\1 second ago": [ - "hai (\\d+[.,]?\\d*) s", - "hai (\\d+[.,]?\\d*) seg", - "hai (\\d+[.,]?\\d*) segundos", - "hai (\\d+[.,]?\\d*) segundu" + "hai (\\d++[.,]?\\d*+) s", + "hai (\\d++[.,]?\\d*+) seg", + "hai (\\d++[.,]?\\d*+) segundos", + "hai (\\d++[.,]?\\d*+) segundu" ], "\\1 week ago": [ - "hai (\\d+[.,]?\\d*) se", - "hai (\\d+[.,]?\\d*) selm", - "hai (\\d+[.,]?\\d*) selmana", - "hai (\\d+[.,]?\\d*) selmanes" + "hai (\\d++[.,]?\\d*+) se", + "hai (\\d++[.,]?\\d*+) selm", + "hai (\\d++[.,]?\\d*+) selmana", + "hai (\\d++[.,]?\\d*+) selmanes" ], "\\1 year ago": [ - "hai (\\d+[.,]?\\d*) a", - "hai (\\d+[.,]?\\d*) años", - "hai (\\d+[.,]?\\d*) añu" + "hai (\\d++[.,]?\\d*+) a", + "hai (\\d++[.,]?\\d*+) años", + "hai (\\d++[.,]?\\d*+) añu" ], "in \\1 day": [ - "en (\\d+[.,]?\\d*) d", - "en (\\d+[.,]?\\d*) día", - "en (\\d+[.,]?\\d*) díes" + "en (\\d++[.,]?\\d*+) d", + "en (\\d++[.,]?\\d*+) día", + "en (\\d++[.,]?\\d*+) díes" ], "in \\1 hour": [ - "en (\\d+[.,]?\\d*) h", - "en (\\d+[.,]?\\d*) hora", - "en (\\d+[.,]?\\d*) hores" + "en (\\d++[.,]?\\d*+) h", + "en (\\d++[.,]?\\d*+) hora", + "en (\\d++[.,]?\\d*+) hores" ], "in \\1 minute": [ - "en (\\d+[.,]?\\d*) min", - "en (\\d+[.,]?\\d*) minutos", - "en (\\d+[.,]?\\d*) minutu" + "en (\\d++[.,]?\\d*+) min", + "en (\\d++[.,]?\\d*+) minutos", + "en (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "en (\\d+[.,]?\\d*) m", - "en (\\d+[.,]?\\d*) mes", - "en (\\d+[.,]?\\d*) meses" + "en (\\d++[.,]?\\d*+) m", + "en (\\d++[.,]?\\d*+) mes", + "en (\\d++[.,]?\\d*+) meses" ], "in \\1 second": [ - "en (\\d+[.,]?\\d*) s", - "en (\\d+[.,]?\\d*) seg", - "en (\\d+[.,]?\\d*) segundos", - "en (\\d+[.,]?\\d*) segundu" + "en (\\d++[.,]?\\d*+) s", + "en (\\d++[.,]?\\d*+) seg", + "en (\\d++[.,]?\\d*+) segundos", + "en (\\d++[.,]?\\d*+) segundu" ], "in \\1 week": [ - "en (\\d+[.,]?\\d*) se", - "en (\\d+[.,]?\\d*) selm", - "en (\\d+[.,]?\\d*) selmana", - "en (\\d+[.,]?\\d*) selmanes" + "en (\\d++[.,]?\\d*+) se", + "en (\\d++[.,]?\\d*+) selm", + "en (\\d++[.,]?\\d*+) selmana", + "en (\\d++[.,]?\\d*+) selmanes" ], "in \\1 year": [ - "en (\\d+[.,]?\\d*) a", - "en (\\d+[.,]?\\d*) años", - "en (\\d+[.,]?\\d*) añu" + "en (\\d++[.,]?\\d*+) a", + "en (\\d++[.,]?\\d*+) años", + "en (\\d++[.,]?\\d*+) añu" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/az-Latn.py b/dateparser/data/date_translation_data/az-Latn.py index 1709c642d..df79ae0a8 100644 --- a/dateparser/data/date_translation_data/az-Latn.py +++ b/dateparser/data/date_translation_data/az-Latn.py @@ -157,46 +157,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) gün öncə" + "(\\d++[.,]?\\d*+) gün öncə" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) saat öncə" + "(\\d++[.,]?\\d*+) saat öncə" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) dəqiqə öncə" + "(\\d++[.,]?\\d*+) dəqiqə öncə" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ay öncə" + "(\\d++[.,]?\\d*+) ay öncə" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) saniyə öncə" + "(\\d++[.,]?\\d*+) saniyə öncə" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) həftə öncə" + "(\\d++[.,]?\\d*+) həftə öncə" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) il öncə" + "(\\d++[.,]?\\d*+) il öncə" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) gün ərzində" + "(\\d++[.,]?\\d*+) gün ərzində" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) saat ərzində" + "(\\d++[.,]?\\d*+) saat ərzində" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) dəqiqə ərzində" + "(\\d++[.,]?\\d*+) dəqiqə ərzində" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ay ərzində" + "(\\d++[.,]?\\d*+) ay ərzində" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) saniyə ərzində" + "(\\d++[.,]?\\d*+) saniyə ərzində" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) həftə ərzində" + "(\\d++[.,]?\\d*+) həftə ərzində" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) il ərzində" + "(\\d++[.,]?\\d*+) il ərzində" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/az.py b/dateparser/data/date_translation_data/az.py index 037511509..e4033ab9f 100644 --- a/dateparser/data/date_translation_data/az.py +++ b/dateparser/data/date_translation_data/az.py @@ -157,46 +157,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) gün öncə" + "(\\d++[.,]?\\d*+) gün öncə" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) saat öncə" + "(\\d++[.,]?\\d*+) saat öncə" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) dəqiqə öncə" + "(\\d++[.,]?\\d*+) dəqiqə öncə" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ay öncə" + "(\\d++[.,]?\\d*+) ay öncə" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) saniyə öncə" + "(\\d++[.,]?\\d*+) saniyə öncə" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) həftə öncə" + "(\\d++[.,]?\\d*+) həftə öncə" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) il öncə" + "(\\d++[.,]?\\d*+) il öncə" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) gün ərzində" + "(\\d++[.,]?\\d*+) gün ərzində" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) saat ərzində" + "(\\d++[.,]?\\d*+) saat ərzində" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) dəqiqə ərzində" + "(\\d++[.,]?\\d*+) dəqiqə ərzində" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ay ərzində" + "(\\d++[.,]?\\d*+) ay ərzində" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) saniyə ərzində" + "(\\d++[.,]?\\d*+) saniyə ərzində" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) həftə ərzində" + "(\\d++[.,]?\\d*+) həftə ərzində" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) il ərzində" + "(\\d++[.,]?\\d*+) il ərzində" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/be.py b/dateparser/data/date_translation_data/be.py index ea3e99dd3..e44a2083c 100644 --- a/dateparser/data/date_translation_data/be.py +++ b/dateparser/data/date_translation_data/be.py @@ -216,74 +216,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) д таму", - "(\\d+[.,]?\\d*) дзень таму", - "(\\d+[.,]?\\d*) дня таму" + "(\\d++[.,]?\\d*+) д таму", + "(\\d++[.,]?\\d*+) дзень таму", + "(\\d++[.,]?\\d*+) дня таму" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) гадз таму", - "(\\d+[.,]?\\d*) гадзіну таму", - "(\\d+[.,]?\\d*) гадзіны таму" + "(\\d++[.,]?\\d*+) гадз таму", + "(\\d++[.,]?\\d*+) гадзіну таму", + "(\\d++[.,]?\\d*+) гадзіны таму" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) хв таму", - "(\\d+[.,]?\\d*) хвіліну таму", - "(\\d+[.,]?\\d*) хвіліны таму" + "(\\d++[.,]?\\d*+) хв таму", + "(\\d++[.,]?\\d*+) хвіліну таму", + "(\\d++[.,]?\\d*+) хвіліны таму" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) мес таму", - "(\\d+[.,]?\\d*) месяц таму", - "(\\d+[.,]?\\d*) месяца таму" + "(\\d++[.,]?\\d*+) мес таму", + "(\\d++[.,]?\\d*+) месяц таму", + "(\\d++[.,]?\\d*+) месяца таму" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) с таму", - "(\\d+[.,]?\\d*) секунду таму", - "(\\d+[.,]?\\d*) секунды таму" + "(\\d++[.,]?\\d*+) с таму", + "(\\d++[.,]?\\d*+) секунду таму", + "(\\d++[.,]?\\d*+) секунды таму" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) тыд таму", - "(\\d+[.,]?\\d*) тыдзень таму", - "(\\d+[.,]?\\d*) тыдня таму" + "(\\d++[.,]?\\d*+) тыд таму", + "(\\d++[.,]?\\d*+) тыдзень таму", + "(\\d++[.,]?\\d*+) тыдня таму" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) г таму", - "(\\d+[.,]?\\d*) год таму", - "(\\d+[.,]?\\d*) года таму" + "(\\d++[.,]?\\d*+) г таму", + "(\\d++[.,]?\\d*+) год таму", + "(\\d++[.,]?\\d*+) года таму" ], "in \\1 day": [ - "праз (\\d+[.,]?\\d*) д", - "праз (\\d+[.,]?\\d*) дзень", - "праз (\\d+[.,]?\\d*) дня" + "праз (\\d++[.,]?\\d*+) д", + "праз (\\d++[.,]?\\d*+) дзень", + "праз (\\d++[.,]?\\d*+) дня" ], "in \\1 hour": [ - "праз (\\d+[.,]?\\d*) гадз", - "праз (\\d+[.,]?\\d*) гадзіну", - "праз (\\d+[.,]?\\d*) гадзіны" + "праз (\\d++[.,]?\\d*+) гадз", + "праз (\\d++[.,]?\\d*+) гадзіну", + "праз (\\d++[.,]?\\d*+) гадзіны" ], "in \\1 minute": [ - "праз (\\d+[.,]?\\d*) хв", - "праз (\\d+[.,]?\\d*) хвіліну", - "праз (\\d+[.,]?\\d*) хвіліны" + "праз (\\d++[.,]?\\d*+) хв", + "праз (\\d++[.,]?\\d*+) хвіліну", + "праз (\\d++[.,]?\\d*+) хвіліны" ], "in \\1 month": [ - "праз (\\d+[.,]?\\d*) мес", - "праз (\\d+[.,]?\\d*) месяц", - "праз (\\d+[.,]?\\d*) месяца" + "праз (\\d++[.,]?\\d*+) мес", + "праз (\\d++[.,]?\\d*+) месяц", + "праз (\\d++[.,]?\\d*+) месяца" ], "in \\1 second": [ - "праз (\\d+[.,]?\\d*) с", - "праз (\\d+[.,]?\\d*) секунду", - "праз (\\d+[.,]?\\d*) секунды" + "праз (\\d++[.,]?\\d*+) с", + "праз (\\d++[.,]?\\d*+) секунду", + "праз (\\d++[.,]?\\d*+) секунды" ], "in \\1 week": [ - "праз (\\d+[.,]?\\d*) тыд", - "праз (\\d+[.,]?\\d*) тыдзень", - "праз (\\d+[.,]?\\d*) тыдня" + "праз (\\d++[.,]?\\d*+) тыд", + "праз (\\d++[.,]?\\d*+) тыдзень", + "праз (\\d++[.,]?\\d*+) тыдня" ], "in \\1 year": [ - "праз (\\d+[.,]?\\d*) г", - "праз (\\d+[.,]?\\d*) год", - "праз (\\d+[.,]?\\d*) года" + "праз (\\d++[.,]?\\d*+) г", + "праз (\\d++[.,]?\\d*+) год", + "праз (\\d++[.,]?\\d*+) года" ] }, "locale_specific": {}, @@ -334,7 +334,7 @@ "некалькі хвілін": "2 хвіліны" }, { - "(\\d+[.,]?\\d*)\\s*гадзін\\s(\\d+[.,]?\\d*)\\s*хвілін": "\\1:\\2" + "(\\d++[.,]?\\d*+)\\s*гадзін\\s(\\d++[.,]?\\d*+)\\s*хвілін": "\\1:\\2" } ] } diff --git a/dateparser/data/date_translation_data/bg.py b/dateparser/data/date_translation_data/bg.py index 972971b60..e52b1ec18 100644 --- a/dateparser/data/date_translation_data/bg.py +++ b/dateparser/data/date_translation_data/bg.py @@ -219,86 +219,86 @@ }, "relative-type-regex": { "\\1 day ago": [ - "пр (\\d+[.,]?\\d*) д", - "преди (\\d+[.,]?\\d*) ден", - "преди (\\d+[.,]?\\d*) дни" + "пр (\\d++[.,]?\\d*+) д", + "преди (\\d++[.,]?\\d*+) ден", + "преди (\\d++[.,]?\\d*+) дни" ], "\\1 hour ago": [ - "пр (\\d+[.,]?\\d*) ч", - "преди (\\d+[.,]?\\d*) ч", - "преди (\\d+[.,]?\\d*) час", - "преди (\\d+[.,]?\\d*) часа" + "пр (\\d++[.,]?\\d*+) ч", + "преди (\\d++[.,]?\\d*+) ч", + "преди (\\d++[.,]?\\d*+) час", + "преди (\\d++[.,]?\\d*+) часа" ], "\\1 minute ago": [ - "пр (\\d+[.,]?\\d*) мин", - "преди (\\d+[.,]?\\d*) мин", - "преди (\\d+[.,]?\\d*) минута", - "преди (\\d+[.,]?\\d*) минути" + "пр (\\d++[.,]?\\d*+) мин", + "преди (\\d++[.,]?\\d*+) мин", + "преди (\\d++[.,]?\\d*+) минута", + "преди (\\d++[.,]?\\d*+) минути" ], "\\1 month ago": [ - "пр (\\d+[.,]?\\d*) м", - "преди (\\d+[.,]?\\d*) м", - "преди (\\d+[.,]?\\d*) месец", - "преди (\\d+[.,]?\\d*) месеца" + "пр (\\d++[.,]?\\d*+) м", + "преди (\\d++[.,]?\\d*+) м", + "преди (\\d++[.,]?\\d*+) месец", + "преди (\\d++[.,]?\\d*+) месеца" ], "\\1 second ago": [ - "пр (\\d+[.,]?\\d*) сек", - "преди (\\d+[.,]?\\d*) сек", - "преди (\\d+[.,]?\\d*) секунда", - "преди (\\d+[.,]?\\d*) секунди" + "пр (\\d++[.,]?\\d*+) сек", + "преди (\\d++[.,]?\\d*+) сек", + "преди (\\d++[.,]?\\d*+) секунда", + "преди (\\d++[.,]?\\d*+) секунди" ], "\\1 week ago": [ - "пр (\\d+[.,]?\\d*) седм", - "преди (\\d+[.,]?\\d*) седм", - "преди (\\d+[.,]?\\d*) седмица", - "преди (\\d+[.,]?\\d*) седмици" + "пр (\\d++[.,]?\\d*+) седм", + "преди (\\d++[.,]?\\d*+) седм", + "преди (\\d++[.,]?\\d*+) седмица", + "преди (\\d++[.,]?\\d*+) седмици" ], "\\1 year ago": [ - "пр (\\d+[.,]?\\d*) г", - "преди (\\d+[.,]?\\d*) г", - "преди (\\d+[.,]?\\d*) година", - "преди (\\d+[.,]?\\d*) години" + "пр (\\d++[.,]?\\d*+) г", + "преди (\\d++[.,]?\\d*+) г", + "преди (\\d++[.,]?\\d*+) година", + "преди (\\d++[.,]?\\d*+) години" ], "in \\1 day": [ - "сл (\\d+[.,]?\\d*) д", - "след (\\d+[.,]?\\d*) ден", - "след (\\d+[.,]?\\d*) дни" + "сл (\\d++[.,]?\\d*+) д", + "след (\\d++[.,]?\\d*+) ден", + "след (\\d++[.,]?\\d*+) дни" ], "in \\1 hour": [ - "сл (\\d+[.,]?\\d*) ч", - "след (\\d+[.,]?\\d*) ч", - "след (\\d+[.,]?\\d*) час", - "след (\\d+[.,]?\\d*) часа" + "сл (\\d++[.,]?\\d*+) ч", + "след (\\d++[.,]?\\d*+) ч", + "след (\\d++[.,]?\\d*+) час", + "след (\\d++[.,]?\\d*+) часа" ], "in \\1 minute": [ - "сл (\\d+[.,]?\\d*) мин", - "след (\\d+[.,]?\\d*) мин", - "след (\\d+[.,]?\\d*) минута", - "след (\\d+[.,]?\\d*) минути" + "сл (\\d++[.,]?\\d*+) мин", + "след (\\d++[.,]?\\d*+) мин", + "след (\\d++[.,]?\\d*+) минута", + "след (\\d++[.,]?\\d*+) минути" ], "in \\1 month": [ - "сл (\\d+[.,]?\\d*) м", - "след (\\d+[.,]?\\d*) м", - "след (\\d+[.,]?\\d*) месец", - "след (\\d+[.,]?\\d*) месеца" + "сл (\\d++[.,]?\\d*+) м", + "след (\\d++[.,]?\\d*+) м", + "след (\\d++[.,]?\\d*+) месец", + "след (\\d++[.,]?\\d*+) месеца" ], "in \\1 second": [ - "сл (\\d+[.,]?\\d*) сек", - "след (\\d+[.,]?\\d*) сек", - "след (\\d+[.,]?\\d*) секунда", - "след (\\d+[.,]?\\d*) секунди" + "сл (\\d++[.,]?\\d*+) сек", + "след (\\d++[.,]?\\d*+) сек", + "след (\\d++[.,]?\\d*+) секунда", + "след (\\d++[.,]?\\d*+) секунди" ], "in \\1 week": [ - "сл (\\d+[.,]?\\d*) седм", - "след (\\d+[.,]?\\d*) седм", - "след (\\d+[.,]?\\d*) седмица", - "след (\\d+[.,]?\\d*) седмици" + "сл (\\d++[.,]?\\d*+) седм", + "след (\\d++[.,]?\\d*+) седм", + "след (\\d++[.,]?\\d*+) седмица", + "след (\\d++[.,]?\\d*+) седмици" ], "in \\1 year": [ - "сл (\\d+[.,]?\\d*) г", - "след (\\d+[.,]?\\d*) г", - "след (\\d+[.,]?\\d*) година", - "след (\\d+[.,]?\\d*) години" + "сл (\\d++[.,]?\\d*+) г", + "след (\\d++[.,]?\\d*+) г", + "след (\\d++[.,]?\\d*+) година", + "след (\\d++[.,]?\\d*+) години" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/bn.py b/dateparser/data/date_translation_data/bn.py index 409f0d587..e8fccfde6 100644 --- a/dateparser/data/date_translation_data/bn.py +++ b/dateparser/data/date_translation_data/bn.py @@ -154,48 +154,48 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) দিন আগে" + "(\\d++[.,]?\\d*+) দিন আগে" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ঘন্টা আগে" + "(\\d++[.,]?\\d*+) ঘন্টা আগে" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) মিনিট আগে", - "(\\d+[.,]?\\d*) মিনিট পূর্বে" + "(\\d++[.,]?\\d*+) মিনিট আগে", + "(\\d++[.,]?\\d*+) মিনিট পূর্বে" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) মাস আগে" + "(\\d++[.,]?\\d*+) মাস আগে" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) সেকেন্ড আগে", - "(\\d+[.,]?\\d*) সেকেন্ড পূর্বে" + "(\\d++[.,]?\\d*+) সেকেন্ড আগে", + "(\\d++[.,]?\\d*+) সেকেন্ড পূর্বে" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) সপ্তাহ আগে" + "(\\d++[.,]?\\d*+) সপ্তাহ আগে" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) বছর পূর্বে" + "(\\d++[.,]?\\d*+) বছর পূর্বে" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) দিনের মধ্যে" + "(\\d++[.,]?\\d*+) দিনের মধ্যে" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ঘন্টায়" + "(\\d++[.,]?\\d*+) ঘন্টায়" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) মিনিটে" + "(\\d++[.,]?\\d*+) মিনিটে" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) মাসে" + "(\\d++[.,]?\\d*+) মাসে" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) সেকেন্ডে" + "(\\d++[.,]?\\d*+) সেকেন্ডে" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) সপ্তাহে" + "(\\d++[.,]?\\d*+) সপ্তাহে" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) বছরে" + "(\\d++[.,]?\\d*+) বছরে" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/br.py b/dateparser/data/date_translation_data/br.py index 38c5ae437..1d3755a81 100644 --- a/dateparser/data/date_translation_data/br.py +++ b/dateparser/data/date_translation_data/br.py @@ -154,58 +154,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) d zo", - "(\\d+[.,]?\\d*) deiz zo" + "(\\d++[.,]?\\d*+) d zo", + "(\\d++[.,]?\\d*+) deiz zo" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) e zo", - "(\\d+[.,]?\\d*) eur zo" + "(\\d++[.,]?\\d*+) e zo", + "(\\d++[.,]?\\d*+) eur zo" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min zo", - "(\\d+[.,]?\\d*) munut zo" + "(\\d++[.,]?\\d*+) min zo", + "(\\d++[.,]?\\d*+) munut zo" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) miz zo" + "(\\d++[.,]?\\d*+) miz zo" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) eilenn zo", - "(\\d+[.,]?\\d*) s zo" + "(\\d++[.,]?\\d*+) eilenn zo", + "(\\d++[.,]?\\d*+) s zo" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) sizhun zo" + "(\\d++[.,]?\\d*+) sizhun zo" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) bl zo", - "(\\d+[.,]?\\d*) bloaz zo", - "(\\d+[.,]?\\d*) vloaz zo" + "(\\d++[.,]?\\d*+) bl zo", + "(\\d++[.,]?\\d*+) bloaz zo", + "(\\d++[.,]?\\d*+) vloaz zo" ], "in \\1 day": [ - "a-benn (\\d+[.,]?\\d*) d", - "a-benn (\\d+[.,]?\\d*) deiz" + "a-benn (\\d++[.,]?\\d*+) d", + "a-benn (\\d++[.,]?\\d*+) deiz" ], "in \\1 hour": [ - "a-benn (\\d+[.,]?\\d*) e", - "a-benn (\\d+[.,]?\\d*) eur" + "a-benn (\\d++[.,]?\\d*+) e", + "a-benn (\\d++[.,]?\\d*+) eur" ], "in \\1 minute": [ - "a-benn (\\d+[.,]?\\d*) min", - "a-benn (\\d+[.,]?\\d*) munut" + "a-benn (\\d++[.,]?\\d*+) min", + "a-benn (\\d++[.,]?\\d*+) munut" ], "in \\1 month": [ - "a-benn (\\d+[.,]?\\d*) miz" + "a-benn (\\d++[.,]?\\d*+) miz" ], "in \\1 second": [ - "a-benn (\\d+[.,]?\\d*) eilenn", - "a-benn (\\d+[.,]?\\d*) s" + "a-benn (\\d++[.,]?\\d*+) eilenn", + "a-benn (\\d++[.,]?\\d*+) s" ], "in \\1 week": [ - "a-benn (\\d+[.,]?\\d*) sizhun" + "a-benn (\\d++[.,]?\\d*+) sizhun" ], "in \\1 year": [ - "a-benn (\\d+[.,]?\\d*) bl", - "a-benn (\\d+[.,]?\\d*) bloaz", - "a-benn (\\d+[.,]?\\d*) vloaz" + "a-benn (\\d++[.,]?\\d*+) bl", + "a-benn (\\d++[.,]?\\d*+) bloaz", + "a-benn (\\d++[.,]?\\d*+) vloaz" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/bs-Cyrl.py b/dateparser/data/date_translation_data/bs-Cyrl.py index 0b3951a41..303e962f0 100644 --- a/dateparser/data/date_translation_data/bs-Cyrl.py +++ b/dateparser/data/date_translation_data/bs-Cyrl.py @@ -182,98 +182,98 @@ }, "relative-type-regex": { "\\1 day ago": [ - "пре (\\d+[.,]?\\d*) дан", - "пре (\\d+[.,]?\\d*) дана", - "прије (\\d+[.,]?\\d*) дан", - "прије (\\d+[.,]?\\d*) дана" + "пре (\\d++[.,]?\\d*+) дан", + "пре (\\d++[.,]?\\d*+) дана", + "прије (\\d++[.,]?\\d*+) дан", + "прије (\\d++[.,]?\\d*+) дана" ], "\\1 hour ago": [ - "пре (\\d+[.,]?\\d*) сат", - "пре (\\d+[.,]?\\d*) сати", - "прије (\\d+[.,]?\\d*) сат", - "прије (\\d+[.,]?\\d*) сати" + "пре (\\d++[.,]?\\d*+) сат", + "пре (\\d++[.,]?\\d*+) сати", + "прије (\\d++[.,]?\\d*+) сат", + "прије (\\d++[.,]?\\d*+) сати" ], "\\1 minute ago": [ - "пре (\\d+[.,]?\\d*) минут", - "пре (\\d+[.,]?\\d*) минута", - "прије (\\d+[.,]?\\d*) мин", - "прије (\\d+[.,]?\\d*) минута", - "прије (\\d+[.,]?\\d*) минуту" + "пре (\\d++[.,]?\\d*+) минут", + "пре (\\d++[.,]?\\d*+) минута", + "прије (\\d++[.,]?\\d*+) мин", + "прије (\\d++[.,]?\\d*+) минута", + "прије (\\d++[.,]?\\d*+) минуту" ], "\\1 month ago": [ - "пре (\\d+[.,]?\\d*) месец", - "пре (\\d+[.,]?\\d*) месеци", - "прије (\\d+[.,]?\\d*) мј", - "прије (\\d+[.,]?\\d*) мјесец", - "прије (\\d+[.,]?\\d*) мјесеца", - "прије (\\d+[.,]?\\d*) мјесеци" + "пре (\\d++[.,]?\\d*+) месец", + "пре (\\d++[.,]?\\d*+) месеци", + "прије (\\d++[.,]?\\d*+) мј", + "прије (\\d++[.,]?\\d*+) мјесец", + "прије (\\d++[.,]?\\d*+) мјесеца", + "прије (\\d++[.,]?\\d*+) мјесеци" ], "\\1 second ago": [ - "пре (\\d+[.,]?\\d*) секунд", - "пре (\\d+[.,]?\\d*) секунди", - "прије (\\d+[.,]?\\d*) сек", - "прије (\\d+[.,]?\\d*) секунда", - "прије (\\d+[.,]?\\d*) секунду" + "пре (\\d++[.,]?\\d*+) секунд", + "пре (\\d++[.,]?\\d*+) секунди", + "прије (\\d++[.,]?\\d*+) сек", + "прије (\\d++[.,]?\\d*+) секунда", + "прије (\\d++[.,]?\\d*+) секунду" ], "\\1 week ago": [ - "пре (\\d+[.,]?\\d*) недеља", - "пре (\\d+[.,]?\\d*) недељу", - "прије (\\d+[.,]?\\d*) сед", - "прије (\\d+[.,]?\\d*) седмица", - "прије (\\d+[.,]?\\d*) седмице", - "прије (\\d+[.,]?\\d*) седмицу" + "пре (\\d++[.,]?\\d*+) недеља", + "пре (\\d++[.,]?\\d*+) недељу", + "прије (\\d++[.,]?\\d*+) сед", + "прије (\\d++[.,]?\\d*+) седмица", + "прије (\\d++[.,]?\\d*+) седмице", + "прије (\\d++[.,]?\\d*+) седмицу" ], "\\1 year ago": [ - "пре (\\d+[.,]?\\d*) година", - "пре (\\d+[.,]?\\d*) годину", - "прије (\\d+[.,]?\\d*) г", - "прије (\\d+[.,]?\\d*) год", - "прије (\\d+[.,]?\\d*) година", - "прије (\\d+[.,]?\\d*) годину" + "пре (\\d++[.,]?\\d*+) година", + "пре (\\d++[.,]?\\d*+) годину", + "прије (\\d++[.,]?\\d*+) г", + "прије (\\d++[.,]?\\d*+) год", + "прије (\\d++[.,]?\\d*+) година", + "прије (\\d++[.,]?\\d*+) годину" ], "in \\1 day": [ - "за (\\d+[.,]?\\d*) дан", - "за (\\d+[.,]?\\d*) дана" + "за (\\d++[.,]?\\d*+) дан", + "за (\\d++[.,]?\\d*+) дана" ], "in \\1 hour": [ - "за (\\d+[.,]?\\d*) сат", - "за (\\d+[.,]?\\d*) сати" + "за (\\d++[.,]?\\d*+) сат", + "за (\\d++[.,]?\\d*+) сати" ], "in \\1 minute": [ - "за (\\d+[.,]?\\d*) минут", - "за (\\d+[.,]?\\d*) минута", - "за (\\d+[.,]?\\d*) мин", - "за (\\d+[.,]?\\d*) минута", - "за (\\d+[.,]?\\d*) минуту" + "за (\\d++[.,]?\\d*+) минут", + "за (\\d++[.,]?\\d*+) минута", + "за (\\d++[.,]?\\d*+) мин", + "за (\\d++[.,]?\\d*+) минута", + "за (\\d++[.,]?\\d*+) минуту" ], "in \\1 month": [ - "за (\\d+[.,]?\\d*) месец", - "за (\\d+[.,]?\\d*) месеци", - "за (\\d+[.,]?\\d*) мј", - "за (\\d+[.,]?\\d*) мјесец", - "за (\\d+[.,]?\\d*) мјесеца", - "за (\\d+[.,]?\\d*) мјесеци" + "за (\\d++[.,]?\\d*+) месец", + "за (\\d++[.,]?\\d*+) месеци", + "за (\\d++[.,]?\\d*+) мј", + "за (\\d++[.,]?\\d*+) мјесец", + "за (\\d++[.,]?\\d*+) мјесеца", + "за (\\d++[.,]?\\d*+) мјесеци" ], "in \\1 second": [ - "за (\\d+[.,]?\\d*) секунд", - "за (\\d+[.,]?\\d*) секунди", - "за (\\d+[.,]?\\d*) сек", - "за (\\d+[.,]?\\d*) секунда", - "за (\\d+[.,]?\\d*) секунду" + "за (\\d++[.,]?\\d*+) секунд", + "за (\\d++[.,]?\\d*+) секунди", + "за (\\d++[.,]?\\d*+) сек", + "за (\\d++[.,]?\\d*+) секунда", + "за (\\d++[.,]?\\d*+) секунду" ], "in \\1 week": [ - "за (\\d+[.,]?\\d*) недеља", - "за (\\d+[.,]?\\d*) недељу", - "за (\\d+[.,]?\\d*) сед", - "за (\\d+[.,]?\\d*) седмица", - "за (\\d+[.,]?\\d*) седмицу", - "за (\\d+[.,]?\\d*) седмице" + "за (\\d++[.,]?\\d*+) недеља", + "за (\\d++[.,]?\\d*+) недељу", + "за (\\d++[.,]?\\d*+) сед", + "за (\\d++[.,]?\\d*+) седмица", + "за (\\d++[.,]?\\d*+) седмицу", + "за (\\d++[.,]?\\d*+) седмице" ], "in \\1 year": [ - "за (\\d+[.,]?\\d*) година", - "за (\\d+[.,]?\\d*) годину", - "за (\\d+[.,]?\\d*) г", - "за (\\d+[.,]?\\d*) год" + "за (\\d++[.,]?\\d*+) година", + "за (\\d++[.,]?\\d*+) годину", + "за (\\d++[.,]?\\d*+) г", + "за (\\d++[.,]?\\d*+) год" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/bs-Latn.py b/dateparser/data/date_translation_data/bs-Latn.py index b0cbe0c99..856305447 100644 --- a/dateparser/data/date_translation_data/bs-Latn.py +++ b/dateparser/data/date_translation_data/bs-Latn.py @@ -160,74 +160,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "prije (\\d+[.,]?\\d*) d", - "prije (\\d+[.,]?\\d*) dan", - "prije (\\d+[.,]?\\d*) dana" + "prije (\\d++[.,]?\\d*+) d", + "prije (\\d++[.,]?\\d*+) dan", + "prije (\\d++[.,]?\\d*+) dana" ], "\\1 hour ago": [ - "prije (\\d+[.,]?\\d*) sat", - "prije (\\d+[.,]?\\d*) sati" + "prije (\\d++[.,]?\\d*+) sat", + "prije (\\d++[.,]?\\d*+) sati" ], "\\1 minute ago": [ - "prije (\\d+[.,]?\\d*) min", - "prije (\\d+[.,]?\\d*) minuta", - "prije (\\d+[.,]?\\d*) minutu" + "prije (\\d++[.,]?\\d*+) min", + "prije (\\d++[.,]?\\d*+) minuta", + "prije (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "prije (\\d+[.,]?\\d*) mj", - "prije (\\d+[.,]?\\d*) mjesec", - "prije (\\d+[.,]?\\d*) mjeseci" + "prije (\\d++[.,]?\\d*+) mj", + "prije (\\d++[.,]?\\d*+) mjesec", + "prije (\\d++[.,]?\\d*+) mjeseci" ], "\\1 second ago": [ - "prije (\\d+[.,]?\\d*) sek", - "prije (\\d+[.,]?\\d*) sekundi", - "prije (\\d+[.,]?\\d*) sekundu" + "prije (\\d++[.,]?\\d*+) sek", + "prije (\\d++[.,]?\\d*+) sekundi", + "prije (\\d++[.,]?\\d*+) sekundu" ], "\\1 week ago": [ - "prije (\\d+[.,]?\\d*) sed", - "prije (\\d+[.,]?\\d*) sedmica", - "prije (\\d+[.,]?\\d*) sedmicu" + "prije (\\d++[.,]?\\d*+) sed", + "prije (\\d++[.,]?\\d*+) sedmica", + "prije (\\d++[.,]?\\d*+) sedmicu" ], "\\1 year ago": [ - "prije (\\d+[.,]?\\d*) g", - "prije (\\d+[.,]?\\d*) god", - "prije (\\d+[.,]?\\d*) godina", - "prije (\\d+[.,]?\\d*) godinu" + "prije (\\d++[.,]?\\d*+) g", + "prije (\\d++[.,]?\\d*+) god", + "prije (\\d++[.,]?\\d*+) godina", + "prije (\\d++[.,]?\\d*+) godinu" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) d", - "za (\\d+[.,]?\\d*) dan", - "za (\\d+[.,]?\\d*) dana" + "za (\\d++[.,]?\\d*+) d", + "za (\\d++[.,]?\\d*+) dan", + "za (\\d++[.,]?\\d*+) dana" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) sat", - "za (\\d+[.,]?\\d*) sati" + "za (\\d++[.,]?\\d*+) sat", + "za (\\d++[.,]?\\d*+) sati" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minuta", - "za (\\d+[.,]?\\d*) minutu" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minuta", + "za (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) mj", - "za (\\d+[.,]?\\d*) mjesec", - "za (\\d+[.,]?\\d*) mjeseci" + "za (\\d++[.,]?\\d*+) mj", + "za (\\d++[.,]?\\d*+) mjesec", + "za (\\d++[.,]?\\d*+) mjeseci" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundi", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundi", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) sed", - "za (\\d+[.,]?\\d*) sedmica", - "za (\\d+[.,]?\\d*) sedmicu" + "za (\\d++[.,]?\\d*+) sed", + "za (\\d++[.,]?\\d*+) sedmica", + "za (\\d++[.,]?\\d*+) sedmicu" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) god", - "za (\\d+[.,]?\\d*) godina", - "za (\\d+[.,]?\\d*) godinu" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) god", + "za (\\d++[.,]?\\d*+) godina", + "za (\\d++[.,]?\\d*+) godinu" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/bs.py b/dateparser/data/date_translation_data/bs.py index 7c0ba09a7..420ecfa71 100644 --- a/dateparser/data/date_translation_data/bs.py +++ b/dateparser/data/date_translation_data/bs.py @@ -160,74 +160,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "prije (\\d+[.,]?\\d*) d", - "prije (\\d+[.,]?\\d*) dan", - "prije (\\d+[.,]?\\d*) dana" + "prije (\\d++[.,]?\\d*+) d", + "prije (\\d++[.,]?\\d*+) dan", + "prije (\\d++[.,]?\\d*+) dana" ], "\\1 hour ago": [ - "prije (\\d+[.,]?\\d*) sat", - "prije (\\d+[.,]?\\d*) sati" + "prije (\\d++[.,]?\\d*+) sat", + "prije (\\d++[.,]?\\d*+) sati" ], "\\1 minute ago": [ - "prije (\\d+[.,]?\\d*) min", - "prije (\\d+[.,]?\\d*) minuta", - "prije (\\d+[.,]?\\d*) minutu" + "prije (\\d++[.,]?\\d*+) min", + "prije (\\d++[.,]?\\d*+) minuta", + "prije (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "prije (\\d+[.,]?\\d*) mj", - "prije (\\d+[.,]?\\d*) mjesec", - "prije (\\d+[.,]?\\d*) mjeseci" + "prije (\\d++[.,]?\\d*+) mj", + "prije (\\d++[.,]?\\d*+) mjesec", + "prije (\\d++[.,]?\\d*+) mjeseci" ], "\\1 second ago": [ - "prije (\\d+[.,]?\\d*) sek", - "prije (\\d+[.,]?\\d*) sekundi", - "prije (\\d+[.,]?\\d*) sekundu" + "prije (\\d++[.,]?\\d*+) sek", + "prije (\\d++[.,]?\\d*+) sekundi", + "prije (\\d++[.,]?\\d*+) sekundu" ], "\\1 week ago": [ - "prije (\\d+[.,]?\\d*) sed", - "prije (\\d+[.,]?\\d*) sedmica", - "prije (\\d+[.,]?\\d*) sedmicu" + "prije (\\d++[.,]?\\d*+) sed", + "prije (\\d++[.,]?\\d*+) sedmica", + "prije (\\d++[.,]?\\d*+) sedmicu" ], "\\1 year ago": [ - "prije (\\d+[.,]?\\d*) g", - "prije (\\d+[.,]?\\d*) god", - "prije (\\d+[.,]?\\d*) godina", - "prije (\\d+[.,]?\\d*) godinu" + "prije (\\d++[.,]?\\d*+) g", + "prije (\\d++[.,]?\\d*+) god", + "prije (\\d++[.,]?\\d*+) godina", + "prije (\\d++[.,]?\\d*+) godinu" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) d", - "za (\\d+[.,]?\\d*) dan", - "za (\\d+[.,]?\\d*) dana" + "za (\\d++[.,]?\\d*+) d", + "za (\\d++[.,]?\\d*+) dan", + "za (\\d++[.,]?\\d*+) dana" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) sat", - "za (\\d+[.,]?\\d*) sati" + "za (\\d++[.,]?\\d*+) sat", + "za (\\d++[.,]?\\d*+) sati" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minuta", - "za (\\d+[.,]?\\d*) minutu" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minuta", + "za (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) mj", - "za (\\d+[.,]?\\d*) mjesec", - "za (\\d+[.,]?\\d*) mjeseci" + "za (\\d++[.,]?\\d*+) mj", + "za (\\d++[.,]?\\d*+) mjesec", + "za (\\d++[.,]?\\d*+) mjeseci" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundi", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundi", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) sed", - "za (\\d+[.,]?\\d*) sedmica", - "za (\\d+[.,]?\\d*) sedmicu" + "za (\\d++[.,]?\\d*+) sed", + "za (\\d++[.,]?\\d*+) sedmica", + "za (\\d++[.,]?\\d*+) sedmicu" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) god", - "za (\\d+[.,]?\\d*) godina", - "za (\\d+[.,]?\\d*) godinu" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) god", + "za (\\d++[.,]?\\d*+) godina", + "za (\\d++[.,]?\\d*+) godinu" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ca.py b/dateparser/data/date_translation_data/ca.py index 4d0a2f2cd..ec42c9e18 100644 --- a/dateparser/data/date_translation_data/ca.py +++ b/dateparser/data/date_translation_data/ca.py @@ -201,69 +201,69 @@ }, "relative-type-regex": { "\\1 day ago": [ - "fa (\\d+[.,]?\\d*) dia", - "fa (\\d+[.,]?\\d*) dies" + "fa (\\d++[.,]?\\d*+) dia", + "fa (\\d++[.,]?\\d*+) dies" ], "\\1 hour ago": [ - "fa (\\d+[.,]?\\d*) h", - "fa (\\d+[.,]?\\d*) hora", - "fa (\\d+[.,]?\\d*) hores" + "fa (\\d++[.,]?\\d*+) h", + "fa (\\d++[.,]?\\d*+) hora", + "fa (\\d++[.,]?\\d*+) hores" ], "\\1 minute ago": [ - "fa (\\d+[.,]?\\d*) min", - "fa (\\d+[.,]?\\d*) minut", - "fa (\\d+[.,]?\\d*) minuts" + "fa (\\d++[.,]?\\d*+) min", + "fa (\\d++[.,]?\\d*+) minut", + "fa (\\d++[.,]?\\d*+) minuts" ], "\\1 month ago": [ - "fa (\\d+[.,]?\\d*) mes", - "fa (\\d+[.,]?\\d*) mesos" + "fa (\\d++[.,]?\\d*+) mes", + "fa (\\d++[.,]?\\d*+) mesos" ], "\\1 second ago": [ - "fa (\\d+[.,]?\\d*) s", - "fa (\\d+[.,]?\\d*) segon", - "fa (\\d+[.,]?\\d*) segons" + "fa (\\d++[.,]?\\d*+) s", + "fa (\\d++[.,]?\\d*+) segon", + "fa (\\d++[.,]?\\d*+) segons" ], "\\1 week ago": [ - "fa (\\d+[.,]?\\d*) setm", - "fa (\\d+[.,]?\\d*) setmana", - "fa (\\d+[.,]?\\d*) setmanes" + "fa (\\d++[.,]?\\d*+) setm", + "fa (\\d++[.,]?\\d*+) setmana", + "fa (\\d++[.,]?\\d*+) setmanes" ], "\\1 year ago": [ - "fa (\\d+[.,]?\\d*) any", - "fa (\\d+[.,]?\\d*) anys" + "fa (\\d++[.,]?\\d*+) any", + "fa (\\d++[.,]?\\d*+) anys" ], "in \\1 day": [ - "d'aquí a (\\d+[.,]?\\d*) dia", - "d'aquí a (\\d+[.,]?\\d*) dies" + "d'aquí a (\\d++[.,]?\\d*+) dia", + "d'aquí a (\\d++[.,]?\\d*+) dies" ], "in \\1 hour": [ - "d'aquí a (\\d+[.,]?\\d*) h", - "d'aquí a (\\d+[.,]?\\d*) hora", - "d'aquí a (\\d+[.,]?\\d*) hores", - "d‘aquí a (\\d+[.,]?\\d*) h" + "d'aquí a (\\d++[.,]?\\d*+) h", + "d'aquí a (\\d++[.,]?\\d*+) hora", + "d'aquí a (\\d++[.,]?\\d*+) hores", + "d‘aquí a (\\d++[.,]?\\d*+) h" ], "in \\1 minute": [ - "d'aquí a (\\d+[.,]?\\d*) min", - "d'aquí a (\\d+[.,]?\\d*) minut", - "d'aquí a (\\d+[.,]?\\d*) minuts" + "d'aquí a (\\d++[.,]?\\d*+) min", + "d'aquí a (\\d++[.,]?\\d*+) minut", + "d'aquí a (\\d++[.,]?\\d*+) minuts" ], "in \\1 month": [ - "d'aquí a (\\d+[.,]?\\d*) mes", - "d'aquí a (\\d+[.,]?\\d*) mesos" + "d'aquí a (\\d++[.,]?\\d*+) mes", + "d'aquí a (\\d++[.,]?\\d*+) mesos" ], "in \\1 second": [ - "d'aquí a (\\d+[.,]?\\d*) s", - "d'aquí a (\\d+[.,]?\\d*) segon", - "d'aquí a (\\d+[.,]?\\d*) segons" + "d'aquí a (\\d++[.,]?\\d*+) s", + "d'aquí a (\\d++[.,]?\\d*+) segon", + "d'aquí a (\\d++[.,]?\\d*+) segons" ], "in \\1 week": [ - "d'aquí a (\\d+[.,]?\\d*) setm", - "d'aquí a (\\d+[.,]?\\d*) setmana", - "d'aquí a (\\d+[.,]?\\d*) setmanes" + "d'aquí a (\\d++[.,]?\\d*+) setm", + "d'aquí a (\\d++[.,]?\\d*+) setmana", + "d'aquí a (\\d++[.,]?\\d*+) setmanes" ], "in \\1 year": [ - "d'aquí a (\\d+[.,]?\\d*) any", - "d'aquí a (\\d+[.,]?\\d*) anys" + "d'aquí a (\\d++[.,]?\\d*+) any", + "d'aquí a (\\d++[.,]?\\d*+) anys" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ce.py b/dateparser/data/date_translation_data/ce.py index 494d945cd..996f78a3d 100644 --- a/dateparser/data/date_translation_data/ce.py +++ b/dateparser/data/date_translation_data/ce.py @@ -151,60 +151,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) д хьалха", - "(\\d+[.,]?\\d*) де хьалха" + "(\\d++[.,]?\\d*+) д хьалха", + "(\\d++[.,]?\\d*+) де хьалха" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) сахь хьалха", - "(\\d+[.,]?\\d*) сахьт хьалха" + "(\\d++[.,]?\\d*+) сахь хьалха", + "(\\d++[.,]?\\d*+) сахьт хьалха" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мин хьалха", - "(\\d+[.,]?\\d*) минот хьалха" + "(\\d++[.,]?\\d*+) мин хьалха", + "(\\d++[.,]?\\d*+) минот хьалха" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) б хьалха", - "(\\d+[.,]?\\d*) бутт хьалха" + "(\\d++[.,]?\\d*+) б хьалха", + "(\\d++[.,]?\\d*+) бутт хьалха" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сек хьалха", - "(\\d+[.,]?\\d*) секунд хьалха" + "(\\d++[.,]?\\d*+) сек хьалха", + "(\\d++[.,]?\\d*+) секунд хьалха" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) кӏир хьалха", - "(\\d+[.,]?\\d*) кӏира хьалха" + "(\\d++[.,]?\\d*+) кӏир хьалха", + "(\\d++[.,]?\\d*+) кӏира хьалха" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ш хьалха", - "(\\d+[.,]?\\d*) шо хьалха" + "(\\d++[.,]?\\d*+) ш хьалха", + "(\\d++[.,]?\\d*+) шо хьалха" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) д даьлча", - "(\\d+[.,]?\\d*) де даьлча" + "(\\d++[.,]?\\d*+) д даьлча", + "(\\d++[.,]?\\d*+) де даьлча" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) сахь даьлча", - "(\\d+[.,]?\\d*) сахьт даьлча" + "(\\d++[.,]?\\d*+) сахь даьлча", + "(\\d++[.,]?\\d*+) сахьт даьлча" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) мин яьлча", - "(\\d+[.,]?\\d*) минот яьлча" + "(\\d++[.,]?\\d*+) мин яьлча", + "(\\d++[.,]?\\d*+) минот яьлча" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) б баьлча", - "(\\d+[.,]?\\d*) бутт баьлча" + "(\\d++[.,]?\\d*+) б баьлча", + "(\\d++[.,]?\\d*+) бутт баьлча" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сек яьлча", - "(\\d+[.,]?\\d*) секунд яьлча" + "(\\d++[.,]?\\d*+) сек яьлча", + "(\\d++[.,]?\\d*+) секунд яьлча" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) кӏир даьлча", - "(\\d+[.,]?\\d*) кӏира даьлча" + "(\\d++[.,]?\\d*+) кӏир даьлча", + "(\\d++[.,]?\\d*+) кӏира даьлча" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ш даьлча", - "(\\d+[.,]?\\d*) шо даьлча" + "(\\d++[.,]?\\d*+) ш даьлча", + "(\\d++[.,]?\\d*+) шо даьлча" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/chr.py b/dateparser/data/date_translation_data/chr.py index baf375fb6..e9a23a0a3 100644 --- a/dateparser/data/date_translation_data/chr.py +++ b/dateparser/data/date_translation_data/chr.py @@ -158,68 +158,68 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ꭲꭶ ꮵꭸꮢ", - "(\\d+[.,]?\\d*) ꭿꮈꮝꭹ ꮷꮢꭿꮫ ꮵꭸꮢ" + "(\\d++[.,]?\\d*+) ꭲꭶ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꭿꮈꮝꭹ ꮷꮢꭿꮫ ꮵꭸꮢ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ꭲᏻꮯꮆꮣ ꮵꭸꮢ", - "(\\d+[.,]?\\d*) ꮡꮯꮆꮣ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮡꮯ ꮵꭸꮢ" + "(\\d++[.,]?\\d*+) ꭲᏻꮯꮆꮣ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮡꮯꮆꮣ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮡꮯ ꮵꭸꮢ" ], "\\1 minute ago": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꮿꮤ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ" ], "\\1 month ago": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭷꮈ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭷꮈꭲ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮧꭷꮈꭲ ꮵꭸꮢ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈꭲ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮧꭷꮈꭲ ꮵꭸꮢ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ꭰꮞꮲ ꮵꭸꮢ", - "(\\d+[.,]?\\d*) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" + "(\\d++[.,]?\\d*+) ꭰꮞꮲ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], "\\1 week ago": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮢꮎ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ꭲꮷꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", - "(\\d+[.,]?\\d*) ꭴꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭴꮥ ꮵꭸꮢ" + "(\\d++[.,]?\\d*+) ꭲꮷꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꭴꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭴꮥ ꮵꭸꮢ" ], "in \\1 day": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꭶ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭿꮈꮝꭹ ꮷꮢꭿꮫ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꭶ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭿꮈꮝꭹ ꮷꮢꭿꮫ" ], "in \\1 hour": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲᏻꮯꮆꮣ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮡꮯ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮡꮯꮆꮣ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲᏻꮯꮆꮣ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮡꮯ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮡꮯꮆꮣ" ], "in \\1 minute": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꮿꮤ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꮿꮤꮼꮝꮤꮕ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤꮼꮝꮤꮕ" ], "in \\1 month": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭷꮈ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭷꮈꭲ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮧꭷꮈꭲ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈꭲ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮧꭷꮈꭲ" ], "in \\1 second": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭰꮞꮲ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭰꮞꮲ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], "in \\1 week": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲᏻꮎꮩꮣꮖꮝꮧ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮢꮎ", - "ꮎꮏ (\\d+[.,]?\\d*) ꮢꮎꮩꮣꮖꮝꮧ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲᏻꮎꮩꮣꮖꮝꮧ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎꮩꮣꮖꮝꮧ" ], "in \\1 year": [ - "ꮎꮏ (\\d+[.,]?\\d*) ꭲꮷꮥꮨᏼꮜꮧꮢꭲ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭴꮥ", - "ꮎꮏ (\\d+[.,]?\\d*) ꭴꮥꮨᏼꮜꮧꮢꭲ" + "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮷꮥꮨᏼꮜꮧꮢꭲ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭴꮥ", + "ꮎꮏ (\\d++[.,]?\\d*+) ꭴꮥꮨᏼꮜꮧꮢꭲ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index ed7e1ae90..0e21e416a 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -241,95 +241,95 @@ }, "relative-type-regex": { "\\1 day ago": [ - "před (\\d+[.,]?\\d*) dnem", - "před (\\d+[.,]?\\d*) dny" + "před (\\d++[.,]?\\d*+) dnem", + "před (\\d++[.,]?\\d*+) dny" ], "\\1 hour ago": [ - "před (\\d+[.,]?\\d*) h", - "před (\\d+[.,]?\\d*) hodinami", - "před (\\d+[.,]?\\d*) hodinou" + "před (\\d++[.,]?\\d*+) h", + "před (\\d++[.,]?\\d*+) hodinami", + "před (\\d++[.,]?\\d*+) hodinou" ], "\\1 minute ago": [ - "před (\\d+[.,]?\\d*) min", - "před (\\d+[.,]?\\d*) minutami", - "před (\\d+[.,]?\\d*) minutou" + "před (\\d++[.,]?\\d*+) min", + "před (\\d++[.,]?\\d*+) minutami", + "před (\\d++[.,]?\\d*+) minutou" ], "\\1 month ago": [ - "před (\\d+[.,]?\\d*) měs", - "před (\\d+[.,]?\\d*) měsícem", - "před (\\d+[.,]?\\d*) měsíci" + "před (\\d++[.,]?\\d*+) měs", + "před (\\d++[.,]?\\d*+) měsícem", + "před (\\d++[.,]?\\d*+) měsíci" ], "\\1 second ago": [ - "před (\\d+[.,]?\\d*) s", - "před (\\d+[.,]?\\d*) sekundami", - "před (\\d+[.,]?\\d*) sekundou" + "před (\\d++[.,]?\\d*+) s", + "před (\\d++[.,]?\\d*+) sekundami", + "před (\\d++[.,]?\\d*+) sekundou" ], "\\1 week ago": [ - "před (\\d+[.,]?\\d*) týd", - "před (\\d+[.,]?\\d*) týdnem", - "před (\\d+[.,]?\\d*) týdny" + "před (\\d++[.,]?\\d*+) týd", + "před (\\d++[.,]?\\d*+) týdnem", + "před (\\d++[.,]?\\d*+) týdny" ], "\\1 year ago": [ - "před (\\d+[.,]?\\d*) l", - "před (\\d+[.,]?\\d*) lety", - "před (\\d+[.,]?\\d*) r", - "před (\\d+[.,]?\\d*) rokem" + "před (\\d++[.,]?\\d*+) l", + "před (\\d++[.,]?\\d*+) lety", + "před (\\d++[.,]?\\d*+) r", + "před (\\d++[.,]?\\d*+) rokem" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) den", - "za (\\d+[.,]?\\d*) dní" + "za (\\d++[.,]?\\d*+) den", + "za (\\d++[.,]?\\d*+) dní" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) h", - "za (\\d+[.,]?\\d*) hodin", - "za (\\d+[.,]?\\d*) hodinu" + "za (\\d++[.,]?\\d*+) h", + "za (\\d++[.,]?\\d*+) hodin", + "za (\\d++[.,]?\\d*+) hodinu" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minut", - "za (\\d+[.,]?\\d*) minutu" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minut", + "za (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) měs", - "za (\\d+[.,]?\\d*) měsíc", - "za (\\d+[.,]?\\d*) měsíců" + "za (\\d++[.,]?\\d*+) měs", + "za (\\d++[.,]?\\d*+) měsíc", + "za (\\d++[.,]?\\d*+) měsíců" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sekund", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sekund", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) týd", - "za (\\d+[.,]?\\d*) týden", - "za (\\d+[.,]?\\d*) týdnů" + "za (\\d++[.,]?\\d*+) týd", + "za (\\d++[.,]?\\d*+) týden", + "za (\\d++[.,]?\\d*+) týdnů" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) l", - "za (\\d+[.,]?\\d*) let", - "za (\\d+[.,]?\\d*) r", - "za (\\d+[.,]?\\d*) rok" + "za (\\d++[.,]?\\d*+) l", + "za (\\d++[.,]?\\d*+) let", + "za (\\d++[.,]?\\d*+) r", + "za (\\d++[.,]?\\d*+) rok" ], "\\1 decade ago": [ - "před (\\d+[.,]?\\d*) desetiletími", - "před (\\d+[.,]?\\d*) dekádami", - "před (\\d+[.,]?\\d*) dekádou", - "před (\\d+[.,]?\\d*) desetiletím" + "před (\\d++[.,]?\\d*+) desetiletími", + "před (\\d++[.,]?\\d*+) dekádami", + "před (\\d++[.,]?\\d*+) dekádou", + "před (\\d++[.,]?\\d*+) desetiletím" ], "in \\1 decade": [ - "za (\\d+[.,]?\\d*) desetiletí", - "za (\\d+[.,]?\\d*) dekád", - "za (\\d+[.,]?\\d*) dekády", - "za (\\d+[.,]?\\d*) dekádu" + "za (\\d++[.,]?\\d*+) desetiletí", + "za (\\d++[.,]?\\d*+) dekád", + "za (\\d++[.,]?\\d*+) dekády", + "za (\\d++[.,]?\\d*+) dekádu" ], "\\1 century ago": [ - "před (\\d+[.,]?\\d*) staletími", - "před (\\d+[.,]?\\d*) stoletími", - "před (\\d+[.,]?\\d*) stoletím" + "před (\\d++[.,]?\\d*+) staletími", + "před (\\d++[.,]?\\d*+) stoletími", + "před (\\d++[.,]?\\d*+) stoletím" ], "in \\1 century": [ - "za (\\d+[.,]?\\d*) staletí", - "za (\\d+[.,]?\\d*) století" + "za (\\d++[.,]?\\d*+) staletí", + "za (\\d++[.,]?\\d*+) století" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/cy.py b/dateparser/data/date_translation_data/cy.py index da5e8a8d5..bb1cc1356 100644 --- a/dateparser/data/date_translation_data/cy.py +++ b/dateparser/data/date_translation_data/cy.py @@ -155,48 +155,48 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) diwrnod yn ôl" + "(\\d++[.,]?\\d*+) diwrnod yn ôl" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) awr yn ôl" + "(\\d++[.,]?\\d*+) awr yn ôl" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) mun yn ôl", - "(\\d+[.,]?\\d*) munud yn ôl" + "(\\d++[.,]?\\d*+) mun yn ôl", + "(\\d++[.,]?\\d*+) munud yn ôl" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mis yn ôl" + "(\\d++[.,]?\\d*+) mis yn ôl" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) eiliad yn ôl" + "(\\d++[.,]?\\d*+) eiliad yn ôl" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) wythnos yn ôl" + "(\\d++[.,]?\\d*+) wythnos yn ôl" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) o flynyddoedd yn ôl" + "(\\d++[.,]?\\d*+) o flynyddoedd yn ôl" ], "in \\1 day": [ - "ymhen (\\d+[.,]?\\d*) diwrnod" + "ymhen (\\d++[.,]?\\d*+) diwrnod" ], "in \\1 hour": [ - "ymhen (\\d+[.,]?\\d*) awr" + "ymhen (\\d++[.,]?\\d*+) awr" ], "in \\1 minute": [ - "ymhen (\\d+[.,]?\\d*) mun", - "ymhen (\\d+[.,]?\\d*) munud" + "ymhen (\\d++[.,]?\\d*+) mun", + "ymhen (\\d++[.,]?\\d*+) munud" ], "in \\1 month": [ - "ymhen (\\d+[.,]?\\d*) mis" + "ymhen (\\d++[.,]?\\d*+) mis" ], "in \\1 second": [ - "ymhen (\\d+[.,]?\\d*) eiliad" + "ymhen (\\d++[.,]?\\d*+) eiliad" ], "in \\1 week": [ - "ymhen (\\d+[.,]?\\d*) wythnos" + "ymhen (\\d++[.,]?\\d*+) wythnos" ], "in \\1 year": [ - "ymhen (\\d+[.,]?\\d*) mlynedd" + "ymhen (\\d++[.,]?\\d*+) mlynedd" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/da.py b/dateparser/data/date_translation_data/da.py index 9350b648a..382cf1f3b 100644 --- a/dateparser/data/date_translation_data/da.py +++ b/dateparser/data/date_translation_data/da.py @@ -166,72 +166,72 @@ }, "relative-type-regex": { "\\1 day ago": [ - "for (\\d+[.,]?\\d*) dag siden", - "for (\\d+[.,]?\\d*) dage siden" + "for (\\d++[.,]?\\d*+) dag siden", + "for (\\d++[.,]?\\d*+) dage siden" ], "\\1 hour ago": [ - "for (\\d+[.,]?\\d*) time siden", - "for (\\d+[.,]?\\d*) timer siden", - "for (\\d+[.,]?\\d*)\\s*h", - "for (\\d+[.,]?\\d*) timer" + "for (\\d++[.,]?\\d*+) time siden", + "for (\\d++[.,]?\\d*+) timer siden", + "for (\\d++[.,]?\\d*+)\\s*h", + "for (\\d++[.,]?\\d*+) timer" ], "\\1 minute ago": [ - "for (\\d+[.,]?\\d*) min siden", - "for (\\d+[.,]?\\d*) minut siden", - "for (\\d+[.,]?\\d*) minutter siden", - "for (\\d+[.,]?\\d*)\\s*m", - "for (\\d+[.,]?\\d*) minutter" + "for (\\d++[.,]?\\d*+) min siden", + "for (\\d++[.,]?\\d*+) minut siden", + "for (\\d++[.,]?\\d*+) minutter siden", + "for (\\d++[.,]?\\d*+)\\s*m", + "for (\\d++[.,]?\\d*+) minutter" ], "\\1 month ago": [ - "for (\\d+[.,]?\\d*) md siden", - "for (\\d+[.,]?\\d*) mdr siden", - "for (\\d+[.,]?\\d*) måned siden", - "for (\\d+[.,]?\\d*) måneder siden" + "for (\\d++[.,]?\\d*+) md siden", + "for (\\d++[.,]?\\d*+) mdr siden", + "for (\\d++[.,]?\\d*+) måned siden", + "for (\\d++[.,]?\\d*+) måneder siden" ], "\\1 second ago": [ - "for (\\d+[.,]?\\d*) sek siden", - "for (\\d+[.,]?\\d*) sekund siden", - "for (\\d+[.,]?\\d*) sekunder siden", - "for (\\d+[.,]?\\d*)\\s*s", - "for (\\d+[.,]?\\d*) sekunder" + "for (\\d++[.,]?\\d*+) sek siden", + "for (\\d++[.,]?\\d*+) sekund siden", + "for (\\d++[.,]?\\d*+) sekunder siden", + "for (\\d++[.,]?\\d*+)\\s*s", + "for (\\d++[.,]?\\d*+) sekunder" ], "\\1 week ago": [ - "for (\\d+[.,]?\\d*) uge siden", - "for (\\d+[.,]?\\d*) uger siden" + "for (\\d++[.,]?\\d*+) uge siden", + "for (\\d++[.,]?\\d*+) uger siden" ], "\\1 year ago": [ - "for (\\d+[.,]?\\d*) år siden" + "for (\\d++[.,]?\\d*+) år siden" ], "in \\1 day": [ - "om (\\d+[.,]?\\d*) dag", - "om (\\d+[.,]?\\d*) dage" + "om (\\d++[.,]?\\d*+) dag", + "om (\\d++[.,]?\\d*+) dage" ], "in \\1 hour": [ - "om (\\d+[.,]?\\d*) time", - "om (\\d+[.,]?\\d*) timer" + "om (\\d++[.,]?\\d*+) time", + "om (\\d++[.,]?\\d*+) timer" ], "in \\1 minute": [ - "om (\\d+[.,]?\\d*) min", - "om (\\d+[.,]?\\d*) minut", - "om (\\d+[.,]?\\d*) minutter" + "om (\\d++[.,]?\\d*+) min", + "om (\\d++[.,]?\\d*+) minut", + "om (\\d++[.,]?\\d*+) minutter" ], "in \\1 month": [ - "om (\\d+[.,]?\\d*) md", - "om (\\d+[.,]?\\d*) mdr", - "om (\\d+[.,]?\\d*) måned", - "om (\\d+[.,]?\\d*) måneder" + "om (\\d++[.,]?\\d*+) md", + "om (\\d++[.,]?\\d*+) mdr", + "om (\\d++[.,]?\\d*+) måned", + "om (\\d++[.,]?\\d*+) måneder" ], "in \\1 second": [ - "om (\\d+[.,]?\\d*) sek", - "om (\\d+[.,]?\\d*) sekund", - "om (\\d+[.,]?\\d*) sekunder" + "om (\\d++[.,]?\\d*+) sek", + "om (\\d++[.,]?\\d*+) sekund", + "om (\\d++[.,]?\\d*+) sekunder" ], "in \\1 week": [ - "om (\\d+[.,]?\\d*) uge", - "om (\\d+[.,]?\\d*) uger" + "om (\\d++[.,]?\\d*+) uge", + "om (\\d++[.,]?\\d*+) uger" ], "in \\1 year": [ - "om (\\d+[.,]?\\d*) år" + "om (\\d++[.,]?\\d*+) år" ] }, "locale_specific": { @@ -272,13 +272,13 @@ "et": "1" }, { - "(\\d+[.,]?\\d*)\\s*hr(s?)": "\\1 time\\2" + "(\\d++[.,]?\\d*+)\\s*hr(s?)": "\\1 time\\2" }, { - "(\\d+[.,]?\\d*)\\s*min(s?)": "\\1 minut\\2" + "(\\d++[.,]?\\d*+)\\s*min(s?)": "\\1 minut\\2" }, { - "(\\d+[.,]?\\d*)\\s*sec(s?)": "\\1 sekund\\2" + "(\\d++[.,]?\\d*+)\\s*sec(s?)": "\\1 sekund\\2" }, { "middag": "12:00" @@ -287,7 +287,7 @@ "midnat": "00:00" }, { - "(\\d+[.,]?\\d*)h(\\d+[.,]?\\d*)m?": "\\1:\\2" + "(\\d++[.,]?\\d*+)h(\\d++[.,]?\\d*+)m?": "\\1:\\2" }, { "mindre end 1 minut siden": "45 seconds" diff --git a/dateparser/data/date_translation_data/de.py b/dateparser/data/date_translation_data/de.py index dcf9a0b11..4fdcb43ed 100644 --- a/dateparser/data/date_translation_data/de.py +++ b/dateparser/data/date_translation_data/de.py @@ -185,75 +185,75 @@ }, "relative-type-regex": { "\\1 day ago": [ - "vor (\\d+[.,]?\\d*) tag", - "vor (\\d+[.,]?\\d*) tagen" + "vor (\\d++[.,]?\\d*+) tag", + "vor (\\d++[.,]?\\d*+) tagen" ], "\\1 hour ago": [ - "vor (\\d+[.,]?\\d*) std", - "vor (\\d+[.,]?\\d*) stunde", - "vor (\\d+[.,]?\\d*) stunden", - "vor (\\d+[.,]?\\d*)\\s*h" + "vor (\\d++[.,]?\\d*+) std", + "vor (\\d++[.,]?\\d*+) stunde", + "vor (\\d++[.,]?\\d*+) stunden", + "vor (\\d++[.,]?\\d*+)\\s*h" ], "\\1 minute ago": [ - "vor (\\d+[.,]?\\d*) m", - "vor (\\d+[.,]?\\d*) min", - "vor (\\d+[.,]?\\d*) minute", - "vor (\\d+[.,]?\\d*) minuten", - "vor (\\d+[.,]?\\d*)\\s*m" + "vor (\\d++[.,]?\\d*+) m", + "vor (\\d++[.,]?\\d*+) min", + "vor (\\d++[.,]?\\d*+) minute", + "vor (\\d++[.,]?\\d*+) minuten", + "vor (\\d++[.,]?\\d*+)\\s*m" ], "\\1 month ago": [ - "vor (\\d+[.,]?\\d*) monat", - "vor (\\d+[.,]?\\d*) monaten" + "vor (\\d++[.,]?\\d*+) monat", + "vor (\\d++[.,]?\\d*+) monaten" ], "\\1 second ago": [ - "vor (\\d+[.,]?\\d*) s", - "vor (\\d+[.,]?\\d*) sek", - "vor (\\d+[.,]?\\d*) sekunde", - "vor (\\d+[.,]?\\d*) sekunden", - "vor (\\d+[.,]?\\d*)\\s*s" + "vor (\\d++[.,]?\\d*+) s", + "vor (\\d++[.,]?\\d*+) sek", + "vor (\\d++[.,]?\\d*+) sekunde", + "vor (\\d++[.,]?\\d*+) sekunden", + "vor (\\d++[.,]?\\d*+)\\s*s" ], "\\1 week ago": [ - "vor (\\d+[.,]?\\d*) wo", - "vor (\\d+[.,]?\\d*) woche", - "vor (\\d+[.,]?\\d*) wochen" + "vor (\\d++[.,]?\\d*+) wo", + "vor (\\d++[.,]?\\d*+) woche", + "vor (\\d++[.,]?\\d*+) wochen" ], "\\1 year ago": [ - "vor (\\d+[.,]?\\d*) jahr", - "vor (\\d+[.,]?\\d*) jahren" + "vor (\\d++[.,]?\\d*+) jahr", + "vor (\\d++[.,]?\\d*+) jahren" ], "in \\1 day": [ - "in (\\d+[.,]?\\d*) tag", - "in (\\d+[.,]?\\d*) tagen" + "in (\\d++[.,]?\\d*+) tag", + "in (\\d++[.,]?\\d*+) tagen" ], "in \\1 hour": [ - "in (\\d+[.,]?\\d*) std", - "in (\\d+[.,]?\\d*) stunde", - "in (\\d+[.,]?\\d*) stunden" + "in (\\d++[.,]?\\d*+) std", + "in (\\d++[.,]?\\d*+) stunde", + "in (\\d++[.,]?\\d*+) stunden" ], "in \\1 minute": [ - "in (\\d+[.,]?\\d*) m", - "in (\\d+[.,]?\\d*) min", - "in (\\d+[.,]?\\d*) minute", - "in (\\d+[.,]?\\d*) minuten" + "in (\\d++[.,]?\\d*+) m", + "in (\\d++[.,]?\\d*+) min", + "in (\\d++[.,]?\\d*+) minute", + "in (\\d++[.,]?\\d*+) minuten" ], "in \\1 month": [ - "in (\\d+[.,]?\\d*) monat", - "in (\\d+[.,]?\\d*) monaten" + "in (\\d++[.,]?\\d*+) monat", + "in (\\d++[.,]?\\d*+) monaten" ], "in \\1 second": [ - "in (\\d+[.,]?\\d*) s", - "in (\\d+[.,]?\\d*) sek", - "in (\\d+[.,]?\\d*) sekunde", - "in (\\d+[.,]?\\d*) sekunden" + "in (\\d++[.,]?\\d*+) s", + "in (\\d++[.,]?\\d*+) sek", + "in (\\d++[.,]?\\d*+) sekunde", + "in (\\d++[.,]?\\d*+) sekunden" ], "in \\1 week": [ - "in (\\d+[.,]?\\d*) wo", - "in (\\d+[.,]?\\d*) woche", - "in (\\d+[.,]?\\d*) wochen" + "in (\\d++[.,]?\\d*+) wo", + "in (\\d++[.,]?\\d*+) woche", + "in (\\d++[.,]?\\d*+) wochen" ], "in \\1 year": [ - "in (\\d+[.,]?\\d*) jahr", - "in (\\d+[.,]?\\d*) jahren" + "in (\\d++[.,]?\\d*+) jahr", + "in (\\d++[.,]?\\d*+) jahren" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/dsb.py b/dateparser/data/date_translation_data/dsb.py index 086d4ed96..0cabbb532 100644 --- a/dateparser/data/date_translation_data/dsb.py +++ b/dateparser/data/date_translation_data/dsb.py @@ -174,82 +174,82 @@ }, "relative-type-regex": { "\\1 day ago": [ - "pśed (\\d+[.,]?\\d*) d", - "pśed (\\d+[.,]?\\d*) dnj", - "pśed (\\d+[.,]?\\d*) dnjami", - "pśed (\\d+[.,]?\\d*) dnjom" + "pśed (\\d++[.,]?\\d*+) d", + "pśed (\\d++[.,]?\\d*+) dnj", + "pśed (\\d++[.,]?\\d*+) dnjami", + "pśed (\\d++[.,]?\\d*+) dnjom" ], "\\1 hour ago": [ - "pśed (\\d+[.,]?\\d*) g", - "pśed (\\d+[.,]?\\d*) góź", - "pśed (\\d+[.,]?\\d*) góźinami", - "pśed (\\d+[.,]?\\d*) góźinu" + "pśed (\\d++[.,]?\\d*+) g", + "pśed (\\d++[.,]?\\d*+) góź", + "pśed (\\d++[.,]?\\d*+) góźinami", + "pśed (\\d++[.,]?\\d*+) góźinu" ], "\\1 minute ago": [ - "pśed (\\d+[.,]?\\d*) m", - "pśed (\\d+[.,]?\\d*) min", - "pśed (\\d+[.,]?\\d*) minutami", - "pśed (\\d+[.,]?\\d*) minutu" + "pśed (\\d++[.,]?\\d*+) m", + "pśed (\\d++[.,]?\\d*+) min", + "pśed (\\d++[.,]?\\d*+) minutami", + "pśed (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "pśed (\\d+[.,]?\\d*) mjas", - "pśed (\\d+[.,]?\\d*) mjasecami", - "pśed (\\d+[.,]?\\d*) mjasecom" + "pśed (\\d++[.,]?\\d*+) mjas", + "pśed (\\d++[.,]?\\d*+) mjasecami", + "pśed (\\d++[.,]?\\d*+) mjasecom" ], "\\1 second ago": [ - "pśed (\\d+[.,]?\\d*) s", - "pśed (\\d+[.,]?\\d*) sek", - "pśed (\\d+[.,]?\\d*) sekundami", - "pśed (\\d+[.,]?\\d*) sekundu" + "pśed (\\d++[.,]?\\d*+) s", + "pśed (\\d++[.,]?\\d*+) sek", + "pśed (\\d++[.,]?\\d*+) sekundami", + "pśed (\\d++[.,]?\\d*+) sekundu" ], "\\1 week ago": [ - "pśed (\\d+[.,]?\\d*) tyź", - "pśed (\\d+[.,]?\\d*) tyźenjami", - "pśed (\\d+[.,]?\\d*) tyźenjom" + "pśed (\\d++[.,]?\\d*+) tyź", + "pśed (\\d++[.,]?\\d*+) tyźenjami", + "pśed (\\d++[.,]?\\d*+) tyźenjom" ], "\\1 year ago": [ - "pśed (\\d+[.,]?\\d*) l", - "pśed (\\d+[.,]?\\d*) lětami", - "pśed (\\d+[.,]?\\d*) lětom" + "pśed (\\d++[.,]?\\d*+) l", + "pśed (\\d++[.,]?\\d*+) lětami", + "pśed (\\d++[.,]?\\d*+) lětom" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) dnj", - "za (\\d+[.,]?\\d*) dnjow", - "za (\\d+[.,]?\\d*) ź", - "za (\\d+[.,]?\\d*) źeń" + "za (\\d++[.,]?\\d*+) dnj", + "za (\\d++[.,]?\\d*+) dnjow", + "za (\\d++[.,]?\\d*+) ź", + "za (\\d++[.,]?\\d*+) źeń" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) góź", - "za (\\d+[.,]?\\d*) góźin", - "za (\\d+[.,]?\\d*) góźinu" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) góź", + "za (\\d++[.,]?\\d*+) góźin", + "za (\\d++[.,]?\\d*+) góźinu" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) m", - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minutow", - "za (\\d+[.,]?\\d*) minutu" + "za (\\d++[.,]?\\d*+) m", + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minutow", + "za (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) mjas", - "za (\\d+[.,]?\\d*) mjasec", - "za (\\d+[.,]?\\d*) mjasecow" + "za (\\d++[.,]?\\d*+) mjas", + "za (\\d++[.,]?\\d*+) mjasec", + "za (\\d++[.,]?\\d*+) mjasecow" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundow", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundow", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) tyź", - "za (\\d+[.,]?\\d*) tyźenjow", - "za (\\d+[.,]?\\d*) tyźeń" + "za (\\d++[.,]?\\d*+) tyź", + "za (\\d++[.,]?\\d*+) tyźenjow", + "za (\\d++[.,]?\\d*+) tyźeń" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) l", - "za (\\d+[.,]?\\d*) lět", - "za (\\d+[.,]?\\d*) lěto" + "za (\\d++[.,]?\\d*+) l", + "za (\\d++[.,]?\\d*+) lět", + "za (\\d++[.,]?\\d*+) lěto" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/dz.py b/dateparser/data/date_translation_data/dz.py index d1d9013dd..9419439df 100644 --- a/dateparser/data/date_translation_data/dz.py +++ b/dateparser/data/date_translation_data/dz.py @@ -165,46 +165,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "ཉིནམ་ (\\d+[.,]?\\d*) ཧེ་མ་" + "ཉིནམ་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 hour ago": [ - "ཆུ་ཚོད་ (\\d+[.,]?\\d*) ཧེ་མ་" + "ཆུ་ཚོད་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 minute ago": [ - "སྐར་མ་ (\\d+[.,]?\\d*) ཧེ་མ་" + "སྐར་མ་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 month ago": [ - "ཟླཝ་ (\\d+[.,]?\\d*) ཧེ་མ་" + "ཟླཝ་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 second ago": [ - "སྐར་ཆ་ (\\d+[.,]?\\d*) ཧེ་མ་" + "སྐར་ཆ་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 week ago": [ - "བངུན་ཕྲག་ (\\d+[.,]?\\d*) ཧེ་མ་" + "བངུན་ཕྲག་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "\\1 year ago": [ - "ལོ་འཁོར་ (\\d+[.,]?\\d*) ཧེ་མ་" + "ལོ་འཁོར་ (\\d++[.,]?\\d*+) ཧེ་མ་" ], "in \\1 day": [ - "ཉིནམ་ (\\d+[.,]?\\d*) ནང་" + "ཉིནམ་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 hour": [ - "ཆུ་ཚོད་ (\\d+[.,]?\\d*) ནང་" + "ཆུ་ཚོད་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 minute": [ - "སྐར་མ་ (\\d+[.,]?\\d*) ནང་" + "སྐར་མ་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 month": [ - "ཟླཝ་ (\\d+[.,]?\\d*) ནང་" + "ཟླཝ་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 second": [ - "སྐར་ཆ་ (\\d+[.,]?\\d*) ནང་" + "སྐར་ཆ་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 week": [ - "བངུན་ཕྲག་ (\\d+[.,]?\\d*) ནང་" + "བངུན་ཕྲག་ (\\d++[.,]?\\d*+) ནང་" ], "in \\1 year": [ - "ལོ་འཁོར་ (\\d+[.,]?\\d*) ནང་" + "ལོ་འཁོར་ (\\d++[.,]?\\d*+) ནང་" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ee.py b/dateparser/data/date_translation_data/ee.py index b6068c50d..8c46eb098 100644 --- a/dateparser/data/date_translation_data/ee.py +++ b/dateparser/data/date_translation_data/ee.py @@ -153,62 +153,62 @@ }, "relative-type-regex": { "\\1 day ago": [ - "ŋkeke (\\d+[.,]?\\d*) si va yi", - "ŋkeke (\\d+[.,]?\\d*) si wo va yi" + "ŋkeke (\\d++[.,]?\\d*+) si va yi", + "ŋkeke (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 hour ago": [ - "gaƒoƒo (\\d+[.,]?\\d*) si va yi", - "gaƒoƒo (\\d+[.,]?\\d*) si wo va yi" + "gaƒoƒo (\\d++[.,]?\\d*+) si va yi", + "gaƒoƒo (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 minute ago": [ - "aɖabaƒoƒo (\\d+[.,]?\\d*) si va yi", - "aɖabaƒoƒo (\\d+[.,]?\\d*) si wo va yi" + "aɖabaƒoƒo (\\d++[.,]?\\d*+) si va yi", + "aɖabaƒoƒo (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 month ago": [ - "ɣleti (\\d+[.,]?\\d*) si va yi", - "ɣleti (\\d+[.,]?\\d*) si wo va yi" + "ɣleti (\\d++[.,]?\\d*+) si va yi", + "ɣleti (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 second ago": [ - "sekend (\\d+[.,]?\\d*) si va yi", - "sekend (\\d+[.,]?\\d*) si wo va yi" + "sekend (\\d++[.,]?\\d*+) si va yi", + "sekend (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 week ago": [ - "kɔsiɖa (\\d+[.,]?\\d*) si va yi", - "kɔsiɖa (\\d+[.,]?\\d*) si wo va yi" + "kɔsiɖa (\\d++[.,]?\\d*+) si va yi", + "kɔsiɖa (\\d++[.,]?\\d*+) si wo va yi" ], "\\1 year ago": [ - "le ƒe (\\d+[.,]?\\d*) si va yi me", - "ƒe (\\d+[.,]?\\d*) si va yi", - "ƒe (\\d+[.,]?\\d*) si va yi me", - "ƒe (\\d+[.,]?\\d*) si wo va yi" + "le ƒe (\\d++[.,]?\\d*+) si va yi me", + "ƒe (\\d++[.,]?\\d*+) si va yi", + "ƒe (\\d++[.,]?\\d*+) si va yi me", + "ƒe (\\d++[.,]?\\d*+) si wo va yi" ], "in \\1 day": [ - "le ŋkeke (\\d+[.,]?\\d*) me", - "le ŋkeke (\\d+[.,]?\\d*) wo me" + "le ŋkeke (\\d++[.,]?\\d*+) me", + "le ŋkeke (\\d++[.,]?\\d*+) wo me" ], "in \\1 hour": [ - "le gaƒoƒo (\\d+[.,]?\\d*) me", - "le gaƒoƒo (\\d+[.,]?\\d*) wo me" + "le gaƒoƒo (\\d++[.,]?\\d*+) me", + "le gaƒoƒo (\\d++[.,]?\\d*+) wo me" ], "in \\1 minute": [ - "le aɖabaƒoƒo (\\d+[.,]?\\d*) me", - "le aɖabaƒoƒo (\\d+[.,]?\\d*) wo me" + "le aɖabaƒoƒo (\\d++[.,]?\\d*+) me", + "le aɖabaƒoƒo (\\d++[.,]?\\d*+) wo me" ], "in \\1 month": [ - "le ɣleti (\\d+[.,]?\\d*) me", - "le ɣleti (\\d+[.,]?\\d*) wo me" + "le ɣleti (\\d++[.,]?\\d*+) me", + "le ɣleti (\\d++[.,]?\\d*+) wo me" ], "in \\1 second": [ - "le sekend (\\d+[.,]?\\d*) me", - "le sekend (\\d+[.,]?\\d*) wo me" + "le sekend (\\d++[.,]?\\d*+) me", + "le sekend (\\d++[.,]?\\d*+) wo me" ], "in \\1 week": [ - "le kɔsiɖa (\\d+[.,]?\\d*) me", - "le kɔsiɖa (\\d+[.,]?\\d*) wo me" + "le kɔsiɖa (\\d++[.,]?\\d*+) me", + "le kɔsiɖa (\\d++[.,]?\\d*+) wo me" ], "in \\1 year": [ - "le ƒe (\\d+[.,]?\\d*) me", - "le ƒe (\\d+[.,]?\\d*) si gbɔna me" + "le ƒe (\\d++[.,]?\\d*+) me", + "le ƒe (\\d++[.,]?\\d*+) si gbɔna me" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/el.py b/dateparser/data/date_translation_data/el.py index 12c793285..6fb5d76b9 100644 --- a/dateparser/data/date_translation_data/el.py +++ b/dateparser/data/date_translation_data/el.py @@ -180,81 +180,81 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ημ πριν", - "πριν από (\\d+[.,]?\\d*) ημέρα", - "πριν από (\\d+[.,]?\\d*) ημέρες" + "(\\d++[.,]?\\d*+) ημ πριν", + "πριν από (\\d++[.,]?\\d*+) ημέρα", + "πριν από (\\d++[.,]?\\d*+) ημέρες" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ώ πριν", - "πριν από (\\d+[.,]?\\d*) ώρ", - "πριν από (\\d+[.,]?\\d*) ώρα", - "πριν από (\\d+[.,]?\\d*) ώρες" + "(\\d++[.,]?\\d*+) ώ πριν", + "πριν από (\\d++[.,]?\\d*+) ώρ", + "πριν από (\\d++[.,]?\\d*+) ώρα", + "πριν από (\\d++[.,]?\\d*+) ώρες" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) λ πριν", - "πριν από (\\d+[.,]?\\d*) λεπ", - "πριν από (\\d+[.,]?\\d*) λεπτά", - "πριν από (\\d+[.,]?\\d*) λεπτό" + "(\\d++[.,]?\\d*+) λ πριν", + "πριν από (\\d++[.,]?\\d*+) λεπ", + "πριν από (\\d++[.,]?\\d*+) λεπτά", + "πριν από (\\d++[.,]?\\d*+) λεπτό" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) μ πριν", - "πριν από (\\d+[.,]?\\d*) μήνα", - "πριν από (\\d+[.,]?\\d*) μήνες" + "(\\d++[.,]?\\d*+) μ πριν", + "πριν από (\\d++[.,]?\\d*+) μήνα", + "πριν από (\\d++[.,]?\\d*+) μήνες" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) δ πριν", - "πριν από (\\d+[.,]?\\d*) δευτ", - "πριν από (\\d+[.,]?\\d*) δευτερόλεπτα", - "πριν από (\\d+[.,]?\\d*) δευτερόλεπτο" + "(\\d++[.,]?\\d*+) δ πριν", + "πριν από (\\d++[.,]?\\d*+) δευτ", + "πριν από (\\d++[.,]?\\d*+) δευτερόλεπτα", + "πριν από (\\d++[.,]?\\d*+) δευτερόλεπτο" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) εβδ πριν", - "πριν από (\\d+[.,]?\\d*) εβδ", - "πριν από (\\d+[.,]?\\d*) εβδομάδα", - "πριν από (\\d+[.,]?\\d*) εβδομάδες" + "(\\d++[.,]?\\d*+) εβδ πριν", + "πριν από (\\d++[.,]?\\d*+) εβδ", + "πριν από (\\d++[.,]?\\d*+) εβδομάδα", + "πριν από (\\d++[.,]?\\d*+) εβδομάδες" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) έτη πριν", - "(\\d+[.,]?\\d*) έτος πριν", - "πριν από (\\d+[.,]?\\d*) έτη", - "πριν από (\\d+[.,]?\\d*) έτος" + "(\\d++[.,]?\\d*+) έτη πριν", + "(\\d++[.,]?\\d*+) έτος πριν", + "πριν από (\\d++[.,]?\\d*+) έτη", + "πριν από (\\d++[.,]?\\d*+) έτος" ], "in \\1 day": [ - "σε (\\d+[.,]?\\d*) ημ", - "σε (\\d+[.,]?\\d*) ημέρα", - "σε (\\d+[.,]?\\d*) ημέρες" + "σε (\\d++[.,]?\\d*+) ημ", + "σε (\\d++[.,]?\\d*+) ημέρα", + "σε (\\d++[.,]?\\d*+) ημέρες" ], "in \\1 hour": [ - "σε (\\d+[.,]?\\d*) ώ", - "σε (\\d+[.,]?\\d*) ώρ", - "σε (\\d+[.,]?\\d*) ώρα", - "σε (\\d+[.,]?\\d*) ώρες" + "σε (\\d++[.,]?\\d*+) ώ", + "σε (\\d++[.,]?\\d*+) ώρ", + "σε (\\d++[.,]?\\d*+) ώρα", + "σε (\\d++[.,]?\\d*+) ώρες" ], "in \\1 minute": [ - "σε (\\d+[.,]?\\d*) λ", - "σε (\\d+[.,]?\\d*) λεπ", - "σε (\\d+[.,]?\\d*) λεπτά", - "σε (\\d+[.,]?\\d*) λεπτό" + "σε (\\d++[.,]?\\d*+) λ", + "σε (\\d++[.,]?\\d*+) λεπ", + "σε (\\d++[.,]?\\d*+) λεπτά", + "σε (\\d++[.,]?\\d*+) λεπτό" ], "in \\1 month": [ - "σε (\\d+[.,]?\\d*) μ", - "σε (\\d+[.,]?\\d*) μήνα", - "σε (\\d+[.,]?\\d*) μήνες" + "σε (\\d++[.,]?\\d*+) μ", + "σε (\\d++[.,]?\\d*+) μήνα", + "σε (\\d++[.,]?\\d*+) μήνες" ], "in \\1 second": [ - "σε (\\d+[.,]?\\d*) δ", - "σε (\\d+[.,]?\\d*) δευτ", - "σε (\\d+[.,]?\\d*) δευτερόλεπτα", - "σε (\\d+[.,]?\\d*) δευτερόλεπτο" + "σε (\\d++[.,]?\\d*+) δ", + "σε (\\d++[.,]?\\d*+) δευτ", + "σε (\\d++[.,]?\\d*+) δευτερόλεπτα", + "σε (\\d++[.,]?\\d*+) δευτερόλεπτο" ], "in \\1 week": [ - "σε (\\d+[.,]?\\d*) εβδ", - "σε (\\d+[.,]?\\d*) εβδομάδα", - "σε (\\d+[.,]?\\d*) εβδομάδες" + "σε (\\d++[.,]?\\d*+) εβδ", + "σε (\\d++[.,]?\\d*+) εβδομάδα", + "σε (\\d++[.,]?\\d*+) εβδομάδες" ], "in \\1 year": [ - "σε (\\d+[.,]?\\d*) έτη", - "σε (\\d+[.,]?\\d*) έτος" + "σε (\\d++[.,]?\\d*+) έτη", + "σε (\\d++[.,]?\\d*+) έτος" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index 39241c07c..ecb048c0e 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -205,80 +205,80 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) day ago", - "(\\d+[.,]?\\d*) days ago" + "(\\d++[.,]?\\d*+) day ago", + "(\\d++[.,]?\\d*+) days ago" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) hour ago", - "(\\d+[.,]?\\d*) hours ago", - "(\\d+[.,]?\\d*) hr ago" + "(\\d++[.,]?\\d*+) hour ago", + "(\\d++[.,]?\\d*+) hours ago", + "(\\d++[.,]?\\d*+) hr ago" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min ago", - "(\\d+[.,]?\\d*) minute ago", - "(\\d+[.,]?\\d*) minutes ago" + "(\\d++[.,]?\\d*+) min ago", + "(\\d++[.,]?\\d*+) minute ago", + "(\\d++[.,]?\\d*+) minutes ago" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mo ago", - "(\\d+[.,]?\\d*) month ago", - "(\\d+[.,]?\\d*) months ago" + "(\\d++[.,]?\\d*+) mo ago", + "(\\d++[.,]?\\d*+) month ago", + "(\\d++[.,]?\\d*+) months ago" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sec ago", - "(\\d+[.,]?\\d*) second ago", - "(\\d+[.,]?\\d*) seconds ago" + "(\\d++[.,]?\\d*+) sec ago", + "(\\d++[.,]?\\d*+) second ago", + "(\\d++[.,]?\\d*+) seconds ago" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) week ago", - "(\\d+[.,]?\\d*) weeks ago", - "(\\d+[.,]?\\d*) wk ago" + "(\\d++[.,]?\\d*+) week ago", + "(\\d++[.,]?\\d*+) weeks ago", + "(\\d++[.,]?\\d*+) wk ago" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) year ago", - "(\\d+[.,]?\\d*) years ago", - "(\\d+[.,]?\\d*) yr ago" + "(\\d++[.,]?\\d*+) year ago", + "(\\d++[.,]?\\d*+) years ago", + "(\\d++[.,]?\\d*+) yr ago" ], "in \\1 day": [ - "in (\\d+[.,]?\\d*) day", - "in (\\d+[.,]?\\d*) days" + "in (\\d++[.,]?\\d*+) day", + "in (\\d++[.,]?\\d*+) days" ], "in \\1 hour": [ - "in (\\d+[.,]?\\d*) hour", - "in (\\d+[.,]?\\d*) hours", - "in (\\d+[.,]?\\d*) hr" + "in (\\d++[.,]?\\d*+) hour", + "in (\\d++[.,]?\\d*+) hours", + "in (\\d++[.,]?\\d*+) hr" ], "in \\1 minute": [ - "in (\\d+[.,]?\\d*) min", - "in (\\d+[.,]?\\d*) minute", - "in (\\d+[.,]?\\d*) minutes" + "in (\\d++[.,]?\\d*+) min", + "in (\\d++[.,]?\\d*+) minute", + "in (\\d++[.,]?\\d*+) minutes" ], "in \\1 month": [ - "in (\\d+[.,]?\\d*) mo", - "in (\\d+[.,]?\\d*) month", - "in (\\d+[.,]?\\d*) months" + "in (\\d++[.,]?\\d*+) mo", + "in (\\d++[.,]?\\d*+) month", + "in (\\d++[.,]?\\d*+) months" ], "in \\1 second": [ - "in (\\d+[.,]?\\d*) sec", - "in (\\d+[.,]?\\d*) second", - "in (\\d+[.,]?\\d*) seconds" + "in (\\d++[.,]?\\d*+) sec", + "in (\\d++[.,]?\\d*+) second", + "in (\\d++[.,]?\\d*+) seconds" ], "in \\1 week": [ - "in (\\d+[.,]?\\d*) week", - "in (\\d+[.,]?\\d*) weeks", - "in (\\d+[.,]?\\d*) weeks time", - "in (\\d+[.,]?\\d*) weeks' time", - "in (\\d+[.,]?\\d*) wk" + "in (\\d++[.,]?\\d*+) week", + "in (\\d++[.,]?\\d*+) weeks", + "in (\\d++[.,]?\\d*+) weeks time", + "in (\\d++[.,]?\\d*+) weeks' time", + "in (\\d++[.,]?\\d*+) wk" ], "in \\1 year": [ - "in (\\d+[.,]?\\d*) year", - "in (\\d+[.,]?\\d*) years", - "in (\\d+[.,]?\\d*) yr" + "in (\\d++[.,]?\\d*+) year", + "in (\\d++[.,]?\\d*+) years", + "in (\\d++[.,]?\\d*+) yr" ], "in \\1 decade": [ - "in (\\d+[.,]?\\d*) decades?" + "in (\\d++[.,]?\\d*+) decades?" ], "\\1 decade ago": [ - "(\\d+[.,]?\\d*) decades? ago" + "(\\d++[.,]?\\d*+) decades? ago" ] }, "locale_specific": { @@ -344,40 +344,40 @@ "date_order": "YMD", "relative-type-regex": { "\\1 hour ago": [ - "(\\d+[.,]?\\d*) hrs ago" + "(\\d++[.,]?\\d*+) hrs ago" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) mins ago" + "(\\d++[.,]?\\d*+) mins ago" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mos ago" + "(\\d++[.,]?\\d*+) mos ago" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) secs ago" + "(\\d++[.,]?\\d*+) secs ago" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) wks ago" + "(\\d++[.,]?\\d*+) wks ago" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) yrs ago" + "(\\d++[.,]?\\d*+) yrs ago" ], "in \\1 hour": [ - "in (\\d+[.,]?\\d*) hrs" + "in (\\d++[.,]?\\d*+) hrs" ], "in \\1 minute": [ - "in (\\d+[.,]?\\d*) mins" + "in (\\d++[.,]?\\d*+) mins" ], "in \\1 month": [ - "in (\\d+[.,]?\\d*) mos" + "in (\\d++[.,]?\\d*+) mos" ], "in \\1 second": [ - "in (\\d+[.,]?\\d*) secs" + "in (\\d++[.,]?\\d*+) secs" ], "in \\1 week": [ - "in (\\d+[.,]?\\d*) wks" + "in (\\d++[.,]?\\d*+) wks" ], "in \\1 year": [ - "in (\\d+[.,]?\\d*) yrs" + "in (\\d++[.,]?\\d*+) yrs" ] } }, @@ -656,10 +656,10 @@ }, "relative-type-regex": { "\\1 month ago": [ - "(\\d+[.,]?\\d*) mth ago" + "(\\d++[.,]?\\d*+) mth ago" ], "in \\1 month": [ - "in (\\d+[.,]?\\d*) mth" + "in (\\d++[.,]?\\d*+) mth" ] } }, @@ -801,7 +801,7 @@ ], "simplifications": [ { - "(\\d+[.,]?\\d*)\\s*mons?\\b": "\\1 month" + "(\\d++[.,]?\\d*+)\\s*mons?\\b": "\\1 month" }, { "an": "1" @@ -816,7 +816,7 @@ "(?:12\\s+)?midnight": "00:00" }, { - "(\\d+[.,]?\\d*)h(\\d+[.,]?\\d*)": "\\1:\\2" + "(\\d++[.,]?\\d*+)h(\\d++[.,]?\\d*+)": "\\1:\\2" }, { "from\\s+now": "in" @@ -825,7 +825,7 @@ "less than 1 minute ago": "45 second ago" }, { - "(\\d+[.,]?\\d*|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later": "in \\1 \\2" + "(\\d++[.,]?\\d*+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later": "in \\1 \\2" }, { "one": "1" diff --git a/dateparser/data/date_translation_data/es.py b/dateparser/data/date_translation_data/es.py index ea36dbf81..d1882c5db 100644 --- a/dateparser/data/date_translation_data/es.py +++ b/dateparser/data/date_translation_data/es.py @@ -179,72 +179,72 @@ }, "relative-type-regex": { "\\1 day ago": [ - "hace (\\d+[.,]?\\d*) día", - "hace (\\d+[.,]?\\d*) días" + "hace (\\d++[.,]?\\d*+) día", + "hace (\\d++[.,]?\\d*+) días" ], "\\1 hour ago": [ - "hace (\\d+[.,]?\\d*) h", - "hace (\\d+[.,]?\\d*) hora", - "hace (\\d+[.,]?\\d*) horas" + "hace (\\d++[.,]?\\d*+) h", + "hace (\\d++[.,]?\\d*+) hora", + "hace (\\d++[.,]?\\d*+) horas" ], "\\1 minute ago": [ - "hace (\\d+[.,]?\\d*) min", - "hace (\\d+[.,]?\\d*) minuto", - "hace (\\d+[.,]?\\d*) minutos" + "hace (\\d++[.,]?\\d*+) min", + "hace (\\d++[.,]?\\d*+) minuto", + "hace (\\d++[.,]?\\d*+) minutos" ], "\\1 month ago": [ - "hace (\\d+[.,]?\\d*) m", - "hace (\\d+[.,]?\\d*) mes", - "hace (\\d+[.,]?\\d*) meses" + "hace (\\d++[.,]?\\d*+) m", + "hace (\\d++[.,]?\\d*+) mes", + "hace (\\d++[.,]?\\d*+) meses" ], "\\1 second ago": [ - "hace (\\d+[.,]?\\d*) s", - "hace (\\d+[.,]?\\d*) segundo", - "hace (\\d+[.,]?\\d*) segundos" + "hace (\\d++[.,]?\\d*+) s", + "hace (\\d++[.,]?\\d*+) segundo", + "hace (\\d++[.,]?\\d*+) segundos" ], "\\1 week ago": [ - "hace (\\d+[.,]?\\d*) sem", - "hace (\\d+[.,]?\\d*) semana", - "hace (\\d+[.,]?\\d*) semanas" + "hace (\\d++[.,]?\\d*+) sem", + "hace (\\d++[.,]?\\d*+) semana", + "hace (\\d++[.,]?\\d*+) semanas" ], "\\1 year ago": [ - "hace (\\d+[.,]?\\d*) a", - "hace (\\d+[.,]?\\d*) año", - "hace (\\d+[.,]?\\d*) años" + "hace (\\d++[.,]?\\d*+) a", + "hace (\\d++[.,]?\\d*+) año", + "hace (\\d++[.,]?\\d*+) años" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) día", - "dentro de (\\d+[.,]?\\d*) días" + "dentro de (\\d++[.,]?\\d*+) día", + "dentro de (\\d++[.,]?\\d*+) días" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) m", - "dentro de (\\d+[.,]?\\d*) mes", - "dentro de (\\d+[.,]?\\d*) meses" + "dentro de (\\d++[.,]?\\d*+) m", + "dentro de (\\d++[.,]?\\d*+) mes", + "dentro de (\\d++[.,]?\\d*+) meses" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) a", - "dentro de (\\d+[.,]?\\d*) año", - "dentro de (\\d+[.,]?\\d*) años" + "dentro de (\\d++[.,]?\\d*+) a", + "dentro de (\\d++[.,]?\\d*+) año", + "dentro de (\\d++[.,]?\\d*+) años" ] }, "locale_specific": { @@ -264,10 +264,10 @@ ], "relative-type-regex": { "\\1 second ago": [ - "hace (\\d+[.,]?\\d*) seg" + "hace (\\d++[.,]?\\d*+) seg" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) seg" + "dentro de (\\d++[.,]?\\d*+) seg" ] } }, @@ -364,29 +364,29 @@ }, "relative-type-regex": { "in \\1 day": [ - "en (\\d+[.,]?\\d*) día", - "en (\\d+[.,]?\\d*) días" + "en (\\d++[.,]?\\d*+) día", + "en (\\d++[.,]?\\d*+) días" ], "in \\1 hour": [ - "en (\\d+[.,]?\\d*) h", - "en (\\d+[.,]?\\d*) n" + "en (\\d++[.,]?\\d*+) h", + "en (\\d++[.,]?\\d*+) n" ], "in \\1 minute": [ - "en (\\d+[.,]?\\d*) min" + "en (\\d++[.,]?\\d*+) min" ], "in \\1 month": [ - "en (\\d+[.,]?\\d*) m", - "en (\\d+[.,]?\\d*) mes", - "en (\\d+[.,]?\\d*) meses" + "en (\\d++[.,]?\\d*+) m", + "en (\\d++[.,]?\\d*+) mes", + "en (\\d++[.,]?\\d*+) meses" ], "in \\1 second": [ - "en (\\d+[.,]?\\d*) s" + "en (\\d++[.,]?\\d*+) s" ], "in \\1 week": [ - "en (\\d+[.,]?\\d*) sem" + "en (\\d++[.,]?\\d*+) sem" ], "in \\1 year": [ - "en (\\d+[.,]?\\d*) a" + "en (\\d++[.,]?\\d*+) a" ] } }, @@ -427,10 +427,10 @@ ], "relative-type-regex": { "\\1 second ago": [ - "hace (\\d+[.,]?\\d*) seg" + "hace (\\d++[.,]?\\d*+) seg" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) seg" + "dentro de (\\d++[.,]?\\d*+) seg" ] } }, diff --git a/dateparser/data/date_translation_data/et.py b/dateparser/data/date_translation_data/et.py index d17276fb5..c5d8942bd 100644 --- a/dateparser/data/date_translation_data/et.py +++ b/dateparser/data/date_translation_data/et.py @@ -157,62 +157,62 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) p eest", - "(\\d+[.,]?\\d*) päeva eest" + "(\\d++[.,]?\\d*+) p eest", + "(\\d++[.,]?\\d*+) päeva eest" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) t eest", - "(\\d+[.,]?\\d*) tunni eest" + "(\\d++[.,]?\\d*+) t eest", + "(\\d++[.,]?\\d*+) tunni eest" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min eest", - "(\\d+[.,]?\\d*) minuti eest" + "(\\d++[.,]?\\d*+) min eest", + "(\\d++[.,]?\\d*+) minuti eest" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) k eest", - "(\\d+[.,]?\\d*) kuu eest" + "(\\d++[.,]?\\d*+) k eest", + "(\\d++[.,]?\\d*+) kuu eest" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) s eest", - "(\\d+[.,]?\\d*) sek eest", - "(\\d+[.,]?\\d*) sekundi eest" + "(\\d++[.,]?\\d*+) s eest", + "(\\d++[.,]?\\d*+) sek eest", + "(\\d++[.,]?\\d*+) sekundi eest" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) näd eest", - "(\\d+[.,]?\\d*) nädala eest" + "(\\d++[.,]?\\d*+) näd eest", + "(\\d++[.,]?\\d*+) nädala eest" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) a eest", - "(\\d+[.,]?\\d*) aasta eest" + "(\\d++[.,]?\\d*+) a eest", + "(\\d++[.,]?\\d*+) aasta eest" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) p pärast", - "(\\d+[.,]?\\d*) päeva pärast" + "(\\d++[.,]?\\d*+) p pärast", + "(\\d++[.,]?\\d*+) päeva pärast" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) t pärast", - "(\\d+[.,]?\\d*) tunni pärast" + "(\\d++[.,]?\\d*+) t pärast", + "(\\d++[.,]?\\d*+) tunni pärast" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) min pärast", - "(\\d+[.,]?\\d*) minuti pärast" + "(\\d++[.,]?\\d*+) min pärast", + "(\\d++[.,]?\\d*+) minuti pärast" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) k pärast", - "(\\d+[.,]?\\d*) kuu pärast" + "(\\d++[.,]?\\d*+) k pärast", + "(\\d++[.,]?\\d*+) kuu pärast" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) s pärast", - "(\\d+[.,]?\\d*) sek pärast", - "(\\d+[.,]?\\d*) sekundi pärast" + "(\\d++[.,]?\\d*+) s pärast", + "(\\d++[.,]?\\d*+) sek pärast", + "(\\d++[.,]?\\d*+) sekundi pärast" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) näd pärast", - "(\\d+[.,]?\\d*) nädala pärast" + "(\\d++[.,]?\\d*+) näd pärast", + "(\\d++[.,]?\\d*+) nädala pärast" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) a pärast", - "(\\d+[.,]?\\d*) aasta pärast" + "(\\d++[.,]?\\d*+) a pärast", + "(\\d++[.,]?\\d*+) aasta pärast" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/eu.py b/dateparser/data/date_translation_data/eu.py index 2e8a6c436..73e00899d 100644 --- a/dateparser/data/date_translation_data/eu.py +++ b/dateparser/data/date_translation_data/eu.py @@ -159,46 +159,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "duela (\\d+[.,]?\\d*) egun" + "duela (\\d++[.,]?\\d*+) egun" ], "\\1 hour ago": [ - "duela (\\d+[.,]?\\d*) ordu" + "duela (\\d++[.,]?\\d*+) ordu" ], "\\1 minute ago": [ - "duela (\\d+[.,]?\\d*) minutu" + "duela (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "duela (\\d+[.,]?\\d*) hilabete" + "duela (\\d++[.,]?\\d*+) hilabete" ], "\\1 second ago": [ - "duela (\\d+[.,]?\\d*) segundo" + "duela (\\d++[.,]?\\d*+) segundo" ], "\\1 week ago": [ - "duela (\\d+[.,]?\\d*) aste" + "duela (\\d++[.,]?\\d*+) aste" ], "\\1 year ago": [ - "duela (\\d+[.,]?\\d*) urte" + "duela (\\d++[.,]?\\d*+) urte" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) egun barru" + "(\\d++[.,]?\\d*+) egun barru" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ordu barru" + "(\\d++[.,]?\\d*+) ordu barru" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) minutu barru" + "(\\d++[.,]?\\d*+) minutu barru" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) hilabete barru" + "(\\d++[.,]?\\d*+) hilabete barru" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) segundo barru" + "(\\d++[.,]?\\d*+) segundo barru" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) aste barru" + "(\\d++[.,]?\\d*+) aste barru" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) urte barru" + "(\\d++[.,]?\\d*+) urte barru" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/fa.py b/dateparser/data/date_translation_data/fa.py index 8fa28ceaf..5ca114d17 100644 --- a/dateparser/data/date_translation_data/fa.py +++ b/dateparser/data/date_translation_data/fa.py @@ -160,46 +160,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) روز پیش" + "(\\d++[.,]?\\d*+) روز پیش" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ساعت پیش" + "(\\d++[.,]?\\d*+) ساعت پیش" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) دقیقه پیش" + "(\\d++[.,]?\\d*+) دقیقه پیش" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ماه پیش" + "(\\d++[.,]?\\d*+) ماه پیش" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ثانیه پیش" + "(\\d++[.,]?\\d*+) ثانیه پیش" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) هفته پیش" + "(\\d++[.,]?\\d*+) هفته پیش" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) سال پیش" + "(\\d++[.,]?\\d*+) سال پیش" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) روز بعد" + "(\\d++[.,]?\\d*+) روز بعد" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ساعت بعد" + "(\\d++[.,]?\\d*+) ساعت بعد" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) دقیقه بعد" + "(\\d++[.,]?\\d*+) دقیقه بعد" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ماه بعد" + "(\\d++[.,]?\\d*+) ماه بعد" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) ثانیه بعد" + "(\\d++[.,]?\\d*+) ثانیه بعد" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) هفته بعد" + "(\\d++[.,]?\\d*+) هفته بعد" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) سال بعد" + "(\\d++[.,]?\\d*+) سال بعد" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/fi.py b/dateparser/data/date_translation_data/fi.py index ecc6762f1..e57e36c95 100644 --- a/dateparser/data/date_translation_data/fi.py +++ b/dateparser/data/date_translation_data/fi.py @@ -250,67 +250,67 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) pv sitten", - "(\\d+[.,]?\\d*) päivä sitten", - "(\\d+[.,]?\\d*) päivää sitten" + "(\\d++[.,]?\\d*+) pv sitten", + "(\\d++[.,]?\\d*+) päivä sitten", + "(\\d++[.,]?\\d*+) päivää sitten" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) t sitten", - "(\\d+[.,]?\\d*) tunti sitten", - "(\\d+[.,]?\\d*) tuntia sitten" + "(\\d++[.,]?\\d*+) t sitten", + "(\\d++[.,]?\\d*+) tunti sitten", + "(\\d++[.,]?\\d*+) tuntia sitten" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min sitten", - "(\\d+[.,]?\\d*) minuutti sitten", - "(\\d+[.,]?\\d*) minuuttia sitten" + "(\\d++[.,]?\\d*+) min sitten", + "(\\d++[.,]?\\d*+) minuutti sitten", + "(\\d++[.,]?\\d*+) minuuttia sitten" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) kk sitten", - "(\\d+[.,]?\\d*) kuukausi sitten", - "(\\d+[.,]?\\d*) kuukautta sitten" + "(\\d++[.,]?\\d*+) kk sitten", + "(\\d++[.,]?\\d*+) kuukausi sitten", + "(\\d++[.,]?\\d*+) kuukautta sitten" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) s sitten", - "(\\d+[.,]?\\d*) sekunti sitten", - "(\\d+[.,]?\\d*) sekuntia sitten" + "(\\d++[.,]?\\d*+) s sitten", + "(\\d++[.,]?\\d*+) sekunti sitten", + "(\\d++[.,]?\\d*+) sekuntia sitten" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) viikko sitten", - "(\\d+[.,]?\\d*) viikkoa sitten", - "(\\d+[.,]?\\d*) vk sitten" + "(\\d++[.,]?\\d*+) viikko sitten", + "(\\d++[.,]?\\d*+) viikkoa sitten", + "(\\d++[.,]?\\d*+) vk sitten" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) v sitten", - "(\\d+[.,]?\\d*) vuosi sitten", - "(\\d+[.,]?\\d*) vuotta sitten" + "(\\d++[.,]?\\d*+) v sitten", + "(\\d++[.,]?\\d*+) vuosi sitten", + "(\\d++[.,]?\\d*+) vuotta sitten" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) pv päästä", - "(\\d+[.,]?\\d*) päivän päästä" + "(\\d++[.,]?\\d*+) pv päästä", + "(\\d++[.,]?\\d*+) päivän päästä" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) t päästä", - "(\\d+[.,]?\\d*) tunnin päästä" + "(\\d++[.,]?\\d*+) t päästä", + "(\\d++[.,]?\\d*+) tunnin päästä" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) min päästä", - "(\\d+[.,]?\\d*) minuutin päästä" + "(\\d++[.,]?\\d*+) min päästä", + "(\\d++[.,]?\\d*+) minuutin päästä" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) kk päästä", - "(\\d+[.,]?\\d*) kuukauden päästä" + "(\\d++[.,]?\\d*+) kk päästä", + "(\\d++[.,]?\\d*+) kuukauden päästä" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) s päästä", - "(\\d+[.,]?\\d*) sekunnin päästä" + "(\\d++[.,]?\\d*+) s päästä", + "(\\d++[.,]?\\d*+) sekunnin päästä" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) viikon päästä", - "(\\d+[.,]?\\d*) vk päästä" + "(\\d++[.,]?\\d*+) viikon päästä", + "(\\d++[.,]?\\d*+) vk päästä" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) v päästä", - "(\\d+[.,]?\\d*) vuoden päästä" + "(\\d++[.,]?\\d*+) v päästä", + "(\\d++[.,]?\\d*+) vuoden päästä" ] }, "locale_specific": {}, @@ -340,7 +340,7 @@ ], "simplifications": [ { - "(\\d+[.,]?\\d*) (sekunnin|sekuntin|minuutin|tunnin|päivän|viikon|kuukauden|vuoden) (päästä|kuluttua)": "\\3 \\1 \\2" + "(\\d++[.,]?\\d*+) (sekunnin|sekuntin|minuutin|tunnin|päivän|viikon|kuukauden|vuoden) (päästä|kuluttua)": "\\3 \\1 \\2" } ] } diff --git a/dateparser/data/date_translation_data/fil.py b/dateparser/data/date_translation_data/fil.py index e2e598803..b0ef86440 100644 --- a/dateparser/data/date_translation_data/fil.py +++ b/dateparser/data/date_translation_data/fil.py @@ -157,52 +157,52 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) araw ang nakalipas" + "(\\d++[.,]?\\d*+) araw ang nakalipas" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) oras ang nakalipas", - "(\\d+[.,]?\\d*) oras nakalipas" + "(\\d++[.,]?\\d*+) oras ang nakalipas", + "(\\d++[.,]?\\d*+) oras nakalipas" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min ang nakalipas", - "(\\d+[.,]?\\d*) minuto ang nakalipas" + "(\\d++[.,]?\\d*+) min ang nakalipas", + "(\\d++[.,]?\\d*+) minuto ang nakalipas" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) buwan ang nakalipas" + "(\\d++[.,]?\\d*+) buwan ang nakalipas" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) seg ang nakalipas", - "(\\d+[.,]?\\d*) seg nakalipas", - "(\\d+[.,]?\\d*) segundo ang nakalipas" + "(\\d++[.,]?\\d*+) seg ang nakalipas", + "(\\d++[.,]?\\d*+) seg nakalipas", + "(\\d++[.,]?\\d*+) segundo ang nakalipas" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) linggo ang nakalipas" + "(\\d++[.,]?\\d*+) linggo ang nakalipas" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) taon ang nakalipas" + "(\\d++[.,]?\\d*+) taon ang nakalipas" ], "in \\1 day": [ - "sa (\\d+[.,]?\\d*) araw" + "sa (\\d++[.,]?\\d*+) araw" ], "in \\1 hour": [ - "sa (\\d+[.,]?\\d*) oras" + "sa (\\d++[.,]?\\d*+) oras" ], "in \\1 minute": [ - "sa (\\d+[.,]?\\d*) min", - "sa (\\d+[.,]?\\d*) minuto" + "sa (\\d++[.,]?\\d*+) min", + "sa (\\d++[.,]?\\d*+) minuto" ], "in \\1 month": [ - "sa (\\d+[.,]?\\d*) buwan" + "sa (\\d++[.,]?\\d*+) buwan" ], "in \\1 second": [ - "sa (\\d+[.,]?\\d*) seg", - "sa (\\d+[.,]?\\d*) segundo" + "sa (\\d++[.,]?\\d*+) seg", + "sa (\\d++[.,]?\\d*+) segundo" ], "in \\1 week": [ - "sa (\\d+[.,]?\\d*) linggo" + "sa (\\d++[.,]?\\d*+) linggo" ], "in \\1 year": [ - "sa (\\d+[.,]?\\d*) taon" + "sa (\\d++[.,]?\\d*+) taon" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/fo.py b/dateparser/data/date_translation_data/fo.py index d1ffe66a2..b8265b08a 100644 --- a/dateparser/data/date_translation_data/fo.py +++ b/dateparser/data/date_translation_data/fo.py @@ -162,76 +162,76 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) d síðan", - "(\\d+[.,]?\\d*) da síðan", - "(\\d+[.,]?\\d*) dagar síðan", - "(\\d+[.,]?\\d*) dagur síðan" + "(\\d++[.,]?\\d*+) d síðan", + "(\\d++[.,]?\\d*+) da síðan", + "(\\d++[.,]?\\d*+) dagar síðan", + "(\\d++[.,]?\\d*+) dagur síðan" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) t síðan", - "(\\d+[.,]?\\d*) tímar síðan", - "(\\d+[.,]?\\d*) tími síðan" + "(\\d++[.,]?\\d*+) t síðan", + "(\\d++[.,]?\\d*+) tímar síðan", + "(\\d++[.,]?\\d*+) tími síðan" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) m síðan", - "(\\d+[.,]?\\d*) min síðan", - "(\\d+[.,]?\\d*) minutt síðan", - "(\\d+[.,]?\\d*) minuttir síðan" + "(\\d++[.,]?\\d*+) m síðan", + "(\\d++[.,]?\\d*+) min síðan", + "(\\d++[.,]?\\d*+) minutt síðan", + "(\\d++[.,]?\\d*+) minuttir síðan" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mnð síðan", - "(\\d+[.,]?\\d*) mánað síðan", - "(\\d+[.,]?\\d*) mánaðir síðan" + "(\\d++[.,]?\\d*+) mnð síðan", + "(\\d++[.,]?\\d*+) mánað síðan", + "(\\d++[.,]?\\d*+) mánaðir síðan" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) s síðan", - "(\\d+[.,]?\\d*) sek síðan", - "(\\d+[.,]?\\d*) sekund síðan" + "(\\d++[.,]?\\d*+) s síðan", + "(\\d++[.,]?\\d*+) sek síðan", + "(\\d++[.,]?\\d*+) sekund síðan" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) v síðan", - "(\\d+[.,]?\\d*) vi síðan", - "(\\d+[.,]?\\d*) vika síðan", - "(\\d+[.,]?\\d*) vikur síðan" + "(\\d++[.,]?\\d*+) v síðan", + "(\\d++[.,]?\\d*+) vi síðan", + "(\\d++[.,]?\\d*+) vika síðan", + "(\\d++[.,]?\\d*+) vikur síðan" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ár síðan" + "(\\d++[.,]?\\d*+) ár síðan" ], "in \\1 day": [ - "um (\\d+[.,]?\\d*) d", - "um (\\d+[.,]?\\d*) da", - "um (\\d+[.,]?\\d*) dag", - "um (\\d+[.,]?\\d*) dagar" + "um (\\d++[.,]?\\d*+) d", + "um (\\d++[.,]?\\d*+) da", + "um (\\d++[.,]?\\d*+) dag", + "um (\\d++[.,]?\\d*+) dagar" ], "in \\1 hour": [ - "um (\\d+[.,]?\\d*) t", - "um (\\d+[.,]?\\d*) tíma", - "um (\\d+[.,]?\\d*) tímar" + "um (\\d++[.,]?\\d*+) t", + "um (\\d++[.,]?\\d*+) tíma", + "um (\\d++[.,]?\\d*+) tímar" ], "in \\1 minute": [ - "um (\\d+[.,]?\\d*) m", - "um (\\d+[.,]?\\d*) min", - "um (\\d+[.,]?\\d*) minutt", - "um (\\d+[.,]?\\d*) minuttir" + "um (\\d++[.,]?\\d*+) m", + "um (\\d++[.,]?\\d*+) min", + "um (\\d++[.,]?\\d*+) minutt", + "um (\\d++[.,]?\\d*+) minuttir" ], "in \\1 month": [ - "um (\\d+[.,]?\\d*) mnð", - "um (\\d+[.,]?\\d*) mánað", - "um (\\d+[.,]?\\d*) mánaðir" + "um (\\d++[.,]?\\d*+) mnð", + "um (\\d++[.,]?\\d*+) mánað", + "um (\\d++[.,]?\\d*+) mánaðir" ], "in \\1 second": [ - "um (\\d+[.,]?\\d*) s", - "um (\\d+[.,]?\\d*) sek", - "um (\\d+[.,]?\\d*) sekund" + "um (\\d++[.,]?\\d*+) s", + "um (\\d++[.,]?\\d*+) sek", + "um (\\d++[.,]?\\d*+) sekund" ], "in \\1 week": [ - "um (\\d+[.,]?\\d*) v", - "um (\\d+[.,]?\\d*) vi", - "um (\\d+[.,]?\\d*) viku", - "um (\\d+[.,]?\\d*) vikur" + "um (\\d++[.,]?\\d*+) v", + "um (\\d++[.,]?\\d*+) vi", + "um (\\d++[.,]?\\d*+) viku", + "um (\\d++[.,]?\\d*+) vikur" ], "in \\1 year": [ - "um (\\d+[.,]?\\d*) ár" + "um (\\d++[.,]?\\d*+) ár" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/fr.py b/dateparser/data/date_translation_data/fr.py index ee7f4c5ba..c6aa082a4 100644 --- a/dateparser/data/date_translation_data/fr.py +++ b/dateparser/data/date_translation_data/fr.py @@ -183,75 +183,75 @@ }, "relative-type-regex": { "\\1 day ago": [ - "il y a (\\d+[.,]?\\d*) j", - "il y a (\\d+[.,]?\\d*) jour", - "il y a (\\d+[.,]?\\d*) jours" + "il y a (\\d++[.,]?\\d*+) j", + "il y a (\\d++[.,]?\\d*+) jour", + "il y a (\\d++[.,]?\\d*+) jours" ], "\\1 hour ago": [ - "il y a (\\d+[.,]?\\d*) h", - "il y a (\\d+[.,]?\\d*) heure", - "il y a (\\d+[.,]?\\d*) heures", - "il y a (\\d+[.,]?\\d*)h" + "il y a (\\d++[.,]?\\d*+) h", + "il y a (\\d++[.,]?\\d*+) heure", + "il y a (\\d++[.,]?\\d*+) heures", + "il y a (\\d++[.,]?\\d*+)h" ], "\\1 minute ago": [ - "il y a (\\d+[.,]?\\d*) min", - "il y a (\\d+[.,]?\\d*) minute", - "il y a (\\d+[.,]?\\d*) minutes", - "il y a (\\d+[.,]?\\d*)min" + "il y a (\\d++[.,]?\\d*+) min", + "il y a (\\d++[.,]?\\d*+) minute", + "il y a (\\d++[.,]?\\d*+) minutes", + "il y a (\\d++[.,]?\\d*+)min" ], "\\1 month ago": [ - "il y a (\\d+[.,]?\\d*) m", - "il y a (\\d+[.,]?\\d*) mois" + "il y a (\\d++[.,]?\\d*+) m", + "il y a (\\d++[.,]?\\d*+) mois" ], "\\1 second ago": [ - "il y a (\\d+[.,]?\\d*) s", - "il y a (\\d+[.,]?\\d*) seconde", - "il y a (\\d+[.,]?\\d*) secondes" + "il y a (\\d++[.,]?\\d*+) s", + "il y a (\\d++[.,]?\\d*+) seconde", + "il y a (\\d++[.,]?\\d*+) secondes" ], "\\1 week ago": [ - "il y a (\\d+[.,]?\\d*) sem", - "il y a (\\d+[.,]?\\d*) semaine", - "il y a (\\d+[.,]?\\d*) semaines" + "il y a (\\d++[.,]?\\d*+) sem", + "il y a (\\d++[.,]?\\d*+) semaine", + "il y a (\\d++[.,]?\\d*+) semaines" ], "\\1 year ago": [ - "il y a (\\d+[.,]?\\d*) a", - "il y a (\\d+[.,]?\\d*) an", - "il y a (\\d+[.,]?\\d*) ans" + "il y a (\\d++[.,]?\\d*+) a", + "il y a (\\d++[.,]?\\d*+) an", + "il y a (\\d++[.,]?\\d*+) ans" ], "in \\1 day": [ - "dans (\\d+[.,]?\\d*) j", - "dans (\\d+[.,]?\\d*) jour", - "dans (\\d+[.,]?\\d*) jours" + "dans (\\d++[.,]?\\d*+) j", + "dans (\\d++[.,]?\\d*+) jour", + "dans (\\d++[.,]?\\d*+) jours" ], "in \\1 hour": [ - "dans (\\d+[.,]?\\d*) h", - "dans (\\d+[.,]?\\d*) heure", - "dans (\\d+[.,]?\\d*) heures", - "dans (\\d+[.,]?\\d*)h" + "dans (\\d++[.,]?\\d*+) h", + "dans (\\d++[.,]?\\d*+) heure", + "dans (\\d++[.,]?\\d*+) heures", + "dans (\\d++[.,]?\\d*+)h" ], "in \\1 minute": [ - "dans (\\d+[.,]?\\d*) min", - "dans (\\d+[.,]?\\d*) minute", - "dans (\\d+[.,]?\\d*) minutes" + "dans (\\d++[.,]?\\d*+) min", + "dans (\\d++[.,]?\\d*+) minute", + "dans (\\d++[.,]?\\d*+) minutes" ], "in \\1 month": [ - "dans (\\d+[.,]?\\d*) m", - "dans (\\d+[.,]?\\d*) mois" + "dans (\\d++[.,]?\\d*+) m", + "dans (\\d++[.,]?\\d*+) mois" ], "in \\1 second": [ - "dans (\\d+[.,]?\\d*) s", - "dans (\\d+[.,]?\\d*) seconde", - "dans (\\d+[.,]?\\d*) secondes" + "dans (\\d++[.,]?\\d*+) s", + "dans (\\d++[.,]?\\d*+) seconde", + "dans (\\d++[.,]?\\d*+) secondes" ], "in \\1 week": [ - "dans (\\d+[.,]?\\d*) sem", - "dans (\\d+[.,]?\\d*) semaine", - "dans (\\d+[.,]?\\d*) semaines" + "dans (\\d++[.,]?\\d*+) sem", + "dans (\\d++[.,]?\\d*+) semaine", + "dans (\\d++[.,]?\\d*+) semaines" ], "in \\1 year": [ - "dans (\\d+[.,]?\\d*) a", - "dans (\\d+[.,]?\\d*) an", - "dans (\\d+[.,]?\\d*) ans" + "dans (\\d++[.,]?\\d*+) a", + "dans (\\d++[.,]?\\d*+) an", + "dans (\\d++[.,]?\\d*+) ans" ] }, "locale_specific": { @@ -466,22 +466,22 @@ "un": "1" }, { - "(\\d+[.,]?\\d*)\\s+h\\s+(\\d+[.,]?\\d*)\\s+min": "\\1h\\2m" + "(\\d++[.,]?\\d*+)\\s+h\\s+(\\d++[.,]?\\d*+)\\s+min": "\\1h\\2m" }, { - "(\\d+[.,]?\\d*)h(\\d+[.,]?\\d*)m?": "\\1:\\2" + "(\\d++[.,]?\\d*+)h(\\d++[.,]?\\d*+)m?": "\\1:\\2" }, { - "moins\\s(?:de\\s)?(\\d+[.,]?\\d*)\\s?(minute|seconde|heure)": "\\1 \\2" + "moins\\s(?:de\\s)?(\\d++[.,]?\\d*+)\\s?(minute|seconde|heure)": "\\1 \\2" }, { - "moins\\s(?:de\\s)?(\\d+[.,]?\\d*)\\s?s": "\\1 seconde" + "moins\\s(?:de\\s)?(\\d++[.,]?\\d*+)\\s?s": "\\1 seconde" }, { - "moins\\s(?:de\\s)?(\\d+[.,]?\\d*)\\s?m": "\\1 minute" + "moins\\s(?:de\\s)?(\\d++[.,]?\\d*+)\\s?m": "\\1 minute" }, { - "moins\\s(?:de\\s)?(\\d+[.,]?\\d*)\\s?h": "\\1 heure" + "moins\\s(?:de\\s)?(\\d++[.,]?\\d*+)\\s?h": "\\1 heure" }, { "deux": "2" diff --git a/dateparser/data/date_translation_data/fur.py b/dateparser/data/date_translation_data/fur.py index de6789147..d77dd223e 100644 --- a/dateparser/data/date_translation_data/fur.py +++ b/dateparser/data/date_translation_data/fur.py @@ -151,58 +151,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) zornade indaûr", - "(\\d+[.,]?\\d*) zornadis indaûr" + "(\\d++[.,]?\\d*+) zornade indaûr", + "(\\d++[.,]?\\d*+) zornadis indaûr" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ore indaûr", - "(\\d+[.,]?\\d*) oris indaûr" + "(\\d++[.,]?\\d*+) ore indaûr", + "(\\d++[.,]?\\d*+) oris indaûr" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) minût indaûr", - "(\\d+[.,]?\\d*) minûts indaûr" + "(\\d++[.,]?\\d*+) minût indaûr", + "(\\d++[.,]?\\d*+) minûts indaûr" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mês indaûr" + "(\\d++[.,]?\\d*+) mês indaûr" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) secont indaûr", - "(\\d+[.,]?\\d*) seconts indaûr" + "(\\d++[.,]?\\d*+) secont indaûr", + "(\\d++[.,]?\\d*+) seconts indaûr" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) setemane indaûr", - "(\\d+[.,]?\\d*) setemanis indaûr" + "(\\d++[.,]?\\d*+) setemane indaûr", + "(\\d++[.,]?\\d*+) setemanis indaûr" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) agns indaûr", - "(\\d+[.,]?\\d*) an indaûr" + "(\\d++[.,]?\\d*+) agns indaûr", + "(\\d++[.,]?\\d*+) an indaûr" ], "in \\1 day": [ - "ca di (\\d+[.,]?\\d*) zornade", - "ca di (\\d+[.,]?\\d*) zornadis" + "ca di (\\d++[.,]?\\d*+) zornade", + "ca di (\\d++[.,]?\\d*+) zornadis" ], "in \\1 hour": [ - "ca di (\\d+[.,]?\\d*) ore", - "ca di (\\d+[.,]?\\d*) oris" + "ca di (\\d++[.,]?\\d*+) ore", + "ca di (\\d++[.,]?\\d*+) oris" ], "in \\1 minute": [ - "ca di (\\d+[.,]?\\d*) minût", - "ca di (\\d+[.,]?\\d*) minûts" + "ca di (\\d++[.,]?\\d*+) minût", + "ca di (\\d++[.,]?\\d*+) minûts" ], "in \\1 month": [ - "ca di (\\d+[.,]?\\d*) mês" + "ca di (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "ca di (\\d+[.,]?\\d*) secont", - "ca di (\\d+[.,]?\\d*) seconts" + "ca di (\\d++[.,]?\\d*+) secont", + "ca di (\\d++[.,]?\\d*+) seconts" ], "in \\1 week": [ - "ca di (\\d+[.,]?\\d*) setemane", - "ca di (\\d+[.,]?\\d*) setemanis" + "ca di (\\d++[.,]?\\d*+) setemane", + "ca di (\\d++[.,]?\\d*+) setemanis" ], "in \\1 year": [ - "ca di (\\d+[.,]?\\d*) agns", - "ca di (\\d+[.,]?\\d*) an" + "ca di (\\d++[.,]?\\d*+) agns", + "ca di (\\d++[.,]?\\d*+) an" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/fy.py b/dateparser/data/date_translation_data/fy.py index f79680119..075372e31 100644 --- a/dateparser/data/date_translation_data/fy.py +++ b/dateparser/data/date_translation_data/fy.py @@ -153,56 +153,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) dei lyn", - "(\\d+[.,]?\\d*) deien lyn" + "(\\d++[.,]?\\d*+) dei lyn", + "(\\d++[.,]?\\d*+) deien lyn" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) oere lyn" + "(\\d++[.,]?\\d*+) oere lyn" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) minuten lyn", - "(\\d+[.,]?\\d*) minút lyn" + "(\\d++[.,]?\\d*+) minuten lyn", + "(\\d++[.,]?\\d*+) minút lyn" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) moanne lyn", - "(\\d+[.,]?\\d*) moannen lyn" + "(\\d++[.,]?\\d*+) moanne lyn", + "(\\d++[.,]?\\d*+) moannen lyn" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sekonde lyn", - "(\\d+[.,]?\\d*) sekonden lyn" + "(\\d++[.,]?\\d*+) sekonde lyn", + "(\\d++[.,]?\\d*+) sekonden lyn" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) wike lyn", - "(\\d+[.,]?\\d*) wiken lyn" + "(\\d++[.,]?\\d*+) wike lyn", + "(\\d++[.,]?\\d*+) wiken lyn" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) jier lyn" + "(\\d++[.,]?\\d*+) jier lyn" ], "in \\1 day": [ - "oer (\\d+[.,]?\\d*) dei", - "oer (\\d+[.,]?\\d*) deien" + "oer (\\d++[.,]?\\d*+) dei", + "oer (\\d++[.,]?\\d*+) deien" ], "in \\1 hour": [ - "oer (\\d+[.,]?\\d*) oere" + "oer (\\d++[.,]?\\d*+) oere" ], "in \\1 minute": [ - "oer (\\d+[.,]?\\d*) minuten", - "oer (\\d+[.,]?\\d*) minút" + "oer (\\d++[.,]?\\d*+) minuten", + "oer (\\d++[.,]?\\d*+) minút" ], "in \\1 month": [ - "oer (\\d+[.,]?\\d*) moanne", - "oer (\\d+[.,]?\\d*) moannen" + "oer (\\d++[.,]?\\d*+) moanne", + "oer (\\d++[.,]?\\d*+) moannen" ], "in \\1 second": [ - "oer (\\d+[.,]?\\d*) sekonde", - "oer (\\d+[.,]?\\d*) sekonden" + "oer (\\d++[.,]?\\d*+) sekonde", + "oer (\\d++[.,]?\\d*+) sekonden" ], "in \\1 week": [ - "oer (\\d+[.,]?\\d*) wike", - "oer (\\d+[.,]?\\d*) wiken" + "oer (\\d++[.,]?\\d*+) wike", + "oer (\\d++[.,]?\\d*+) wiken" ], "in \\1 year": [ - "oer (\\d+[.,]?\\d*) jier" + "oer (\\d++[.,]?\\d*+) jier" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ga.py b/dateparser/data/date_translation_data/ga.py index daa9b4904..afd650c56 100644 --- a/dateparser/data/date_translation_data/ga.py +++ b/dateparser/data/date_translation_data/ga.py @@ -163,61 +163,61 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) lá ó shin" + "(\\d++[.,]?\\d*+) lá ó shin" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) uair an chloig ó shin", - "(\\d+[.,]?\\d*) uair ó shin" + "(\\d++[.,]?\\d*+) uair an chloig ó shin", + "(\\d++[.,]?\\d*+) uair ó shin" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) nóim ó shin", - "(\\d+[.,]?\\d*) nóiméad ó shin" + "(\\d++[.,]?\\d*+) nóim ó shin", + "(\\d++[.,]?\\d*+) nóiméad ó shin" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mhí ó shin", - "(\\d+[.,]?\\d*) mí ó shin" + "(\\d++[.,]?\\d*+) mhí ó shin", + "(\\d++[.,]?\\d*+) mí ó shin" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) soic ó shin", - "(\\d+[.,]?\\d*) soicind ó shin" + "(\\d++[.,]?\\d*+) soic ó shin", + "(\\d++[.,]?\\d*+) soicind ó shin" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) scht ó shin", - "(\\d+[.,]?\\d*) seachtain ó shin" + "(\\d++[.,]?\\d*+) scht ó shin", + "(\\d++[.,]?\\d*+) seachtain ó shin" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) bhl ó shin", - "(\\d+[.,]?\\d*) bhliain ó shin", - "(\\d+[.,]?\\d*) bl ó shin", - "(\\d+[.,]?\\d*) bliain ó shin" + "(\\d++[.,]?\\d*+) bhl ó shin", + "(\\d++[.,]?\\d*+) bhliain ó shin", + "(\\d++[.,]?\\d*+) bl ó shin", + "(\\d++[.,]?\\d*+) bliain ó shin" ], "in \\1 day": [ - "i gceann (\\d+[.,]?\\d*) lá" + "i gceann (\\d++[.,]?\\d*+) lá" ], "in \\1 hour": [ - "i gceann (\\d+[.,]?\\d*) uair", - "i gceann (\\d+[.,]?\\d*) uair an chloig" + "i gceann (\\d++[.,]?\\d*+) uair", + "i gceann (\\d++[.,]?\\d*+) uair an chloig" ], "in \\1 minute": [ - "i gceann (\\d+[.,]?\\d*) nóim", - "i gceann (\\d+[.,]?\\d*) nóiméad" + "i gceann (\\d++[.,]?\\d*+) nóim", + "i gceann (\\d++[.,]?\\d*+) nóiméad" ], "in \\1 month": [ - "i gceann (\\d+[.,]?\\d*) mhí", - "i gceann (\\d+[.,]?\\d*) mí" + "i gceann (\\d++[.,]?\\d*+) mhí", + "i gceann (\\d++[.,]?\\d*+) mí" ], "in \\1 second": [ - "i gceann (\\d+[.,]?\\d*) soic", - "i gceann (\\d+[.,]?\\d*) soicind" + "i gceann (\\d++[.,]?\\d*+) soic", + "i gceann (\\d++[.,]?\\d*+) soicind" ], "in \\1 week": [ - "i gceann (\\d+[.,]?\\d*) scht", - "i gceann (\\d+[.,]?\\d*) seachtain" + "i gceann (\\d++[.,]?\\d*+) scht", + "i gceann (\\d++[.,]?\\d*+) seachtain" ], "in \\1 year": [ - "i gceann (\\d+[.,]?\\d*) bhliain", - "i gceann (\\d+[.,]?\\d*) bl", - "i gceann (\\d+[.,]?\\d*) bliain" + "i gceann (\\d++[.,]?\\d*+) bhliain", + "i gceann (\\d++[.,]?\\d*+) bl", + "i gceann (\\d++[.,]?\\d*+) bliain" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/gd.py b/dateparser/data/date_translation_data/gd.py index 83660ecf8..be242fe82 100644 --- a/dateparser/data/date_translation_data/gd.py +++ b/dateparser/data/date_translation_data/gd.py @@ -189,74 +189,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "o (\\d+[.,]?\\d*) là", - "(\\d+[.,]?\\d*) latha air ais" + "o (\\d++[.,]?\\d*+) là", + "(\\d++[.,]?\\d*+) latha air ais" ], "\\1 hour ago": [ - "o (\\d+[.,]?\\d*) uair", - "(\\d+[.,]?\\d*) uair a thìde air ais" + "o (\\d++[.,]?\\d*+) uair", + "(\\d++[.,]?\\d*+) uair a thìde air ais" ], "\\1 minute ago": [ - "o (\\d+[.,]?\\d*) mhion", - "o (\\d+[.,]?\\d*) mion", - "(\\d+[.,]?\\d*) mhionaid air ais", - "(\\d+[.,]?\\d*) mionaid air ais" + "o (\\d++[.,]?\\d*+) mhion", + "o (\\d++[.,]?\\d*+) mion", + "(\\d++[.,]?\\d*+) mhionaid air ais", + "(\\d++[.,]?\\d*+) mionaid air ais" ], "\\1 month ago": [ - "o (\\d+[.,]?\\d*) mhìos", - "o (\\d+[.,]?\\d*) mìos", - "(\\d+[.,]?\\d*) mhìos air ais", - "(\\d+[.,]?\\d*) mìos air ais" + "o (\\d++[.,]?\\d*+) mhìos", + "o (\\d++[.,]?\\d*+) mìos", + "(\\d++[.,]?\\d*+) mhìos air ais", + "(\\d++[.,]?\\d*+) mìos air ais" ], "\\1 second ago": [ - "o (\\d+[.,]?\\d*) diog", - "(\\d+[.,]?\\d*) diog air ais" + "o (\\d++[.,]?\\d*+) diog", + "(\\d++[.,]?\\d*+) diog air ais" ], "\\1 week ago": [ - "o (\\d+[.,]?\\d*) seachd", - "o (\\d+[.,]?\\d*) sheachd", - "(\\d+[.,]?\\d*) seachdain air ais" + "o (\\d++[.,]?\\d*+) seachd", + "o (\\d++[.,]?\\d*+) sheachd", + "(\\d++[.,]?\\d*+) seachdain air ais" ], "\\1 year ago": [ - "o (\\d+[.,]?\\d*) bhlia", - "o (\\d+[.,]?\\d*) blia", - "(\\d+[.,]?\\d*) bhliadhna air ais", - "(\\d+[.,]?\\d*) bliadhna air ais" + "o (\\d++[.,]?\\d*+) bhlia", + "o (\\d++[.,]?\\d*+) blia", + "(\\d++[.,]?\\d*+) bhliadhna air ais", + "(\\d++[.,]?\\d*+) bliadhna air ais" ], "in \\1 day": [ - "an ceann (\\d+[.,]?\\d*) latha", - "an (\\d+[.,]?\\d*) là" + "an ceann (\\d++[.,]?\\d*+) latha", + "an (\\d++[.,]?\\d*+) là" ], "in \\1 hour": [ - "an ceann (\\d+[.,]?\\d*) uair a thìde", - "an (\\d+[.,]?\\d*) uair" + "an ceann (\\d++[.,]?\\d*+) uair a thìde", + "an (\\d++[.,]?\\d*+) uair" ], "in \\1 minute": [ - "an ceann (\\d+[.,]?\\d*) mhionaid", - "an ceann (\\d+[.,]?\\d*) mionaid", - "an (\\d+[.,]?\\d*) mhion", - "an (\\d+[.,]?\\d*) mion" + "an ceann (\\d++[.,]?\\d*+) mhionaid", + "an ceann (\\d++[.,]?\\d*+) mionaid", + "an (\\d++[.,]?\\d*+) mhion", + "an (\\d++[.,]?\\d*+) mion" ], "in \\1 month": [ - "an ceann (\\d+[.,]?\\d*) mhìosa", - "an ceann (\\d+[.,]?\\d*) mìosa", - "an (\\d+[.,]?\\d*) mhìos", - "an (\\d+[.,]?\\d*) mìos" + "an ceann (\\d++[.,]?\\d*+) mhìosa", + "an ceann (\\d++[.,]?\\d*+) mìosa", + "an (\\d++[.,]?\\d*+) mhìos", + "an (\\d++[.,]?\\d*+) mìos" ], "in \\1 second": [ - "an ceann (\\d+[.,]?\\d*) diog", - "an (\\d+[.,]?\\d*) diog" + "an ceann (\\d++[.,]?\\d*+) diog", + "an (\\d++[.,]?\\d*+) diog" ], "in \\1 week": [ - "an ceann (\\d+[.,]?\\d*) seachdain", - "an (\\d+[.,]?\\d*) seachd", - "an (\\d+[.,]?\\d*) sheachd" + "an ceann (\\d++[.,]?\\d*+) seachdain", + "an (\\d++[.,]?\\d*+) seachd", + "an (\\d++[.,]?\\d*+) sheachd" ], "in \\1 year": [ - "an ceann (\\d+[.,]?\\d*) bhliadhna", - "an ceann (\\d+[.,]?\\d*) bliadhna", - "an (\\d+[.,]?\\d*) bhlia", - "an (\\d+[.,]?\\d*) blia" + "an ceann (\\d++[.,]?\\d*+) bhliadhna", + "an ceann (\\d++[.,]?\\d*+) bliadhna", + "an (\\d++[.,]?\\d*+) bhlia", + "an (\\d++[.,]?\\d*+) blia" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/gl.py b/dateparser/data/date_translation_data/gl.py index 367412444..588edc111 100644 --- a/dateparser/data/date_translation_data/gl.py +++ b/dateparser/data/date_translation_data/gl.py @@ -165,74 +165,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "hai (\\d+[.,]?\\d*) d", - "hai (\\d+[.,]?\\d*) día", - "hai (\\d+[.,]?\\d*) días" + "hai (\\d++[.,]?\\d*+) d", + "hai (\\d++[.,]?\\d*+) día", + "hai (\\d++[.,]?\\d*+) días" ], "\\1 hour ago": [ - "hai (\\d+[.,]?\\d*) h", - "hai (\\d+[.,]?\\d*) hora", - "hai (\\d+[.,]?\\d*) horas" + "hai (\\d++[.,]?\\d*+) h", + "hai (\\d++[.,]?\\d*+) hora", + "hai (\\d++[.,]?\\d*+) horas" ], "\\1 minute ago": [ - "hai (\\d+[.,]?\\d*) min", - "hai (\\d+[.,]?\\d*) minuto", - "hai (\\d+[.,]?\\d*) minutos" + "hai (\\d++[.,]?\\d*+) min", + "hai (\\d++[.,]?\\d*+) minuto", + "hai (\\d++[.,]?\\d*+) minutos" ], "\\1 month ago": [ - "hai (\\d+[.,]?\\d*) m", - "hai (\\d+[.,]?\\d*) mes", - "hai (\\d+[.,]?\\d*) meses" + "hai (\\d++[.,]?\\d*+) m", + "hai (\\d++[.,]?\\d*+) mes", + "hai (\\d++[.,]?\\d*+) meses" ], "\\1 second ago": [ - "hai (\\d+[.,]?\\d*) s", - "hai (\\d+[.,]?\\d*) segundo", - "hai (\\d+[.,]?\\d*) segundos" + "hai (\\d++[.,]?\\d*+) s", + "hai (\\d++[.,]?\\d*+) segundo", + "hai (\\d++[.,]?\\d*+) segundos" ], "\\1 week ago": [ - "hai (\\d+[.,]?\\d*) sem", - "hai (\\d+[.,]?\\d*) semana", - "hai (\\d+[.,]?\\d*) semanas" + "hai (\\d++[.,]?\\d*+) sem", + "hai (\\d++[.,]?\\d*+) semana", + "hai (\\d++[.,]?\\d*+) semanas" ], "\\1 year ago": [ - "hai (\\d+[.,]?\\d*) a", - "hai (\\d+[.,]?\\d*) ano", - "hai (\\d+[.,]?\\d*) anos" + "hai (\\d++[.,]?\\d*+) a", + "hai (\\d++[.,]?\\d*+) ano", + "hai (\\d++[.,]?\\d*+) anos" ], "in \\1 day": [ - "en (\\d+[.,]?\\d*) d", - "en (\\d+[.,]?\\d*) día", - "en (\\d+[.,]?\\d*) días" + "en (\\d++[.,]?\\d*+) d", + "en (\\d++[.,]?\\d*+) día", + "en (\\d++[.,]?\\d*+) días" ], "in \\1 hour": [ - "en (\\d+[.,]?\\d*) h", - "en (\\d+[.,]?\\d*) hora", - "en (\\d+[.,]?\\d*) horas" + "en (\\d++[.,]?\\d*+) h", + "en (\\d++[.,]?\\d*+) hora", + "en (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "en (\\d+[.,]?\\d*) min", - "en (\\d+[.,]?\\d*) minuto", - "en (\\d+[.,]?\\d*) minutos" + "en (\\d++[.,]?\\d*+) min", + "en (\\d++[.,]?\\d*+) minuto", + "en (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "en (\\d+[.,]?\\d*) m", - "en (\\d+[.,]?\\d*) mes", - "en (\\d+[.,]?\\d*) meses" + "en (\\d++[.,]?\\d*+) m", + "en (\\d++[.,]?\\d*+) mes", + "en (\\d++[.,]?\\d*+) meses" ], "in \\1 second": [ - "en (\\d+[.,]?\\d*) s", - "en (\\d+[.,]?\\d*) segundo", - "en (\\d+[.,]?\\d*) segundos" + "en (\\d++[.,]?\\d*+) s", + "en (\\d++[.,]?\\d*+) segundo", + "en (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "en (\\d+[.,]?\\d*) sem", - "en (\\d+[.,]?\\d*) semana", - "en (\\d+[.,]?\\d*) semanas" + "en (\\d++[.,]?\\d*+) sem", + "en (\\d++[.,]?\\d*+) semana", + "en (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "en (\\d+[.,]?\\d*) a", - "en (\\d+[.,]?\\d*) ano", - "en (\\d+[.,]?\\d*) anos" + "en (\\d++[.,]?\\d*+) a", + "en (\\d++[.,]?\\d*+) ano", + "en (\\d++[.,]?\\d*+) anos" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/gu.py b/dateparser/data/date_translation_data/gu.py index 161fa15b2..86d362f7d 100644 --- a/dateparser/data/date_translation_data/gu.py +++ b/dateparser/data/date_translation_data/gu.py @@ -153,49 +153,49 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) દિવસ પહેલાં" + "(\\d++[.,]?\\d*+) દિવસ પહેલાં" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) કલાક પહેલાં" + "(\\d++[.,]?\\d*+) કલાક પહેલાં" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) મિનિટ પહેલાં" + "(\\d++[.,]?\\d*+) મિનિટ પહેલાં" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) મહિના પહેલાં" + "(\\d++[.,]?\\d*+) મહિના પહેલાં" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) સેકંડ પહેલાં" + "(\\d++[.,]?\\d*+) સેકંડ પહેલાં" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) અઠ પહેલાં", - "(\\d+[.,]?\\d*) અઠવાડિયા પહેલાં" + "(\\d++[.,]?\\d*+) અઠ પહેલાં", + "(\\d++[.,]?\\d*+) અઠવાડિયા પહેલાં" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) વર્ષ પહેલા", - "(\\d+[.,]?\\d*) વર્ષ પહેલાં" + "(\\d++[.,]?\\d*+) વર્ષ પહેલા", + "(\\d++[.,]?\\d*+) વર્ષ પહેલાં" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) દિવસમાં" + "(\\d++[.,]?\\d*+) દિવસમાં" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) કલાકમાં" + "(\\d++[.,]?\\d*+) કલાકમાં" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) મિનિટમાં" + "(\\d++[.,]?\\d*+) મિનિટમાં" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) મહિનામાં" + "(\\d++[.,]?\\d*+) મહિનામાં" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) સેકંડમાં" + "(\\d++[.,]?\\d*+) સેકંડમાં" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) અઠ માં", - "(\\d+[.,]?\\d*) અઠવાડિયામાં" + "(\\d++[.,]?\\d*+) અઠ માં", + "(\\d++[.,]?\\d*+) અઠવાડિયામાં" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) વર્ષમાં" + "(\\d++[.,]?\\d*+) વર્ષમાં" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/he.py b/dateparser/data/date_translation_data/he.py index 1f6ce4cef..d933fcc91 100644 --- a/dateparser/data/date_translation_data/he.py +++ b/dateparser/data/date_translation_data/he.py @@ -218,60 +218,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "לפני (\\d+[.,]?\\d*) ימים", - "לפני (\\d+[.,]?\\d*) ימ׳", - "לפני יום (\\d+[.,]?\\d*)" + "לפני (\\d++[.,]?\\d*+) ימים", + "לפני (\\d++[.,]?\\d*+) ימ׳", + "לפני יום (\\d++[.,]?\\d*+)" ], "\\1 hour ago": [ - "לפני (\\d+[.,]?\\d*) שעות", - "לפני (\\d+[.,]?\\d*) שע׳" + "לפני (\\d++[.,]?\\d*+) שעות", + "לפני (\\d++[.,]?\\d*+) שע׳" ], "\\1 minute ago": [ - "לפני (\\d+[.,]?\\d*) דקות", - "לפני (\\d+[.,]?\\d*) דק׳" + "לפני (\\d++[.,]?\\d*+) דקות", + "לפני (\\d++[.,]?\\d*+) דק׳" ], "\\1 month ago": [ - "לפני (\\d+[.,]?\\d*) חודשים", - "לפני (\\d+[.,]?\\d*) חו׳" + "לפני (\\d++[.,]?\\d*+) חודשים", + "לפני (\\d++[.,]?\\d*+) חו׳" ], "\\1 second ago": [ - "לפני (\\d+[.,]?\\d*) שניות", - "לפני (\\d+[.,]?\\d*) שנ׳" + "לפני (\\d++[.,]?\\d*+) שניות", + "לפני (\\d++[.,]?\\d*+) שנ׳" ], "\\1 week ago": [ - "לפני (\\d+[.,]?\\d*) שבועות", - "לפני (\\d+[.,]?\\d*) שב׳" + "לפני (\\d++[.,]?\\d*+) שבועות", + "לפני (\\d++[.,]?\\d*+) שב׳" ], "\\1 year ago": [ - "לפני (\\d+[.,]?\\d*) שנים" + "לפני (\\d++[.,]?\\d*+) שנים" ], "in \\1 day": [ - "בעוד (\\d+[.,]?\\d*) ימים", - "בעוד (\\d+[.,]?\\d*) ימ׳", - "בעוד יום (\\d+[.,]?\\d*)" + "בעוד (\\d++[.,]?\\d*+) ימים", + "בעוד (\\d++[.,]?\\d*+) ימ׳", + "בעוד יום (\\d++[.,]?\\d*+)" ], "in \\1 hour": [ - "בעוד (\\d+[.,]?\\d*) שעות", - "בעוד (\\d+[.,]?\\d*) שע׳" + "בעוד (\\d++[.,]?\\d*+) שעות", + "בעוד (\\d++[.,]?\\d*+) שע׳" ], "in \\1 minute": [ - "בעוד (\\d+[.,]?\\d*) דקות", - "בעוד (\\d+[.,]?\\d*) דק׳" + "בעוד (\\d++[.,]?\\d*+) דקות", + "בעוד (\\d++[.,]?\\d*+) דק׳" ], "in \\1 month": [ - "בעוד (\\d+[.,]?\\d*) חודשים", - "בעוד (\\d+[.,]?\\d*) חו׳" + "בעוד (\\d++[.,]?\\d*+) חודשים", + "בעוד (\\d++[.,]?\\d*+) חו׳" ], "in \\1 second": [ - "בעוד (\\d+[.,]?\\d*) שניות", - "בעוד (\\d+[.,]?\\d*) שנ׳" + "בעוד (\\d++[.,]?\\d*+) שניות", + "בעוד (\\d++[.,]?\\d*+) שנ׳" ], "in \\1 week": [ - "בעוד (\\d+[.,]?\\d*) שבועות", - "בעוד (\\d+[.,]?\\d*) שב׳" + "בעוד (\\d++[.,]?\\d*+) שבועות", + "בעוד (\\d++[.,]?\\d*+) שב׳" ], "in \\1 year": [ - "בעוד (\\d+[.,]?\\d*) שנים" + "בעוד (\\d++[.,]?\\d*+) שנים" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/hi.py b/dateparser/data/date_translation_data/hi.py index eabe94bbf..4a87df507 100644 --- a/dateparser/data/date_translation_data/hi.py +++ b/dateparser/data/date_translation_data/hi.py @@ -172,58 +172,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) दिन पहले" + "(\\d++[.,]?\\d*+) दिन पहले" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) घं पहले", - "(\\d+[.,]?\\d*) घंटे पहले" + "(\\d++[.,]?\\d*+) घं पहले", + "(\\d++[.,]?\\d*+) घंटे पहले" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) मि पहले", - "(\\d+[.,]?\\d*) मिनट पहले" + "(\\d++[.,]?\\d*+) मि पहले", + "(\\d++[.,]?\\d*+) मिनट पहले" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) माह पहले" + "(\\d++[.,]?\\d*+) माह पहले" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) से पहले", - "(\\d+[.,]?\\d*) सेकंड पहले" + "(\\d++[.,]?\\d*+) से पहले", + "(\\d++[.,]?\\d*+) सेकंड पहले" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) सप्ताह पहले" + "(\\d++[.,]?\\d*+) सप्ताह पहले" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) वर्ष पहले" + "(\\d++[.,]?\\d*+) वर्ष पहले" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) दिन में" + "(\\d++[.,]?\\d*+) दिन में" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) घं में", - "(\\d+[.,]?\\d*) घंटे में" + "(\\d++[.,]?\\d*+) घं में", + "(\\d++[.,]?\\d*+) घंटे में" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) मि में", - "(\\d+[.,]?\\d*) मिनट में" + "(\\d++[.,]?\\d*+) मि में", + "(\\d++[.,]?\\d*+) मिनट में" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) माह में" + "(\\d++[.,]?\\d*+) माह में" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) से में", - "(\\d+[.,]?\\d*) सेकंड में" + "(\\d++[.,]?\\d*+) से में", + "(\\d++[.,]?\\d*+) सेकंड में" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) सप्ताह में" + "(\\d++[.,]?\\d*+) सप्ताह में" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) वर्ष में" + "(\\d++[.,]?\\d*+) वर्ष में" ], "in \\1 decade": [ - "(\\d+[.,]?\\d*) दशक में" + "(\\d++[.,]?\\d*+) दशक में" ], "\\1 decade ago": [ - "(\\d+[.,]?\\d*) दशक पहले" + "(\\d++[.,]?\\d*+) दशक पहले" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/hr.py b/dateparser/data/date_translation_data/hr.py index 781c52cb4..60a6f38e8 100644 --- a/dateparser/data/date_translation_data/hr.py +++ b/dateparser/data/date_translation_data/hr.py @@ -261,88 +261,88 @@ }, "relative-type-regex": { "\\1 day ago": [ - "prije (\\d+[.,]?\\d*) d", - "prije (\\d+[.,]?\\d*) dan", - "prije (\\d+[.,]?\\d*) dana" + "prije (\\d++[.,]?\\d*+) d", + "prije (\\d++[.,]?\\d*+) dan", + "prije (\\d++[.,]?\\d*+) dana" ], "\\1 hour ago": [ - "prije (\\d+[.,]?\\d*) h", - "prije (\\d+[.,]?\\d*) sat", - "prije (\\d+[.,]?\\d*) sati", - "prije (\\d+[.,]?\\d*) sata" + "prije (\\d++[.,]?\\d*+) h", + "prije (\\d++[.,]?\\d*+) sat", + "prije (\\d++[.,]?\\d*+) sati", + "prije (\\d++[.,]?\\d*+) sata" ], "\\1 minute ago": [ - "prije (\\d+[.,]?\\d*) min", - "prije (\\d+[.,]?\\d*) minuta", - "prije (\\d+[.,]?\\d*) minutu", - "prije (\\d+[.,]?\\d*) minute" + "prije (\\d++[.,]?\\d*+) min", + "prije (\\d++[.,]?\\d*+) minuta", + "prije (\\d++[.,]?\\d*+) minutu", + "prije (\\d++[.,]?\\d*+) minute" ], "\\1 month ago": [ - "prije (\\d+[.,]?\\d*) mj", - "prije (\\d+[.,]?\\d*) mjesec", - "prije (\\d+[.,]?\\d*) mjeseci", - "prije (\\d+[.,]?\\d*) mjeseca" + "prije (\\d++[.,]?\\d*+) mj", + "prije (\\d++[.,]?\\d*+) mjesec", + "prije (\\d++[.,]?\\d*+) mjeseci", + "prije (\\d++[.,]?\\d*+) mjeseca" ], "\\1 second ago": [ - "prije (\\d+[.,]?\\d*) s", - "prije (\\d+[.,]?\\d*) sekundi", - "prije (\\d+[.,]?\\d*) sekundu", - "prije (\\d+[.,]?\\d*) sekunde", - "prije (\\d+[.,]?\\d*) sekundu" + "prije (\\d++[.,]?\\d*+) s", + "prije (\\d++[.,]?\\d*+) sekundi", + "prije (\\d++[.,]?\\d*+) sekundu", + "prije (\\d++[.,]?\\d*+) sekunde", + "prije (\\d++[.,]?\\d*+) sekundu" ], "\\1 week ago": [ - "prije (\\d+[.,]?\\d*) tj", - "prije (\\d+[.,]?\\d*) tjedan", - "prije (\\d+[.,]?\\d*) tjedana", - "prije (\\d+[.,]?\\d*) tjedna" + "prije (\\d++[.,]?\\d*+) tj", + "prije (\\d++[.,]?\\d*+) tjedan", + "prije (\\d++[.,]?\\d*+) tjedana", + "prije (\\d++[.,]?\\d*+) tjedna" ], "\\1 year ago": [ - "prije (\\d+[.,]?\\d*) g", - "prije (\\d+[.,]?\\d*) godina", - "prije (\\d+[.,]?\\d*) godinu", - "prije (\\d+[.,]?\\d*) godine" + "prije (\\d++[.,]?\\d*+) g", + "prije (\\d++[.,]?\\d*+) godina", + "prije (\\d++[.,]?\\d*+) godinu", + "prije (\\d++[.,]?\\d*+) godine" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) d", - "za (\\d+[.,]?\\d*) dan", - "za (\\d+[.,]?\\d*) dana" + "za (\\d++[.,]?\\d*+) d", + "za (\\d++[.,]?\\d*+) dan", + "za (\\d++[.,]?\\d*+) dana" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) h", - "za (\\d+[.,]?\\d*) sat", - "za (\\d+[.,]?\\d*) sati", - "za (\\d+[.,]?\\d*) sata" + "za (\\d++[.,]?\\d*+) h", + "za (\\d++[.,]?\\d*+) sat", + "za (\\d++[.,]?\\d*+) sati", + "za (\\d++[.,]?\\d*+) sata" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minuta", - "za (\\d+[.,]?\\d*) minutu", - "za (\\d+[.,]?\\d*) minute" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minuta", + "za (\\d++[.,]?\\d*+) minutu", + "za (\\d++[.,]?\\d*+) minute" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) mj", - "za (\\d+[.,]?\\d*) mjesec", - "za (\\d+[.,]?\\d*) mjeseci", - "za (\\d+[.,]?\\d*) mjeseca" + "za (\\d++[.,]?\\d*+) mj", + "za (\\d++[.,]?\\d*+) mjesec", + "za (\\d++[.,]?\\d*+) mjeseci", + "za (\\d++[.,]?\\d*+) mjeseca" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sekundi", - "za (\\d+[.,]?\\d*) sekundu", - "za (\\d+[.,]?\\d*) sekunde", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sekundi", + "za (\\d++[.,]?\\d*+) sekundu", + "za (\\d++[.,]?\\d*+) sekunde", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) tj", - "za (\\d+[.,]?\\d*) tjedan", - "za (\\d+[.,]?\\d*) tjedana", - "za (\\d+[.,]?\\d*) tjedna" + "za (\\d++[.,]?\\d*+) tj", + "za (\\d++[.,]?\\d*+) tjedan", + "za (\\d++[.,]?\\d*+) tjedana", + "za (\\d++[.,]?\\d*+) tjedna" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) godina", - "za (\\d+[.,]?\\d*) godinu", - "za (\\d+[.,]?\\d*) godine" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) godina", + "za (\\d++[.,]?\\d*+) godinu", + "za (\\d++[.,]?\\d*+) godine" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/hsb.py b/dateparser/data/date_translation_data/hsb.py index 52b53866c..1ea5a7161 100644 --- a/dateparser/data/date_translation_data/hsb.py +++ b/dateparser/data/date_translation_data/hsb.py @@ -175,82 +175,82 @@ }, "relative-type-regex": { "\\1 day ago": [ - "před (\\d+[.,]?\\d*) d", - "před (\\d+[.,]?\\d*) dnj", - "před (\\d+[.,]?\\d*) dnjemi", - "před (\\d+[.,]?\\d*) dnjom" + "před (\\d++[.,]?\\d*+) d", + "před (\\d++[.,]?\\d*+) dnj", + "před (\\d++[.,]?\\d*+) dnjemi", + "před (\\d++[.,]?\\d*+) dnjom" ], "\\1 hour ago": [ - "před (\\d+[.,]?\\d*) h", - "před (\\d+[.,]?\\d*) hodź", - "před (\\d+[.,]?\\d*) hodźinami", - "před (\\d+[.,]?\\d*) hodźinu" + "před (\\d++[.,]?\\d*+) h", + "před (\\d++[.,]?\\d*+) hodź", + "před (\\d++[.,]?\\d*+) hodźinami", + "před (\\d++[.,]?\\d*+) hodźinu" ], "\\1 minute ago": [ - "před (\\d+[.,]?\\d*) m", - "před (\\d+[.,]?\\d*) min", - "před (\\d+[.,]?\\d*) minutami", - "před (\\d+[.,]?\\d*) minutu" + "před (\\d++[.,]?\\d*+) m", + "před (\\d++[.,]?\\d*+) min", + "před (\\d++[.,]?\\d*+) minutami", + "před (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "před (\\d+[.,]?\\d*) měs", - "před (\\d+[.,]?\\d*) měsacami", - "před (\\d+[.,]?\\d*) měsacom" + "před (\\d++[.,]?\\d*+) měs", + "před (\\d++[.,]?\\d*+) měsacami", + "před (\\d++[.,]?\\d*+) měsacom" ], "\\1 second ago": [ - "před (\\d+[.,]?\\d*) s", - "před (\\d+[.,]?\\d*) sek", - "před (\\d+[.,]?\\d*) sekundami", - "před (\\d+[.,]?\\d*) sekundu" + "před (\\d++[.,]?\\d*+) s", + "před (\\d++[.,]?\\d*+) sek", + "před (\\d++[.,]?\\d*+) sekundami", + "před (\\d++[.,]?\\d*+) sekundu" ], "\\1 week ago": [ - "před (\\d+[.,]?\\d*) tydź", - "před (\\d+[.,]?\\d*) tydźenjemi", - "před (\\d+[.,]?\\d*) tydźenjom" + "před (\\d++[.,]?\\d*+) tydź", + "před (\\d++[.,]?\\d*+) tydźenjemi", + "před (\\d++[.,]?\\d*+) tydźenjom" ], "\\1 year ago": [ - "před (\\d+[.,]?\\d*) l", - "před (\\d+[.,]?\\d*) lětami", - "před (\\d+[.,]?\\d*) lětom" + "před (\\d++[.,]?\\d*+) l", + "před (\\d++[.,]?\\d*+) lětami", + "před (\\d++[.,]?\\d*+) lětom" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) d", - "za (\\d+[.,]?\\d*) dnj", - "za (\\d+[.,]?\\d*) dnjow", - "za (\\d+[.,]?\\d*) dźeń" + "za (\\d++[.,]?\\d*+) d", + "za (\\d++[.,]?\\d*+) dnj", + "za (\\d++[.,]?\\d*+) dnjow", + "za (\\d++[.,]?\\d*+) dźeń" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) h", - "za (\\d+[.,]?\\d*) hodź", - "za (\\d+[.,]?\\d*) hodźin", - "za (\\d+[.,]?\\d*) hodźinu" + "za (\\d++[.,]?\\d*+) h", + "za (\\d++[.,]?\\d*+) hodź", + "za (\\d++[.,]?\\d*+) hodźin", + "za (\\d++[.,]?\\d*+) hodźinu" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) m", - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minutow", - "za (\\d+[.,]?\\d*) minutu" + "za (\\d++[.,]?\\d*+) m", + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minutow", + "za (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) měs", - "za (\\d+[.,]?\\d*) měsac", - "za (\\d+[.,]?\\d*) měsacow" + "za (\\d++[.,]?\\d*+) měs", + "za (\\d++[.,]?\\d*+) měsac", + "za (\\d++[.,]?\\d*+) měsacow" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundow", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundow", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) tydź", - "za (\\d+[.,]?\\d*) tydźenjow", - "za (\\d+[.,]?\\d*) tydźeń" + "za (\\d++[.,]?\\d*+) tydź", + "za (\\d++[.,]?\\d*+) tydźenjow", + "za (\\d++[.,]?\\d*+) tydźeń" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) l", - "za (\\d+[.,]?\\d*) lět", - "za (\\d+[.,]?\\d*) lěto" + "za (\\d++[.,]?\\d*+) l", + "za (\\d++[.,]?\\d*+) lět", + "za (\\d++[.,]?\\d*+) lěto" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/hu.py b/dateparser/data/date_translation_data/hu.py index e45d89a33..3906bab29 100644 --- a/dateparser/data/date_translation_data/hu.py +++ b/dateparser/data/date_translation_data/hu.py @@ -202,47 +202,47 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) napja", - "(\\d+[.,]?\\d*) nappal ezelőtt" + "(\\d++[.,]?\\d*+) napja", + "(\\d++[.,]?\\d*+) nappal ezelőtt" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) órával ezelőtt" + "(\\d++[.,]?\\d*+) órával ezelőtt" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) perccel ezelőtt" + "(\\d++[.,]?\\d*+) perccel ezelőtt" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) hónappal ezelőtt" + "(\\d++[.,]?\\d*+) hónappal ezelőtt" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) másodperccel ezelőtt" + "(\\d++[.,]?\\d*+) másodperccel ezelőtt" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) héttel ezelőtt" + "(\\d++[.,]?\\d*+) héttel ezelőtt" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) évvel ezelőtt" + "(\\d++[.,]?\\d*+) évvel ezelőtt" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) nap múlva" + "(\\d++[.,]?\\d*+) nap múlva" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) óra múlva" + "(\\d++[.,]?\\d*+) óra múlva" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) perc múlva" + "(\\d++[.,]?\\d*+) perc múlva" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) hónap múlva" + "(\\d++[.,]?\\d*+) hónap múlva" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) másodperc múlva" + "(\\d++[.,]?\\d*+) másodperc múlva" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) hét múlva" + "(\\d++[.,]?\\d*+) hét múlva" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) év múlva" + "(\\d++[.,]?\\d*+) év múlva" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/hy.py b/dateparser/data/date_translation_data/hy.py index 596a2658d..9ac4a9129 100644 --- a/dateparser/data/date_translation_data/hy.py +++ b/dateparser/data/date_translation_data/hy.py @@ -174,58 +174,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) օր առաջ" + "(\\d++[.,]?\\d*+) օր առաջ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ժ առաջ", - "(\\d+[.,]?\\d*) ժամ առաջ" + "(\\d++[.,]?\\d*+) ժ առաջ", + "(\\d++[.,]?\\d*+) ժամ առաջ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) ր առաջ", - "(\\d+[.,]?\\d*) րոպե առաջ" + "(\\d++[.,]?\\d*+) ր առաջ", + "(\\d++[.,]?\\d*+) րոպե առաջ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ամիս առաջ" + "(\\d++[.,]?\\d*+) ամիս առաջ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) վ առաջ", - "(\\d+[.,]?\\d*) վայրկյան առաջ", - "(\\d+[.,]?\\d*) վրկ առաջ" + "(\\d++[.,]?\\d*+) վ առաջ", + "(\\d++[.,]?\\d*+) վայրկյան առաջ", + "(\\d++[.,]?\\d*+) վրկ առաջ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) շաբ առաջ", - "(\\d+[.,]?\\d*) շաբաթ առաջ" + "(\\d++[.,]?\\d*+) շաբ առաջ", + "(\\d++[.,]?\\d*+) շաբաթ առաջ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) տ առաջ", - "(\\d+[.,]?\\d*) տարի առաջ" + "(\\d++[.,]?\\d*+) տ առաջ", + "(\\d++[.,]?\\d*+) տարի առաջ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) օրից" + "(\\d++[.,]?\\d*+) օրից" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ժ-ից", - "(\\d+[.,]?\\d*) ժամից" + "(\\d++[.,]?\\d*+) ժ-ից", + "(\\d++[.,]?\\d*+) ժամից" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) ր-ից", - "(\\d+[.,]?\\d*) րոպեից" + "(\\d++[.,]?\\d*+) ր-ից", + "(\\d++[.,]?\\d*+) րոպեից" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ամսից" + "(\\d++[.,]?\\d*+) ամսից" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) վ-ից", - "(\\d+[.,]?\\d*) վայրկյանից", - "(\\d+[.,]?\\d*) վրկ-ից" + "(\\d++[.,]?\\d*+) վ-ից", + "(\\d++[.,]?\\d*+) վայրկյանից", + "(\\d++[.,]?\\d*+) վրկ-ից" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) շաբ անց", - "(\\d+[.,]?\\d*) շաբ-ից", - "(\\d+[.,]?\\d*) շաբաթից" + "(\\d++[.,]?\\d*+) շաբ անց", + "(\\d++[.,]?\\d*+) շաբ-ից", + "(\\d++[.,]?\\d*+) շաբաթից" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) տարուց" + "(\\d++[.,]?\\d*+) տարուց" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/id.py b/dateparser/data/date_translation_data/id.py index fe3e59e6b..73bd5b7b2 100644 --- a/dateparser/data/date_translation_data/id.py +++ b/dateparser/data/date_translation_data/id.py @@ -180,65 +180,65 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) h lalu", - "(\\d+[.,]?\\d*) hari yang lalu" + "(\\d++[.,]?\\d*+) h lalu", + "(\\d++[.,]?\\d*+) hari yang lalu" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) jam lalu", - "(\\d+[.,]?\\d*) jam yang lalu" + "(\\d++[.,]?\\d*+) jam lalu", + "(\\d++[.,]?\\d*+) jam yang lalu" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) menit yang lalu", - "(\\d+[.,]?\\d*) mnt lalu" + "(\\d++[.,]?\\d*+) menit yang lalu", + "(\\d++[.,]?\\d*+) mnt lalu" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) bln lalu", - "(\\d+[.,]?\\d*) bulan yang lalu", - "(\\d+[.,]?\\d*) bulan lalu" + "(\\d++[.,]?\\d*+) bln lalu", + "(\\d++[.,]?\\d*+) bulan yang lalu", + "(\\d++[.,]?\\d*+) bulan lalu" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) detik yang lalu", - "(\\d+[.,]?\\d*) dtk lalu" + "(\\d++[.,]?\\d*+) detik yang lalu", + "(\\d++[.,]?\\d*+) dtk lalu" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) mgg lalu", - "(\\d+[.,]?\\d*) minggu yang lalu", - "(\\d+[.,]?\\d*) minggu lalu" + "(\\d++[.,]?\\d*+) mgg lalu", + "(\\d++[.,]?\\d*+) minggu yang lalu", + "(\\d++[.,]?\\d*+) minggu lalu" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) tahun yang lalu", - "(\\d+[.,]?\\d*) thn lalu", - "(\\d+[.,]?\\d*) tahun lalu" + "(\\d++[.,]?\\d*+) tahun yang lalu", + "(\\d++[.,]?\\d*+) thn lalu", + "(\\d++[.,]?\\d*+) tahun lalu" ], "in \\1 day": [ - "dalam (\\d+[.,]?\\d*) h", - "dalam (\\d+[.,]?\\d*) hari" + "dalam (\\d++[.,]?\\d*+) h", + "dalam (\\d++[.,]?\\d*+) hari" ], "in \\1 hour": [ - "dalam (\\d+[.,]?\\d*) jam" + "dalam (\\d++[.,]?\\d*+) jam" ], "in \\1 minute": [ - "dalam (\\d+[.,]?\\d*) menit", - "dlm (\\d+[.,]?\\d*) mnt" + "dalam (\\d++[.,]?\\d*+) menit", + "dlm (\\d++[.,]?\\d*+) mnt" ], "in \\1 month": [ - "dalam (\\d+[.,]?\\d*) bulan", - "dlm (\\d+[.,]?\\d*) bln" + "dalam (\\d++[.,]?\\d*+) bulan", + "dlm (\\d++[.,]?\\d*+) bln" ], "in \\1 second": [ - "dalam (\\d+[.,]?\\d*) detik", - "dlm (\\d+[.,]?\\d*) dtk" + "dalam (\\d++[.,]?\\d*+) detik", + "dlm (\\d++[.,]?\\d*+) dtk" ], "in \\1 week": [ - "dalam (\\d+[.,]?\\d*) minggu", - "dlm (\\d+[.,]?\\d*) mgg" + "dalam (\\d++[.,]?\\d*+) minggu", + "dlm (\\d++[.,]?\\d*+) mgg" ], "in \\1 year": [ - "dalam (\\d+[.,]?\\d*) tahun", - "dlm (\\d+[.,]?\\d*) thn" + "dalam (\\d++[.,]?\\d*+) tahun", + "dlm (\\d++[.,]?\\d*+) thn" ], "\\1 week": [ - "(\\d+[.,]?\\d*) minggu" + "(\\d++[.,]?\\d*+) minggu" ], "sunday": [ "minggu" diff --git a/dateparser/data/date_translation_data/is.py b/dateparser/data/date_translation_data/is.py index 40e481bb7..ac499759d 100644 --- a/dateparser/data/date_translation_data/is.py +++ b/dateparser/data/date_translation_data/is.py @@ -161,67 +161,67 @@ }, "relative-type-regex": { "\\1 day ago": [ - "fyrir (\\d+[.,]?\\d*) degi", - "fyrir (\\d+[.,]?\\d*) dögum" + "fyrir (\\d++[.,]?\\d*+) degi", + "fyrir (\\d++[.,]?\\d*+) dögum" ], "\\1 hour ago": [ - "fyrir (\\d+[.,]?\\d*) klst", - "fyrir (\\d+[.,]?\\d*) klukkustund", - "fyrir (\\d+[.,]?\\d*) klukkustundum" + "fyrir (\\d++[.,]?\\d*+) klst", + "fyrir (\\d++[.,]?\\d*+) klukkustund", + "fyrir (\\d++[.,]?\\d*+) klukkustundum" ], "\\1 minute ago": [ - "fyrir (\\d+[.,]?\\d*) mín", - "fyrir (\\d+[.,]?\\d*) mínútu", - "fyrir (\\d+[.,]?\\d*) mínútum" + "fyrir (\\d++[.,]?\\d*+) mín", + "fyrir (\\d++[.,]?\\d*+) mínútu", + "fyrir (\\d++[.,]?\\d*+) mínútum" ], "\\1 month ago": [ - "fyrir (\\d+[.,]?\\d*) mán", - "fyrir (\\d+[.,]?\\d*) mánuði", - "fyrir (\\d+[.,]?\\d*) mánuðum" + "fyrir (\\d++[.,]?\\d*+) mán", + "fyrir (\\d++[.,]?\\d*+) mánuði", + "fyrir (\\d++[.,]?\\d*+) mánuðum" ], "\\1 second ago": [ - "fyrir (\\d+[.,]?\\d*) sek", - "fyrir (\\d+[.,]?\\d*) sekúndu", - "fyrir (\\d+[.,]?\\d*) sekúndum" + "fyrir (\\d++[.,]?\\d*+) sek", + "fyrir (\\d++[.,]?\\d*+) sekúndu", + "fyrir (\\d++[.,]?\\d*+) sekúndum" ], "\\1 week ago": [ - "fyrir (\\d+[.,]?\\d*) viku", - "fyrir (\\d+[.,]?\\d*) vikum" + "fyrir (\\d++[.,]?\\d*+) viku", + "fyrir (\\d++[.,]?\\d*+) vikum" ], "\\1 year ago": [ - "fyrir (\\d+[.,]?\\d*) ári", - "fyrir (\\d+[.,]?\\d*) árum" + "fyrir (\\d++[.,]?\\d*+) ári", + "fyrir (\\d++[.,]?\\d*+) árum" ], "in \\1 day": [ - "eftir (\\d+[.,]?\\d*) dag", - "eftir (\\d+[.,]?\\d*) daga" + "eftir (\\d++[.,]?\\d*+) dag", + "eftir (\\d++[.,]?\\d*+) daga" ], "in \\1 hour": [ - "eftir (\\d+[.,]?\\d*) klst", - "eftir (\\d+[.,]?\\d*) klukkustund", - "eftir (\\d+[.,]?\\d*) klukkustundir" + "eftir (\\d++[.,]?\\d*+) klst", + "eftir (\\d++[.,]?\\d*+) klukkustund", + "eftir (\\d++[.,]?\\d*+) klukkustundir" ], "in \\1 minute": [ - "eftir (\\d+[.,]?\\d*) mín", - "eftir (\\d+[.,]?\\d*) mínútu", - "eftir (\\d+[.,]?\\d*) mínútur" + "eftir (\\d++[.,]?\\d*+) mín", + "eftir (\\d++[.,]?\\d*+) mínútu", + "eftir (\\d++[.,]?\\d*+) mínútur" ], "in \\1 month": [ - "eftir (\\d+[.,]?\\d*) mán", - "eftir (\\d+[.,]?\\d*) mánuð", - "eftir (\\d+[.,]?\\d*) mánuði" + "eftir (\\d++[.,]?\\d*+) mán", + "eftir (\\d++[.,]?\\d*+) mánuð", + "eftir (\\d++[.,]?\\d*+) mánuði" ], "in \\1 second": [ - "eftir (\\d+[.,]?\\d*) sek", - "eftir (\\d+[.,]?\\d*) sekúndu", - "eftir (\\d+[.,]?\\d*) sekúndur" + "eftir (\\d++[.,]?\\d*+) sek", + "eftir (\\d++[.,]?\\d*+) sekúndu", + "eftir (\\d++[.,]?\\d*+) sekúndur" ], "in \\1 week": [ - "eftir (\\d+[.,]?\\d*) viku", - "eftir (\\d+[.,]?\\d*) vikur" + "eftir (\\d++[.,]?\\d*+) viku", + "eftir (\\d++[.,]?\\d*+) vikur" ], "in \\1 year": [ - "eftir (\\d+[.,]?\\d*) ár" + "eftir (\\d++[.,]?\\d*+) ár" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/it.py b/dateparser/data/date_translation_data/it.py index fee99ccc1..9dcdd4f6a 100644 --- a/dateparser/data/date_translation_data/it.py +++ b/dateparser/data/date_translation_data/it.py @@ -170,74 +170,74 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) g fa", - "(\\d+[.,]?\\d*) gg fa", - "(\\d+[.,]?\\d*) giorni fa", - "(\\d+[.,]?\\d*) giorno fa" + "(\\d++[.,]?\\d*+) g fa", + "(\\d++[.,]?\\d*+) gg fa", + "(\\d++[.,]?\\d*+) giorni fa", + "(\\d++[.,]?\\d*+) giorno fa" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) h fa", - "(\\d+[.,]?\\d*) ora fa", - "(\\d+[.,]?\\d*) ore fa" + "(\\d++[.,]?\\d*+) h fa", + "(\\d++[.,]?\\d*+) ora fa", + "(\\d++[.,]?\\d*+) ore fa" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min fa", - "(\\d+[.,]?\\d*) minuti fa", - "(\\d+[.,]?\\d*) minuto fa" + "(\\d++[.,]?\\d*+) min fa", + "(\\d++[.,]?\\d*+) minuti fa", + "(\\d++[.,]?\\d*+) minuto fa" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mese fa", - "(\\d+[.,]?\\d*) mesi fa" + "(\\d++[.,]?\\d*+) mese fa", + "(\\d++[.,]?\\d*+) mesi fa" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) s fa", - "(\\d+[.,]?\\d*) sec fa", - "(\\d+[.,]?\\d*) secondi fa", - "(\\d+[.,]?\\d*) secondo fa" + "(\\d++[.,]?\\d*+) s fa", + "(\\d++[.,]?\\d*+) sec fa", + "(\\d++[.,]?\\d*+) secondi fa", + "(\\d++[.,]?\\d*+) secondo fa" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) sett fa", - "(\\d+[.,]?\\d*) settimana fa", - "(\\d+[.,]?\\d*) settimane fa" + "(\\d++[.,]?\\d*+) sett fa", + "(\\d++[.,]?\\d*+) settimana fa", + "(\\d++[.,]?\\d*+) settimane fa" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) anni fa", - "(\\d+[.,]?\\d*) anno fa" + "(\\d++[.,]?\\d*+) anni fa", + "(\\d++[.,]?\\d*+) anno fa" ], "in \\1 day": [ - "tra (\\d+[.,]?\\d*) g", - "tra (\\d+[.,]?\\d*) gg", - "tra (\\d+[.,]?\\d*) giorni", - "tra (\\d+[.,]?\\d*) giorno" + "tra (\\d++[.,]?\\d*+) g", + "tra (\\d++[.,]?\\d*+) gg", + "tra (\\d++[.,]?\\d*+) giorni", + "tra (\\d++[.,]?\\d*+) giorno" ], "in \\1 hour": [ - "tra (\\d+[.,]?\\d*) h", - "tra (\\d+[.,]?\\d*) ora", - "tra (\\d+[.,]?\\d*) ore" + "tra (\\d++[.,]?\\d*+) h", + "tra (\\d++[.,]?\\d*+) ora", + "tra (\\d++[.,]?\\d*+) ore" ], "in \\1 minute": [ - "tra (\\d+[.,]?\\d*) min", - "tra (\\d+[.,]?\\d*) minuti", - "tra (\\d+[.,]?\\d*) minuto" + "tra (\\d++[.,]?\\d*+) min", + "tra (\\d++[.,]?\\d*+) minuti", + "tra (\\d++[.,]?\\d*+) minuto" ], "in \\1 month": [ - "tra (\\d+[.,]?\\d*) mese", - "tra (\\d+[.,]?\\d*) mesi" + "tra (\\d++[.,]?\\d*+) mese", + "tra (\\d++[.,]?\\d*+) mesi" ], "in \\1 second": [ - "tra (\\d+[.,]?\\d*) s", - "tra (\\d+[.,]?\\d*) sec", - "tra (\\d+[.,]?\\d*) secondi", - "tra (\\d+[.,]?\\d*) secondo" + "tra (\\d++[.,]?\\d*+) s", + "tra (\\d++[.,]?\\d*+) sec", + "tra (\\d++[.,]?\\d*+) secondi", + "tra (\\d++[.,]?\\d*+) secondo" ], "in \\1 week": [ - "tra (\\d+[.,]?\\d*) sett", - "tra (\\d+[.,]?\\d*) settimana", - "tra (\\d+[.,]?\\d*) settimane" + "tra (\\d++[.,]?\\d*+) sett", + "tra (\\d++[.,]?\\d*+) settimana", + "tra (\\d++[.,]?\\d*+) settimane" ], "in \\1 year": [ - "tra (\\d+[.,]?\\d*) anni", - "tra (\\d+[.,]?\\d*) anno" + "tra (\\d++[.,]?\\d*+) anni", + "tra (\\d++[.,]?\\d*+) anno" ] }, "locale_specific": { @@ -276,7 +276,7 @@ ], "simplifications": [ { - "(\\d+[.,]?\\d*)\\s+ora": "\\1 ore" + "(\\d++[.,]?\\d*+)\\s+ora": "\\1 ore" } ] } diff --git a/dateparser/data/date_translation_data/ja.py b/dateparser/data/date_translation_data/ja.py index 730305f6d..38a2d3667 100644 --- a/dateparser/data/date_translation_data/ja.py +++ b/dateparser/data/date_translation_data/ja.py @@ -179,60 +179,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) 日前", - "(\\d+[.,]?\\d*)日前" + "(\\d++[.,]?\\d*+) 日前", + "(\\d++[.,]?\\d*+)日前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) 時間前", - "(\\d+[.,]?\\d*)時間前" + "(\\d++[.,]?\\d*+) 時間前", + "(\\d++[.,]?\\d*+)時間前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) 分前", - "(\\d+[.,]?\\d*)分前" + "(\\d++[.,]?\\d*+) 分前", + "(\\d++[.,]?\\d*+)分前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) か月前", - "(\\d+[.,]?\\d*)か月前" + "(\\d++[.,]?\\d*+) か月前", + "(\\d++[.,]?\\d*+)か月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) 秒前", - "(\\d+[.,]?\\d*)秒前" + "(\\d++[.,]?\\d*+) 秒前", + "(\\d++[.,]?\\d*+)秒前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 週間前", - "(\\d+[.,]?\\d*)週間前" + "(\\d++[.,]?\\d*+) 週間前", + "(\\d++[.,]?\\d*+)週間前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) 年前", - "(\\d+[.,]?\\d*)年前" + "(\\d++[.,]?\\d*+) 年前", + "(\\d++[.,]?\\d*+)年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) 日後", - "(\\d+[.,]?\\d*)日後" + "(\\d++[.,]?\\d*+) 日後", + "(\\d++[.,]?\\d*+)日後" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) 時間後", - "(\\d+[.,]?\\d*)時間後" + "(\\d++[.,]?\\d*+) 時間後", + "(\\d++[.,]?\\d*+)時間後" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) 分後", - "(\\d+[.,]?\\d*)分後" + "(\\d++[.,]?\\d*+) 分後", + "(\\d++[.,]?\\d*+)分後" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) か月後", - "(\\d+[.,]?\\d*)か月後" + "(\\d++[.,]?\\d*+) か月後", + "(\\d++[.,]?\\d*+)か月後" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) 秒後", - "(\\d+[.,]?\\d*)秒後" + "(\\d++[.,]?\\d*+) 秒後", + "(\\d++[.,]?\\d*+)秒後" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 週間後", - "(\\d+[.,]?\\d*)週間後" + "(\\d++[.,]?\\d*+) 週間後", + "(\\d++[.,]?\\d*+)週間後" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) 年後", - "(\\d+[.,]?\\d*)年後" + "(\\d++[.,]?\\d*+) 年後", + "(\\d++[.,]?\\d*+)年後" ] }, "locale_specific": {}, @@ -265,19 +265,19 @@ ], "simplifications": [ { - "(\\d+[.,]?\\d*)年(?:\\s+)?(\\d+[.,]?\\d*)月(?:\\s+)?(\\d+[.,]?\\d*)日": "\\1-\\2-\\3" + "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日": "\\1-\\2-\\3" }, { - "(\\d+[.,]?\\d*)月(?:\\s+)?(\\d+[.,]?\\d*)日": "\\1-\\2" + "(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日": "\\1-\\2" }, { - "(\\d+[.,]?\\d*)時(?:\\s+)?(\\d+[.,]?\\d*)分(?:\\s+)?(\\d+[.,]?\\d*)秒": "\\1:\\2:\\3" + "(\\d++[.,]?\\d*+)時(?:\\s+)?(\\d++[.,]?\\d*+)分(?:\\s+)?(\\d++[.,]?\\d*+)秒": "\\1:\\2:\\3" }, { - "(\\d+[.,]?\\d*)時(?:\\s+)?(\\d+[.,]?\\d*)分": "\\1:\\2" + "(\\d++[.,]?\\d*+)時(?:\\s+)?(\\d++[.,]?\\d*+)分": "\\1:\\2" }, { - "(\\d+[.,]?\\d*)時$": "\\1:00" + "(\\d++[.,]?\\d*+)時$": "\\1:00" }, { "正午": "12:00" diff --git a/dateparser/data/date_translation_data/jgo.py b/dateparser/data/date_translation_data/jgo.py index 9e52f34bc..b19873d96 100644 --- a/dateparser/data/date_translation_data/jgo.py +++ b/dateparser/data/date_translation_data/jgo.py @@ -134,40 +134,40 @@ }, "relative-type-regex": { "\\1 day ago": [ - "ɛ́ gɛ́ mɔ́ lɛ́ꞌ (\\d+[.,]?\\d*)" + "ɛ́ gɛ́ mɔ́ lɛ́ꞌ (\\d++[.,]?\\d*+)" ], "\\1 hour ago": [ - "ɛ́ gɛ mɔ́ (\\d+[.,]?\\d*) háwa" + "ɛ́ gɛ mɔ́ (\\d++[.,]?\\d*+) háwa" ], "\\1 minute ago": [ - "ɛ́ gɛ́ mɔ́ minút (\\d+[.,]?\\d*)" + "ɛ́ gɛ́ mɔ́ minút (\\d++[.,]?\\d*+)" ], "\\1 month ago": [ - "ɛ́ gɛ́ mɔ́ pɛsaŋ (\\d+[.,]?\\d*)" + "ɛ́ gɛ́ mɔ́ pɛsaŋ (\\d++[.,]?\\d*+)" ], "\\1 week ago": [ - "ɛ́ gɛ́ mɔ (\\d+[.,]?\\d*) ŋgap-mbi" + "ɛ́ gɛ́ mɔ (\\d++[.,]?\\d*+) ŋgap-mbi" ], "\\1 year ago": [ - "ɛ́gɛ́ mɔ́ ŋguꞌ (\\d+[.,]?\\d*)" + "ɛ́gɛ́ mɔ́ ŋguꞌ (\\d++[.,]?\\d*+)" ], "in \\1 day": [ - "nǔu lɛ́ꞌ (\\d+[.,]?\\d*)" + "nǔu lɛ́ꞌ (\\d++[.,]?\\d*+)" ], "in \\1 hour": [ - "nǔu háwa (\\d+[.,]?\\d*)" + "nǔu háwa (\\d++[.,]?\\d*+)" ], "in \\1 minute": [ - "nǔu (\\d+[.,]?\\d*) minút" + "nǔu (\\d++[.,]?\\d*+) minút" ], "in \\1 month": [ - "nǔu (\\d+[.,]?\\d*) saŋ" + "nǔu (\\d++[.,]?\\d*+) saŋ" ], "in \\1 week": [ - "nǔu ŋgap-mbi (\\d+[.,]?\\d*)" + "nǔu ŋgap-mbi (\\d++[.,]?\\d*+)" ], "in \\1 year": [ - "nǔu ŋguꞌ (\\d+[.,]?\\d*)" + "nǔu ŋguꞌ (\\d++[.,]?\\d*+)" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ka.py b/dateparser/data/date_translation_data/ka.py index f303291fd..60d94a1d8 100644 --- a/dateparser/data/date_translation_data/ka.py +++ b/dateparser/data/date_translation_data/ka.py @@ -160,51 +160,51 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) დღის წინ" + "(\\d++[.,]?\\d*+) დღის წინ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) საათის წინ", - "(\\d+[.,]?\\d*) სთ წინ" + "(\\d++[.,]?\\d*+) საათის წინ", + "(\\d++[.,]?\\d*+) სთ წინ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) წთ წინ", - "(\\d+[.,]?\\d*) წუთის წინ" + "(\\d++[.,]?\\d*+) წთ წინ", + "(\\d++[.,]?\\d*+) წუთის წინ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) თვის წინ" + "(\\d++[.,]?\\d*+) თვის წინ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) წამის წინ", - "(\\d+[.,]?\\d*) წმ წინ" + "(\\d++[.,]?\\d*+) წამის წინ", + "(\\d++[.,]?\\d*+) წმ წინ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) კვ წინ", - "(\\d+[.,]?\\d*) კვირის წინ" + "(\\d++[.,]?\\d*+) კვ წინ", + "(\\d++[.,]?\\d*+) კვირის წინ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) წლის წინ" + "(\\d++[.,]?\\d*+) წლის წინ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) დღეში" + "(\\d++[.,]?\\d*+) დღეში" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) საათში" + "(\\d++[.,]?\\d*+) საათში" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) წუთში" + "(\\d++[.,]?\\d*+) წუთში" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) თვეში" + "(\\d++[.,]?\\d*+) თვეში" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) წამში" + "(\\d++[.,]?\\d*+) წამში" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) კვირაში" + "(\\d++[.,]?\\d*+) კვირაში" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) წელიწადში", - "(\\d+[.,]?\\d*) წელში" + "(\\d++[.,]?\\d*+) წელიწადში", + "(\\d++[.,]?\\d*+) წელში" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/kea.py b/dateparser/data/date_translation_data/kea.py index b642fa156..2bcb4bee9 100644 --- a/dateparser/data/date_translation_data/kea.py +++ b/dateparser/data/date_translation_data/kea.py @@ -160,56 +160,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "a ten (\\d+[.,]?\\d*) dia" + "a ten (\\d++[.,]?\\d*+) dia" ], "\\1 hour ago": [ - "a ten (\\d+[.,]?\\d*) ora" + "a ten (\\d++[.,]?\\d*+) ora" ], "\\1 minute ago": [ - "a ten (\\d+[.,]?\\d*) m", - "a ten (\\d+[.,]?\\d*) min", - "a ten (\\d+[.,]?\\d*) minutu" + "a ten (\\d++[.,]?\\d*+) m", + "a ten (\\d++[.,]?\\d*+) min", + "a ten (\\d++[.,]?\\d*+) minutu" ], "\\1 month ago": [ - "a ten (\\d+[.,]?\\d*) mes" + "a ten (\\d++[.,]?\\d*+) mes" ], "\\1 second ago": [ - "a ten (\\d+[.,]?\\d*) s", - "a ten (\\d+[.,]?\\d*) sig", - "a ten (\\d+[.,]?\\d*) sigundu" + "a ten (\\d++[.,]?\\d*+) s", + "a ten (\\d++[.,]?\\d*+) sig", + "a ten (\\d++[.,]?\\d*+) sigundu" ], "\\1 week ago": [ - "a ten (\\d+[.,]?\\d*) sim", - "a ten (\\d+[.,]?\\d*) simana" + "a ten (\\d++[.,]?\\d*+) sim", + "a ten (\\d++[.,]?\\d*+) simana" ], "\\1 year ago": [ - "a ten (\\d+[.,]?\\d*) anu" + "a ten (\\d++[.,]?\\d*+) anu" ], "in \\1 day": [ - "di li (\\d+[.,]?\\d*) dia" + "di li (\\d++[.,]?\\d*+) dia" ], "in \\1 hour": [ - "di li (\\d+[.,]?\\d*) ora" + "di li (\\d++[.,]?\\d*+) ora" ], "in \\1 minute": [ - "di li (\\d+[.,]?\\d*) m", - "di li (\\d+[.,]?\\d*) min", - "di li (\\d+[.,]?\\d*) minutu" + "di li (\\d++[.,]?\\d*+) m", + "di li (\\d++[.,]?\\d*+) min", + "di li (\\d++[.,]?\\d*+) minutu" ], "in \\1 month": [ - "di li (\\d+[.,]?\\d*) mes" + "di li (\\d++[.,]?\\d*+) mes" ], "in \\1 second": [ - "di li (\\d+[.,]?\\d*) s", - "di li (\\d+[.,]?\\d*) sig", - "di li (\\d+[.,]?\\d*) sigundu" + "di li (\\d++[.,]?\\d*+) s", + "di li (\\d++[.,]?\\d*+) sig", + "di li (\\d++[.,]?\\d*+) sigundu" ], "in \\1 week": [ - "di li (\\d+[.,]?\\d*) sim", - "di li (\\d+[.,]?\\d*) simana" + "di li (\\d++[.,]?\\d*+) sim", + "di li (\\d++[.,]?\\d*+) simana" ], "in \\1 year": [ - "di li (\\d+[.,]?\\d*) anu" + "di li (\\d++[.,]?\\d*+) anu" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/kk.py b/dateparser/data/date_translation_data/kk.py index 733522348..5cd1835a6 100644 --- a/dateparser/data/date_translation_data/kk.py +++ b/dateparser/data/date_translation_data/kk.py @@ -158,56 +158,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) күн бұрын" + "(\\d++[.,]?\\d*+) күн бұрын" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) сағ бұрын", - "(\\d+[.,]?\\d*) сағат бұрын" + "(\\d++[.,]?\\d*+) сағ бұрын", + "(\\d++[.,]?\\d*+) сағат бұрын" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мин бұрын", - "(\\d+[.,]?\\d*) минут бұрын" + "(\\d++[.,]?\\d*+) мин бұрын", + "(\\d++[.,]?\\d*+) минут бұрын" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ай бұрын" + "(\\d++[.,]?\\d*+) ай бұрын" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сек бұрын", - "(\\d+[.,]?\\d*) секунд бұрын" + "(\\d++[.,]?\\d*+) сек бұрын", + "(\\d++[.,]?\\d*+) секунд бұрын" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ап бұрын", - "(\\d+[.,]?\\d*) апта бұрын" + "(\\d++[.,]?\\d*+) ап бұрын", + "(\\d++[.,]?\\d*+) апта бұрын" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ж бұрын", - "(\\d+[.,]?\\d*) жыл бұрын" + "(\\d++[.,]?\\d*+) ж бұрын", + "(\\d++[.,]?\\d*+) жыл бұрын" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) күннен кейін" + "(\\d++[.,]?\\d*+) күннен кейін" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) сағ кейін", - "(\\d+[.,]?\\d*) сағаттан кейін" + "(\\d++[.,]?\\d*+) сағ кейін", + "(\\d++[.,]?\\d*+) сағаттан кейін" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) мин кейін", - "(\\d+[.,]?\\d*) минуттан кейін" + "(\\d++[.,]?\\d*+) мин кейін", + "(\\d++[.,]?\\d*+) минуттан кейін" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) айдан кейін" + "(\\d++[.,]?\\d*+) айдан кейін" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сек кейін", - "(\\d+[.,]?\\d*) секундтан кейін" + "(\\d++[.,]?\\d*+) сек кейін", + "(\\d++[.,]?\\d*+) секундтан кейін" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ап кейін", - "(\\d+[.,]?\\d*) аптадан кейін" + "(\\d++[.,]?\\d*+) ап кейін", + "(\\d++[.,]?\\d*+) аптадан кейін" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ж кейін", - "(\\d+[.,]?\\d*) жылдан кейін" + "(\\d++[.,]?\\d*+) ж кейін", + "(\\d++[.,]?\\d*+) жылдан кейін" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/kl.py b/dateparser/data/date_translation_data/kl.py index eddcea08e..8dab1db59 100644 --- a/dateparser/data/date_translation_data/kl.py +++ b/dateparser/data/date_translation_data/kl.py @@ -153,46 +153,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "for (\\d+[.,]?\\d*) ulloq unnuarlu siden" + "for (\\d++[.,]?\\d*+) ulloq unnuarlu siden" ], "\\1 hour ago": [ - "for (\\d+[.,]?\\d*) nalunaaquttap-akunnera siden" + "for (\\d++[.,]?\\d*+) nalunaaquttap-akunnera siden" ], "\\1 minute ago": [ - "for (\\d+[.,]?\\d*) minutsi siden" + "for (\\d++[.,]?\\d*+) minutsi siden" ], "\\1 month ago": [ - "for (\\d+[.,]?\\d*) qaammat siden" + "for (\\d++[.,]?\\d*+) qaammat siden" ], "\\1 second ago": [ - "for (\\d+[.,]?\\d*) sekundi siden" + "for (\\d++[.,]?\\d*+) sekundi siden" ], "\\1 week ago": [ - "for (\\d+[.,]?\\d*) sapaatip-akunnera siden" + "for (\\d++[.,]?\\d*+) sapaatip-akunnera siden" ], "\\1 year ago": [ - "for (\\d+[.,]?\\d*) ukioq siden" + "for (\\d++[.,]?\\d*+) ukioq siden" ], "in \\1 day": [ - "om (\\d+[.,]?\\d*) ulloq unnuarlu" + "om (\\d++[.,]?\\d*+) ulloq unnuarlu" ], "in \\1 hour": [ - "om (\\d+[.,]?\\d*) nalunaaquttap-akunnera" + "om (\\d++[.,]?\\d*+) nalunaaquttap-akunnera" ], "in \\1 minute": [ - "om (\\d+[.,]?\\d*) minutsi" + "om (\\d++[.,]?\\d*+) minutsi" ], "in \\1 month": [ - "om (\\d+[.,]?\\d*) qaammat" + "om (\\d++[.,]?\\d*+) qaammat" ], "in \\1 second": [ - "om (\\d+[.,]?\\d*) sekundi" + "om (\\d++[.,]?\\d*+) sekundi" ], "in \\1 week": [ - "om (\\d+[.,]?\\d*) sapaatip-akunnera" + "om (\\d++[.,]?\\d*+) sapaatip-akunnera" ], "in \\1 year": [ - "om (\\d+[.,]?\\d*) ukioq" + "om (\\d++[.,]?\\d*+) ukioq" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/km.py b/dateparser/data/date_translation_data/km.py index cda9dad61..ec4b526b3 100644 --- a/dateparser/data/date_translation_data/km.py +++ b/dateparser/data/date_translation_data/km.py @@ -135,49 +135,49 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ថ្ងៃ​មុន", - "(\\d+[.,]?\\d*) ថ្ងៃ​​មុន" + "(\\d++[.,]?\\d*+) ថ្ងៃ​មុន", + "(\\d++[.,]?\\d*+) ថ្ងៃ​​មុន" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ម៉ោង​មុន" + "(\\d++[.,]?\\d*+) ម៉ោង​មុន" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) នាទី​មុន", - "(\\d+[.,]?\\d*) នាទី​​មុន" + "(\\d++[.,]?\\d*+) នាទី​មុន", + "(\\d++[.,]?\\d*+) នាទី​​មុន" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ខែមុន" + "(\\d++[.,]?\\d*+) ខែមុន" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) វិនាទី​មុន" + "(\\d++[.,]?\\d*+) វិនាទី​មុន" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) សប្ដាហ៍​មុន" + "(\\d++[.,]?\\d*+) សប្ដាហ៍​មុន" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ឆ្នាំ​មុន" + "(\\d++[.,]?\\d*+) ឆ្នាំ​មុន" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ថ្ងៃទៀត" + "(\\d++[.,]?\\d*+) ថ្ងៃទៀត" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ម៉ោងទៀត", - "ក្នុង​រយៈ​ពេល (\\d+[.,]?\\d*) ម៉ោង" + "(\\d++[.,]?\\d*+) ម៉ោងទៀត", + "ក្នុង​រយៈ​ពេល (\\d++[.,]?\\d*+) ម៉ោង" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) នាទីទៀត" + "(\\d++[.,]?\\d*+) នាទីទៀត" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ខែទៀត" + "(\\d++[.,]?\\d*+) ខែទៀត" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) វិនាទីទៀត" + "(\\d++[.,]?\\d*+) វិនាទីទៀត" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) សប្ដាហ៍ទៀត" + "(\\d++[.,]?\\d*+) សប្ដាហ៍ទៀត" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ឆ្នាំទៀត" + "(\\d++[.,]?\\d*+) ឆ្នាំទៀត" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/kn.py b/dateparser/data/date_translation_data/kn.py index d575334e8..83a4c0b6a 100644 --- a/dateparser/data/date_translation_data/kn.py +++ b/dateparser/data/date_translation_data/kn.py @@ -150,61 +150,61 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ದಿನಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ದಿನದ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ದಿನಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ದಿನದ ಹಿಂದೆ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ಗಂಟೆ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ಗಂಟೆಗಳ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ಗಂಟೆ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ಗಂಟೆಗಳ ಹಿಂದೆ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) ನಿಮಿಷಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ನಿಮಿಷದ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ನಿಮಿಷಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ನಿಮಿಷದ ಹಿಂದೆ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ತಿಂಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ತಿಂಗಳು ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ತಿಂಗಳುಗಳ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ತಿಂಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ತಿಂಗಳು ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ತಿಂಗಳುಗಳ ಹಿಂದೆ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ಸೆಕೆಂಡುಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ಸೆಕೆಂಡ್ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ಸೆಕೆಂಡುಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ಸೆಕೆಂಡ್ ಹಿಂದೆ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ವಾರಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ವಾರದ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ವಾರಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ವಾರದ ಹಿಂದೆ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ವರ್ಷಗಳ ಹಿಂದೆ", - "(\\d+[.,]?\\d*) ವರ್ಷದ ಹಿಂದೆ" + "(\\d++[.,]?\\d*+) ವರ್ಷಗಳ ಹಿಂದೆ", + "(\\d++[.,]?\\d*+) ವರ್ಷದ ಹಿಂದೆ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ದಿನಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ದಿನದಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ದಿನಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ದಿನದಲ್ಲಿ" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ಗಂಟೆಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ಗಂಟೆಯಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ಗಂಟೆಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ಗಂಟೆಯಲ್ಲಿ" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) ನಿಮಿಷಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ನಿಮಿಷದಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ನಿಮಿಷಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ನಿಮಿಷದಲ್ಲಿ" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ತಿಂಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ತಿಂಗಳುಗಳಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ತಿಂಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ತಿಂಗಳುಗಳಲ್ಲಿ" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) ಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ಸೆಕೆಂಡ್‌ನಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ಸೆಕೆಂಡ್‌ನಲ್ಲಿ" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ವಾರಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ವಾರದಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ವಾರಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ವಾರದಲ್ಲಿ" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ವರ್ಷಗಳಲ್ಲಿ", - "(\\d+[.,]?\\d*) ವರ್ಷದಲ್ಲಿ" + "(\\d++[.,]?\\d*+) ವರ್ಷಗಳಲ್ಲಿ", + "(\\d++[.,]?\\d*+) ವರ್ಷದಲ್ಲಿ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ko.py b/dateparser/data/date_translation_data/ko.py index 6b361e07a..841257fb7 100644 --- a/dateparser/data/date_translation_data/ko.py +++ b/dateparser/data/date_translation_data/ko.py @@ -143,46 +143,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*)일 전" + "(\\d++[.,]?\\d*+)일 전" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*)시간 전" + "(\\d++[.,]?\\d*+)시간 전" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*)분 전" + "(\\d++[.,]?\\d*+)분 전" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*)개월 전" + "(\\d++[.,]?\\d*+)개월 전" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*)초 전" + "(\\d++[.,]?\\d*+)초 전" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*)주 전" + "(\\d++[.,]?\\d*+)주 전" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*)년 전" + "(\\d++[.,]?\\d*+)년 전" ], "in \\1 day": [ - "(\\d+[.,]?\\d*)일 후" + "(\\d++[.,]?\\d*+)일 후" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*)시간 후" + "(\\d++[.,]?\\d*+)시간 후" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*)분 후" + "(\\d++[.,]?\\d*+)분 후" ], "in \\1 month": [ - "(\\d+[.,]?\\d*)개월 후" + "(\\d++[.,]?\\d*+)개월 후" ], "in \\1 second": [ - "(\\d+[.,]?\\d*)초 후" + "(\\d++[.,]?\\d*+)초 후" ], "in \\1 week": [ - "(\\d+[.,]?\\d*)주 후" + "(\\d++[.,]?\\d*+)주 후" ], "in \\1 year": [ - "(\\d+[.,]?\\d*)년 후" + "(\\d++[.,]?\\d*+)년 후" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ksh.py b/dateparser/data/date_translation_data/ksh.py index 123828698..d915b2723 100644 --- a/dateparser/data/date_translation_data/ksh.py +++ b/dateparser/data/date_translation_data/ksh.py @@ -166,12 +166,12 @@ }, "relative-type-regex": { "\\1 year ago": [ - "vör (\\d+[.,]?\\d*) johr", - "vör (\\d+[.,]?\\d*) johre" + "vör (\\d++[.,]?\\d*+) johr", + "vör (\\d++[.,]?\\d*+) johre" ], "in \\1 year": [ - "en (\\d+[.,]?\\d*) johr", - "en (\\d+[.,]?\\d*) johre" + "en (\\d++[.,]?\\d*+) johr", + "en (\\d++[.,]?\\d*+) johre" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ky.py b/dateparser/data/date_translation_data/ky.py index 847110dab..42d6c3efb 100644 --- a/dateparser/data/date_translation_data/ky.py +++ b/dateparser/data/date_translation_data/ky.py @@ -162,64 +162,64 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) күн мурун" + "(\\d++[.,]?\\d*+) күн мурун" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) с мурн", - "(\\d+[.,]?\\d*) саат мурун" + "(\\d++[.,]?\\d*+) с мурн", + "(\\d++[.,]?\\d*+) саат мурун" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мүн мурн", - "(\\d+[.,]?\\d*) мүн мурун", - "(\\d+[.,]?\\d*) мүнөт мурун" + "(\\d++[.,]?\\d*+) мүн мурн", + "(\\d++[.,]?\\d*+) мүн мурун", + "(\\d++[.,]?\\d*+) мүнөт мурун" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ай мурн", - "(\\d+[.,]?\\d*) ай мурун" + "(\\d++[.,]?\\d*+) ай мурн", + "(\\d++[.,]?\\d*+) ай мурун" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сек мурн", - "(\\d+[.,]?\\d*) сек мурун", - "(\\d+[.,]?\\d*) секунд мурун" + "(\\d++[.,]?\\d*+) сек мурн", + "(\\d++[.,]?\\d*+) сек мурун", + "(\\d++[.,]?\\d*+) секунд мурун" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) апт мурун", - "(\\d+[.,]?\\d*) апта мурун" + "(\\d++[.,]?\\d*+) апт мурун", + "(\\d++[.,]?\\d*+) апта мурун" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) жыл мурун" + "(\\d++[.,]?\\d*+) жыл мурун" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) күн кийин", - "(\\d+[.,]?\\d*) күндөн кийин" + "(\\d++[.,]?\\d*+) күн кийин", + "(\\d++[.,]?\\d*+) күндөн кийин" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) с кийн", - "(\\d+[.,]?\\d*) саат кийин", - "(\\d+[.,]?\\d*) сааттан кийин" + "(\\d++[.,]?\\d*+) с кийн", + "(\\d++[.,]?\\d*+) саат кийин", + "(\\d++[.,]?\\d*+) сааттан кийин" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) мүн кийин", - "(\\d+[.,]?\\d*) мүн кийн", - "(\\d+[.,]?\\d*) мүнөттөн кийин" + "(\\d++[.,]?\\d*+) мүн кийин", + "(\\d++[.,]?\\d*+) мүн кийн", + "(\\d++[.,]?\\d*+) мүнөттөн кийин" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) айд кийин", - "(\\d+[.,]?\\d*) айд кийн", - "(\\d+[.,]?\\d*) айдан кийин" + "(\\d++[.,]?\\d*+) айд кийин", + "(\\d++[.,]?\\d*+) айд кийн", + "(\\d++[.,]?\\d*+) айдан кийин" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сек кийин", - "(\\d+[.,]?\\d*) сек кийн", - "(\\d+[.,]?\\d*) секунддан кийин" + "(\\d++[.,]?\\d*+) сек кийин", + "(\\d++[.,]?\\d*+) сек кийн", + "(\\d++[.,]?\\d*+) секунддан кийин" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) апт кийин", - "(\\d+[.,]?\\d*) аптадан кийин" + "(\\d++[.,]?\\d*+) апт кийин", + "(\\d++[.,]?\\d*+) аптадан кийин" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) жыл кийин", - "(\\d+[.,]?\\d*) жылдан кийин" + "(\\d++[.,]?\\d*+) жыл кийин", + "(\\d++[.,]?\\d*+) жылдан кийин" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/lb.py b/dateparser/data/date_translation_data/lb.py index 18afe1be4..b5ac7a61a 100644 --- a/dateparser/data/date_translation_data/lb.py +++ b/dateparser/data/date_translation_data/lb.py @@ -159,60 +159,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "virun (\\d+[.,]?\\d*) d", - "virun (\\d+[.,]?\\d*) dag" + "virun (\\d++[.,]?\\d*+) d", + "virun (\\d++[.,]?\\d*+) dag" ], "\\1 hour ago": [ - "virun (\\d+[.,]?\\d*) st", - "virun (\\d+[.,]?\\d*) stonn" + "virun (\\d++[.,]?\\d*+) st", + "virun (\\d++[.,]?\\d*+) stonn" ], "\\1 minute ago": [ - "virun (\\d+[.,]?\\d*) min", - "virun (\\d+[.,]?\\d*) minutt" + "virun (\\d++[.,]?\\d*+) min", + "virun (\\d++[.,]?\\d*+) minutt" ], "\\1 month ago": [ - "virun (\\d+[.,]?\\d*) m", - "virun (\\d+[.,]?\\d*) mount" + "virun (\\d++[.,]?\\d*+) m", + "virun (\\d++[.,]?\\d*+) mount" ], "\\1 second ago": [ - "virun (\\d+[.,]?\\d*) sek", - "virun (\\d+[.,]?\\d*) sekonn" + "virun (\\d++[.,]?\\d*+) sek", + "virun (\\d++[.,]?\\d*+) sekonn" ], "\\1 week ago": [ - "virun (\\d+[.,]?\\d*) w", - "virun (\\d+[.,]?\\d*) woch" + "virun (\\d++[.,]?\\d*+) w", + "virun (\\d++[.,]?\\d*+) woch" ], "\\1 year ago": [ - "virun (\\d+[.,]?\\d*) j", - "virun (\\d+[.,]?\\d*) joer" + "virun (\\d++[.,]?\\d*+) j", + "virun (\\d++[.,]?\\d*+) joer" ], "in \\1 day": [ - "an (\\d+[.,]?\\d*) d", - "an (\\d+[.,]?\\d*) dag" + "an (\\d++[.,]?\\d*+) d", + "an (\\d++[.,]?\\d*+) dag" ], "in \\1 hour": [ - "an (\\d+[.,]?\\d*) st", - "an (\\d+[.,]?\\d*) stonn" + "an (\\d++[.,]?\\d*+) st", + "an (\\d++[.,]?\\d*+) stonn" ], "in \\1 minute": [ - "an (\\d+[.,]?\\d*) min", - "an (\\d+[.,]?\\d*) minutt" + "an (\\d++[.,]?\\d*+) min", + "an (\\d++[.,]?\\d*+) minutt" ], "in \\1 month": [ - "an (\\d+[.,]?\\d*) m", - "an (\\d+[.,]?\\d*) mount" + "an (\\d++[.,]?\\d*+) m", + "an (\\d++[.,]?\\d*+) mount" ], "in \\1 second": [ - "an (\\d+[.,]?\\d*) sek", - "an (\\d+[.,]?\\d*) sekonn" + "an (\\d++[.,]?\\d*+) sek", + "an (\\d++[.,]?\\d*+) sekonn" ], "in \\1 week": [ - "an (\\d+[.,]?\\d*) w", - "an (\\d+[.,]?\\d*) woch" + "an (\\d++[.,]?\\d*+) w", + "an (\\d++[.,]?\\d*+) woch" ], "in \\1 year": [ - "an (\\d+[.,]?\\d*) j", - "an (\\d+[.,]?\\d*) joer" + "an (\\d++[.,]?\\d*+) j", + "an (\\d++[.,]?\\d*+) joer" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/lkt.py b/dateparser/data/date_translation_data/lkt.py index 71e9586b6..dbedd2715 100644 --- a/dateparser/data/date_translation_data/lkt.py +++ b/dateparser/data/date_translation_data/lkt.py @@ -134,46 +134,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "hékta (\\d+[.,]?\\d*)-čháŋ k'uŋ héhaŋ" + "hékta (\\d++[.,]?\\d*+)-čháŋ k'uŋ héhaŋ" ], "\\1 hour ago": [ - "hékta owápȟe (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta owápȟe (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "\\1 minute ago": [ - "hékta oȟ'áŋkȟo (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta oȟ'áŋkȟo (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "\\1 month ago": [ - "hékta wíyawapi (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta wíyawapi (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "\\1 second ago": [ - "hékta okpí (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta okpí (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "\\1 week ago": [ - "hékta okó (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta okó (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "\\1 year ago": [ - "hékta ómakȟa (\\d+[.,]?\\d*) k'uŋ héhaŋ" + "hékta ómakȟa (\\d++[.,]?\\d*+) k'uŋ héhaŋ" ], "in \\1 day": [ - "letáŋhaŋ (\\d+[.,]?\\d*)-čháŋ kiŋháŋ" + "letáŋhaŋ (\\d++[.,]?\\d*+)-čháŋ kiŋháŋ" ], "in \\1 hour": [ - "letáŋhaŋ owápȟe (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ owápȟe (\\d++[.,]?\\d*+) kiŋháŋ" ], "in \\1 minute": [ - "letáŋhaŋ oȟ'áŋkȟo (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ oȟ'áŋkȟo (\\d++[.,]?\\d*+) kiŋháŋ" ], "in \\1 month": [ - "letáŋhaŋ wíyawapi (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ wíyawapi (\\d++[.,]?\\d*+) kiŋháŋ" ], "in \\1 second": [ - "letáŋhaŋ okpí (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ okpí (\\d++[.,]?\\d*+) kiŋháŋ" ], "in \\1 week": [ - "letáŋhaŋ okó (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ okó (\\d++[.,]?\\d*+) kiŋháŋ" ], "in \\1 year": [ - "letáŋhaŋ ómakȟa (\\d+[.,]?\\d*) kiŋháŋ" + "letáŋhaŋ ómakȟa (\\d++[.,]?\\d*+) kiŋháŋ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/lo.py b/dateparser/data/date_translation_data/lo.py index ba6cfc897..83160ff74 100644 --- a/dateparser/data/date_translation_data/lo.py +++ b/dateparser/data/date_translation_data/lo.py @@ -158,56 +158,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ມື້ກ່ອນ" + "(\\d++[.,]?\\d*+) ມື້ກ່ອນ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ຊມ ກ່ອນ", - "(\\d+[.,]?\\d*) ຊົ່ວໂມງກ່ອນ" + "(\\d++[.,]?\\d*+) ຊມ ກ່ອນ", + "(\\d++[.,]?\\d*+) ຊົ່ວໂມງກ່ອນ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) ນທ ກ່ອນ", - "(\\d+[.,]?\\d*) ນາທີກ່ອນ" + "(\\d++[.,]?\\d*+) ນທ ກ່ອນ", + "(\\d++[.,]?\\d*+) ນາທີກ່ອນ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ດ ກ່ອນ", - "(\\d+[.,]?\\d*) ເດືອນກ່ອນ" + "(\\d++[.,]?\\d*+) ດ ກ່ອນ", + "(\\d++[.,]?\\d*+) ເດືອນກ່ອນ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ວິ ກ່ອນ", - "(\\d+[.,]?\\d*) ວິນາທີກ່ອນ" + "(\\d++[.,]?\\d*+) ວິ ກ່ອນ", + "(\\d++[.,]?\\d*+) ວິນາທີກ່ອນ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ອທ ກ່ອນ", - "(\\d+[.,]?\\d*) ອາທິດກ່ອນ" + "(\\d++[.,]?\\d*+) ອທ ກ່ອນ", + "(\\d++[.,]?\\d*+) ອາທິດກ່ອນ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ປີກ່ອນ" + "(\\d++[.,]?\\d*+) ປີກ່ອນ" ], "in \\1 day": [ - "ໃນອີກ (\\d+[.,]?\\d*) ມື້" + "ໃນອີກ (\\d++[.,]?\\d*+) ມື້" ], "in \\1 hour": [ - "ໃນອີກ (\\d+[.,]?\\d*) ຊມ", - "ໃນອີກ (\\d+[.,]?\\d*) ຊົ່ວໂມງ" + "ໃນອີກ (\\d++[.,]?\\d*+) ຊມ", + "ໃນອີກ (\\d++[.,]?\\d*+) ຊົ່ວໂມງ" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) ໃນອີກ 0 ນາທີ", - "ໃນ (\\d+[.,]?\\d*) ນທ" + "(\\d++[.,]?\\d*+) ໃນອີກ 0 ນາທີ", + "ໃນ (\\d++[.,]?\\d*+) ນທ" ], "in \\1 month": [ - "ໃນອີກ (\\d+[.,]?\\d*) ດ", - "ໃນອີກ (\\d+[.,]?\\d*) ເດືອນ" + "ໃນອີກ (\\d++[.,]?\\d*+) ດ", + "ໃນອີກ (\\d++[.,]?\\d*+) ເດືອນ" ], "in \\1 second": [ - "ໃນ (\\d+[.,]?\\d*) ວິ", - "ໃນອີກ (\\d+[.,]?\\d*) ວິນາທີ" + "ໃນ (\\d++[.,]?\\d*+) ວິ", + "ໃນອີກ (\\d++[.,]?\\d*+) ວິນາທີ" ], "in \\1 week": [ - "ໃນອີກ (\\d+[.,]?\\d*) ອທ", - "ໃນອີກ (\\d+[.,]?\\d*) ອາທິດ" + "ໃນອີກ (\\d++[.,]?\\d*+) ອທ", + "ໃນອີກ (\\d++[.,]?\\d*+) ອາທິດ" ], "in \\1 year": [ - "ໃນອີກ (\\d+[.,]?\\d*) ປີ" + "ໃນອີກ (\\d++[.,]?\\d*+) ປີ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/lt.py b/dateparser/data/date_translation_data/lt.py index 529a2dca3..464cf6cea 100644 --- a/dateparser/data/date_translation_data/lt.py +++ b/dateparser/data/date_translation_data/lt.py @@ -174,75 +174,75 @@ }, "relative-type-regex": { "\\1 day ago": [ - "prieš (\\d+[.,]?\\d*) d", - "prieš (\\d+[.,]?\\d*) dieną", - "prieš (\\d+[.,]?\\d*) dienų" + "prieš (\\d++[.,]?\\d*+) d", + "prieš (\\d++[.,]?\\d*+) dieną", + "prieš (\\d++[.,]?\\d*+) dienų" ], "\\1 hour ago": [ - "prieš (\\d+[.,]?\\d*) val", - "prieš (\\d+[.,]?\\d*) valandą", - "prieš (\\d+[.,]?\\d*) valandų" + "prieš (\\d++[.,]?\\d*+) val", + "prieš (\\d++[.,]?\\d*+) valandą", + "prieš (\\d++[.,]?\\d*+) valandų" ], "\\1 minute ago": [ - "prieš (\\d+[.,]?\\d*) min", - "prieš (\\d+[.,]?\\d*) minutę", - "prieš (\\d+[.,]?\\d*) minučių" + "prieš (\\d++[.,]?\\d*+) min", + "prieš (\\d++[.,]?\\d*+) minutę", + "prieš (\\d++[.,]?\\d*+) minučių" ], "\\1 month ago": [ - "prieš (\\d+[.,]?\\d*) mėn", - "prieš (\\d+[.,]?\\d*) mėnesių", - "prieš (\\d+[.,]?\\d*) mėnesį" + "prieš (\\d++[.,]?\\d*+) mėn", + "prieš (\\d++[.,]?\\d*+) mėnesių", + "prieš (\\d++[.,]?\\d*+) mėnesį" ], "\\1 second ago": [ - "prieš (\\d+[.,]?\\d*) s", - "prieš (\\d+[.,]?\\d*) sek", - "prieš (\\d+[.,]?\\d*) sekundę", - "prieš (\\d+[.,]?\\d*) sekundžių" + "prieš (\\d++[.,]?\\d*+) s", + "prieš (\\d++[.,]?\\d*+) sek", + "prieš (\\d++[.,]?\\d*+) sekundę", + "prieš (\\d++[.,]?\\d*+) sekundžių" ], "\\1 week ago": [ - "prieš (\\d+[.,]?\\d*) sav", - "prieš (\\d+[.,]?\\d*) savaitę", - "prieš (\\d+[.,]?\\d*) savaičių" + "prieš (\\d++[.,]?\\d*+) sav", + "prieš (\\d++[.,]?\\d*+) savaitę", + "prieš (\\d++[.,]?\\d*+) savaičių" ], "\\1 year ago": [ - "prieš (\\d+[.,]?\\d*) m", - "prieš (\\d+[.,]?\\d*) metus", - "prieš (\\d+[.,]?\\d*) metų" + "prieš (\\d++[.,]?\\d*+) m", + "prieš (\\d++[.,]?\\d*+) metus", + "prieš (\\d++[.,]?\\d*+) metų" ], "in \\1 day": [ - "po (\\d+[.,]?\\d*) d", - "po (\\d+[.,]?\\d*) dienos", - "po (\\d+[.,]?\\d*) dienų" + "po (\\d++[.,]?\\d*+) d", + "po (\\d++[.,]?\\d*+) dienos", + "po (\\d++[.,]?\\d*+) dienų" ], "in \\1 hour": [ - "po (\\d+[.,]?\\d*) val", - "po (\\d+[.,]?\\d*) valandos", - "po (\\d+[.,]?\\d*) valandų" + "po (\\d++[.,]?\\d*+) val", + "po (\\d++[.,]?\\d*+) valandos", + "po (\\d++[.,]?\\d*+) valandų" ], "in \\1 minute": [ - "po (\\d+[.,]?\\d*) min", - "po (\\d+[.,]?\\d*) minutės", - "po (\\d+[.,]?\\d*) minučių" + "po (\\d++[.,]?\\d*+) min", + "po (\\d++[.,]?\\d*+) minutės", + "po (\\d++[.,]?\\d*+) minučių" ], "in \\1 month": [ - "po (\\d+[.,]?\\d*) mėn", - "po (\\d+[.,]?\\d*) mėnesio", - "po (\\d+[.,]?\\d*) mėnesių" + "po (\\d++[.,]?\\d*+) mėn", + "po (\\d++[.,]?\\d*+) mėnesio", + "po (\\d++[.,]?\\d*+) mėnesių" ], "in \\1 second": [ - "po (\\d+[.,]?\\d*) s", - "po (\\d+[.,]?\\d*) sek", - "po (\\d+[.,]?\\d*) sekundės", - "po (\\d+[.,]?\\d*) sekundžių" + "po (\\d++[.,]?\\d*+) s", + "po (\\d++[.,]?\\d*+) sek", + "po (\\d++[.,]?\\d*+) sekundės", + "po (\\d++[.,]?\\d*+) sekundžių" ], "in \\1 week": [ - "po (\\d+[.,]?\\d*) sav", - "po (\\d+[.,]?\\d*) savaitės", - "po (\\d+[.,]?\\d*) savaičių" + "po (\\d++[.,]?\\d*+) sav", + "po (\\d++[.,]?\\d*+) savaitės", + "po (\\d++[.,]?\\d*+) savaičių" ], "in \\1 year": [ - "po (\\d+[.,]?\\d*) m", - "po (\\d+[.,]?\\d*) metų" + "po (\\d++[.,]?\\d*+) m", + "po (\\d++[.,]?\\d*+) metų" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/lv.py b/dateparser/data/date_translation_data/lv.py index 20a6fbe5e..8ed540f2a 100644 --- a/dateparser/data/date_translation_data/lv.py +++ b/dateparser/data/date_translation_data/lv.py @@ -165,78 +165,78 @@ }, "relative-type-regex": { "\\1 day ago": [ - "pirms (\\d+[.,]?\\d*) d", - "pirms (\\d+[.,]?\\d*) dienas", - "pirms (\\d+[.,]?\\d*) dienām" + "pirms (\\d++[.,]?\\d*+) d", + "pirms (\\d++[.,]?\\d*+) dienas", + "pirms (\\d++[.,]?\\d*+) dienām" ], "\\1 hour ago": [ - "pirms (\\d+[.,]?\\d*) h", - "pirms (\\d+[.,]?\\d*) st", - "pirms (\\d+[.,]?\\d*) stundas", - "pirms (\\d+[.,]?\\d*) stundām" + "pirms (\\d++[.,]?\\d*+) h", + "pirms (\\d++[.,]?\\d*+) st", + "pirms (\\d++[.,]?\\d*+) stundas", + "pirms (\\d++[.,]?\\d*+) stundām" ], "\\1 minute ago": [ - "pirms (\\d+[.,]?\\d*) min", - "pirms (\\d+[.,]?\\d*) minūtes", - "pirms (\\d+[.,]?\\d*) minūtēm" + "pirms (\\d++[.,]?\\d*+) min", + "pirms (\\d++[.,]?\\d*+) minūtes", + "pirms (\\d++[.,]?\\d*+) minūtēm" ], "\\1 month ago": [ - "pirms (\\d+[.,]?\\d*) mēn", - "pirms (\\d+[.,]?\\d*) mēneša", - "pirms (\\d+[.,]?\\d*) mēnešiem" + "pirms (\\d++[.,]?\\d*+) mēn", + "pirms (\\d++[.,]?\\d*+) mēneša", + "pirms (\\d++[.,]?\\d*+) mēnešiem" ], "\\1 second ago": [ - "pirms (\\d+[.,]?\\d*) s", - "pirms (\\d+[.,]?\\d*) sek", - "pirms (\\d+[.,]?\\d*) sekundes", - "pirms (\\d+[.,]?\\d*) sekundēm" + "pirms (\\d++[.,]?\\d*+) s", + "pirms (\\d++[.,]?\\d*+) sek", + "pirms (\\d++[.,]?\\d*+) sekundes", + "pirms (\\d++[.,]?\\d*+) sekundēm" ], "\\1 week ago": [ - "pirms (\\d+[.,]?\\d*) ned", - "pirms (\\d+[.,]?\\d*) nedēļas", - "pirms (\\d+[.,]?\\d*) nedēļām" + "pirms (\\d++[.,]?\\d*+) ned", + "pirms (\\d++[.,]?\\d*+) nedēļas", + "pirms (\\d++[.,]?\\d*+) nedēļām" ], "\\1 year ago": [ - "pirms (\\d+[.,]?\\d*) g", - "pirms (\\d+[.,]?\\d*) gada", - "pirms (\\d+[.,]?\\d*) gadiem" + "pirms (\\d++[.,]?\\d*+) g", + "pirms (\\d++[.,]?\\d*+) gada", + "pirms (\\d++[.,]?\\d*+) gadiem" ], "in \\1 day": [ - "pēc (\\d+[.,]?\\d*) d", - "pēc (\\d+[.,]?\\d*) dienas", - "pēc (\\d+[.,]?\\d*) dienām" + "pēc (\\d++[.,]?\\d*+) d", + "pēc (\\d++[.,]?\\d*+) dienas", + "pēc (\\d++[.,]?\\d*+) dienām" ], "in \\1 hour": [ - "pēc (\\d+[.,]?\\d*) h", - "pēc (\\d+[.,]?\\d*) st", - "pēc (\\d+[.,]?\\d*) stundas", - "pēc (\\d+[.,]?\\d*) stundām" + "pēc (\\d++[.,]?\\d*+) h", + "pēc (\\d++[.,]?\\d*+) st", + "pēc (\\d++[.,]?\\d*+) stundas", + "pēc (\\d++[.,]?\\d*+) stundām" ], "in \\1 minute": [ - "pēc (\\d+[.,]?\\d*) min", - "pēc (\\d+[.,]?\\d*) minūtes", - "pēc (\\d+[.,]?\\d*) minūtēm" + "pēc (\\d++[.,]?\\d*+) min", + "pēc (\\d++[.,]?\\d*+) minūtes", + "pēc (\\d++[.,]?\\d*+) minūtēm" ], "in \\1 month": [ - "pēc (\\d+[.,]?\\d*) mēn", - "pēc (\\d+[.,]?\\d*) mēneša", - "pēc (\\d+[.,]?\\d*) mēnešiem" + "pēc (\\d++[.,]?\\d*+) mēn", + "pēc (\\d++[.,]?\\d*+) mēneša", + "pēc (\\d++[.,]?\\d*+) mēnešiem" ], "in \\1 second": [ - "pēc (\\d+[.,]?\\d*) s", - "pēc (\\d+[.,]?\\d*) sek", - "pēc (\\d+[.,]?\\d*) sekundes", - "pēc (\\d+[.,]?\\d*) sekundēm" + "pēc (\\d++[.,]?\\d*+) s", + "pēc (\\d++[.,]?\\d*+) sek", + "pēc (\\d++[.,]?\\d*+) sekundes", + "pēc (\\d++[.,]?\\d*+) sekundēm" ], "in \\1 week": [ - "pēc (\\d+[.,]?\\d*) ned", - "pēc (\\d+[.,]?\\d*) nedēļas", - "pēc (\\d+[.,]?\\d*) nedēļām" + "pēc (\\d++[.,]?\\d*+) ned", + "pēc (\\d++[.,]?\\d*+) nedēļas", + "pēc (\\d++[.,]?\\d*+) nedēļām" ], "in \\1 year": [ - "pēc (\\d+[.,]?\\d*) g", - "pēc (\\d+[.,]?\\d*) gada", - "pēc (\\d+[.,]?\\d*) gadiem" + "pēc (\\d++[.,]?\\d*+) g", + "pēc (\\d++[.,]?\\d*+) gada", + "pēc (\\d++[.,]?\\d*+) gadiem" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/mk.py b/dateparser/data/date_translation_data/mk.py index 01762fa10..875619585 100644 --- a/dateparser/data/date_translation_data/mk.py +++ b/dateparser/data/date_translation_data/mk.py @@ -160,60 +160,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "пред (\\d+[.,]?\\d*) ден", - "пред (\\d+[.,]?\\d*) дена" + "пред (\\d++[.,]?\\d*+) ден", + "пред (\\d++[.,]?\\d*+) дена" ], "\\1 hour ago": [ - "пред (\\d+[.,]?\\d*) час", - "пред (\\d+[.,]?\\d*) часа" + "пред (\\d++[.,]?\\d*+) час", + "пред (\\d++[.,]?\\d*+) часа" ], "\\1 minute ago": [ - "пред (\\d+[.,]?\\d*) минута", - "пред (\\d+[.,]?\\d*) минути" + "пред (\\d++[.,]?\\d*+) минута", + "пред (\\d++[.,]?\\d*+) минути" ], "\\1 month ago": [ - "пред (\\d+[.,]?\\d*) месец", - "пред (\\d+[.,]?\\d*) месеци" + "пред (\\d++[.,]?\\d*+) месец", + "пред (\\d++[.,]?\\d*+) месеци" ], "\\1 second ago": [ - "пред (\\d+[.,]?\\d*) секунда", - "пред (\\d+[.,]?\\d*) секунди" + "пред (\\d++[.,]?\\d*+) секунда", + "пред (\\d++[.,]?\\d*+) секунди" ], "\\1 week ago": [ - "пред (\\d+[.,]?\\d*) седмица", - "пред (\\d+[.,]?\\d*) седмици" + "пред (\\d++[.,]?\\d*+) седмица", + "пред (\\d++[.,]?\\d*+) седмици" ], "\\1 year ago": [ - "пред (\\d+[.,]?\\d*) година", - "пред (\\d+[.,]?\\d*) години" + "пред (\\d++[.,]?\\d*+) година", + "пред (\\d++[.,]?\\d*+) години" ], "in \\1 day": [ - "за (\\d+[.,]?\\d*) ден", - "за (\\d+[.,]?\\d*) дена" + "за (\\d++[.,]?\\d*+) ден", + "за (\\d++[.,]?\\d*+) дена" ], "in \\1 hour": [ - "за (\\d+[.,]?\\d*) час", - "за (\\d+[.,]?\\d*) часа" + "за (\\d++[.,]?\\d*+) час", + "за (\\d++[.,]?\\d*+) часа" ], "in \\1 minute": [ - "за (\\d+[.,]?\\d*) минута", - "за (\\d+[.,]?\\d*) минути" + "за (\\d++[.,]?\\d*+) минута", + "за (\\d++[.,]?\\d*+) минути" ], "in \\1 month": [ - "за (\\d+[.,]?\\d*) месец", - "за (\\d+[.,]?\\d*) месеци" + "за (\\d++[.,]?\\d*+) месец", + "за (\\d++[.,]?\\d*+) месеци" ], "in \\1 second": [ - "за (\\d+[.,]?\\d*) секунда", - "за (\\d+[.,]?\\d*) секунди" + "за (\\d++[.,]?\\d*+) секунда", + "за (\\d++[.,]?\\d*+) секунди" ], "in \\1 week": [ - "за (\\d+[.,]?\\d*) седмица", - "за (\\d+[.,]?\\d*) седмици" + "за (\\d++[.,]?\\d*+) седмица", + "за (\\d++[.,]?\\d*+) седмици" ], "in \\1 year": [ - "за (\\d+[.,]?\\d*) година", - "за (\\d+[.,]?\\d*) години" + "за (\\d++[.,]?\\d*+) година", + "за (\\d++[.,]?\\d*+) години" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ml.py b/dateparser/data/date_translation_data/ml.py index 1b95fa1e3..bda893fcf 100644 --- a/dateparser/data/date_translation_data/ml.py +++ b/dateparser/data/date_translation_data/ml.py @@ -157,46 +157,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ദിവസം മുമ്പ്" + "(\\d++[.,]?\\d*+) ദിവസം മുമ്പ്" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) മണിക്കൂർ മുമ്പ്" + "(\\d++[.,]?\\d*+) മണിക്കൂർ മുമ്പ്" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) മിനിറ്റ് മുമ്പ്" + "(\\d++[.,]?\\d*+) മിനിറ്റ് മുമ്പ്" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) മാസം മുമ്പ്" + "(\\d++[.,]?\\d*+) മാസം മുമ്പ്" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) സെക്കൻഡ് മുമ്പ്" + "(\\d++[.,]?\\d*+) സെക്കൻഡ് മുമ്പ്" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ആഴ്ച മുമ്പ്" + "(\\d++[.,]?\\d*+) ആഴ്ച മുമ്പ്" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) വർഷം മുമ്പ്" + "(\\d++[.,]?\\d*+) വർഷം മുമ്പ്" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ദിവസത്തിൽ" + "(\\d++[.,]?\\d*+) ദിവസത്തിൽ" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) മണിക്കൂറിൽ" + "(\\d++[.,]?\\d*+) മണിക്കൂറിൽ" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) മിനിറ്റിൽ" + "(\\d++[.,]?\\d*+) മിനിറ്റിൽ" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) മാസത്തിൽ" + "(\\d++[.,]?\\d*+) മാസത്തിൽ" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) സെക്കൻഡിൽ" + "(\\d++[.,]?\\d*+) സെക്കൻഡിൽ" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ആഴ്ചയിൽ" + "(\\d++[.,]?\\d*+) ആഴ്ചയിൽ" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) വർഷത്തിൽ" + "(\\d++[.,]?\\d*+) വർഷത്തിൽ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/mn.py b/dateparser/data/date_translation_data/mn.py index 32fc895d8..f8729bac6 100644 --- a/dateparser/data/date_translation_data/mn.py +++ b/dateparser/data/date_translation_data/mn.py @@ -157,53 +157,53 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) өдрийн өмнө" + "(\\d++[.,]?\\d*+) өдрийн өмнө" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ц өмнө", - "(\\d+[.,]?\\d*) цагийн өмнө" + "(\\d++[.,]?\\d*+) ц өмнө", + "(\\d++[.,]?\\d*+) цагийн өмнө" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мин өмнө", - "(\\d+[.,]?\\d*) минутын өмнө" + "(\\d++[.,]?\\d*+) мин өмнө", + "(\\d++[.,]?\\d*+) минутын өмнө" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) сарын өмнө" + "(\\d++[.,]?\\d*+) сарын өмнө" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сек өмнө", - "(\\d+[.,]?\\d*) секундын өмнө" + "(\\d++[.,]?\\d*+) сек өмнө", + "(\\d++[.,]?\\d*+) секундын өмнө" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 7х-ийн өмнө" + "(\\d++[.,]?\\d*+) 7х-ийн өмнө" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) жилийн өмнө" + "(\\d++[.,]?\\d*+) жилийн өмнө" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) өдрийн дараа", - "(\\d+[.,]?\\d*) өдөрт" + "(\\d++[.,]?\\d*+) өдрийн дараа", + "(\\d++[.,]?\\d*+) өдөрт" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ц дараа", - "(\\d+[.,]?\\d*) цагийн дараа" + "(\\d++[.,]?\\d*+) ц дараа", + "(\\d++[.,]?\\d*+) цагийн дараа" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) мин дараа", - "(\\d+[.,]?\\d*) минутын дараа" + "(\\d++[.,]?\\d*+) мин дараа", + "(\\d++[.,]?\\d*+) минутын дараа" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) сарын дараа" + "(\\d++[.,]?\\d*+) сарын дараа" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сек дараа", - "(\\d+[.,]?\\d*) секундын дараа" + "(\\d++[.,]?\\d*+) сек дараа", + "(\\d++[.,]?\\d*+) секундын дараа" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 7х-ийн дараа" + "(\\d++[.,]?\\d*+) 7х-ийн дараа" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) жилийн дараа" + "(\\d++[.,]?\\d*+) жилийн дараа" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/mr.py b/dateparser/data/date_translation_data/mr.py index 1fecbd7c3..ef2fc785a 100644 --- a/dateparser/data/date_translation_data/mr.py +++ b/dateparser/data/date_translation_data/mr.py @@ -151,64 +151,64 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) दिवसांपूर्वी", - "(\\d+[.,]?\\d*) दिवसापूर्वी" + "(\\d++[.,]?\\d*+) दिवसांपूर्वी", + "(\\d++[.,]?\\d*+) दिवसापूर्वी" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) तासांपूर्वी", - "(\\d+[.,]?\\d*) तासापूर्वी" + "(\\d++[.,]?\\d*+) तासांपूर्वी", + "(\\d++[.,]?\\d*+) तासापूर्वी" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) मिनि पूर्वी", - "(\\d+[.,]?\\d*) मिनिटांपूर्वी", - "(\\d+[.,]?\\d*) मिनिटापूर्वी" + "(\\d++[.,]?\\d*+) मिनि पूर्वी", + "(\\d++[.,]?\\d*+) मिनिटांपूर्वी", + "(\\d++[.,]?\\d*+) मिनिटापूर्वी" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) महिन्यांपूर्वी", - "(\\d+[.,]?\\d*) महिन्यापूर्वी" + "(\\d++[.,]?\\d*+) महिन्यांपूर्वी", + "(\\d++[.,]?\\d*+) महिन्यापूर्वी" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) से पूर्वी", - "(\\d+[.,]?\\d*) सेकंदांपूर्वी", - "(\\d+[.,]?\\d*) सेकंदापूर्वी" + "(\\d++[.,]?\\d*+) से पूर्वी", + "(\\d++[.,]?\\d*+) सेकंदांपूर्वी", + "(\\d++[.,]?\\d*+) सेकंदापूर्वी" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) आठवड्यांपूर्वी", - "(\\d+[.,]?\\d*) आठवड्यापूर्वी" + "(\\d++[.,]?\\d*+) आठवड्यांपूर्वी", + "(\\d++[.,]?\\d*+) आठवड्यापूर्वी" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) वर्षांपूर्वी", - "(\\d+[.,]?\\d*) वर्षापूर्वी" + "(\\d++[.,]?\\d*+) वर्षांपूर्वी", + "(\\d++[.,]?\\d*+) वर्षापूर्वी" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) दिवसांमध्ये", - "(\\d+[.,]?\\d*) दिवसामध्ये" + "(\\d++[.,]?\\d*+) दिवसांमध्ये", + "(\\d++[.,]?\\d*+) दिवसामध्ये" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) तासांमध्ये", - "(\\d+[.,]?\\d*) तासामध्ये" + "(\\d++[.,]?\\d*+) तासांमध्ये", + "(\\d++[.,]?\\d*+) तासामध्ये" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) मिनि मध्ये", - "(\\d+[.,]?\\d*) मिनिटांमध्ये", - "(\\d+[.,]?\\d*) मिनिटामध्ये" + "(\\d++[.,]?\\d*+) मिनि मध्ये", + "(\\d++[.,]?\\d*+) मिनिटांमध्ये", + "(\\d++[.,]?\\d*+) मिनिटामध्ये" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) महिन्यांमध्ये", - "(\\d+[.,]?\\d*) महिन्यामध्ये" + "(\\d++[.,]?\\d*+) महिन्यांमध्ये", + "(\\d++[.,]?\\d*+) महिन्यामध्ये" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) से मध्ये", - "(\\d+[.,]?\\d*) सेकंदांमध्ये", - "(\\d+[.,]?\\d*) सेकंदामध्ये" + "(\\d++[.,]?\\d*+) से मध्ये", + "(\\d++[.,]?\\d*+) सेकंदांमध्ये", + "(\\d++[.,]?\\d*+) सेकंदामध्ये" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) आठवड्यांमध्ये", - "(\\d+[.,]?\\d*) आठवड्यामध्ये" + "(\\d++[.,]?\\d*+) आठवड्यांमध्ये", + "(\\d++[.,]?\\d*+) आठवड्यामध्ये" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) वर्षांमध्ये", - "(\\d+[.,]?\\d*) वर्षामध्ये" + "(\\d++[.,]?\\d*+) वर्षांमध्ये", + "(\\d++[.,]?\\d*+) वर्षामध्ये" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ms.py b/dateparser/data/date_translation_data/ms.py index b685742bc..fb8670850 100644 --- a/dateparser/data/date_translation_data/ms.py +++ b/dateparser/data/date_translation_data/ms.py @@ -164,57 +164,57 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) hari lalu" + "(\\d++[.,]?\\d*+) hari lalu" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) jam lalu" + "(\\d++[.,]?\\d*+) jam lalu" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min lalu", - "(\\d+[.,]?\\d*) minit lalu" + "(\\d++[.,]?\\d*+) min lalu", + "(\\d++[.,]?\\d*+) minit lalu" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) bln lalu", - "(\\d+[.,]?\\d*) bulan lalu" + "(\\d++[.,]?\\d*+) bln lalu", + "(\\d++[.,]?\\d*+) bulan lalu" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) saat lalu" + "(\\d++[.,]?\\d*+) saat lalu" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) mgu lalu", - "(\\d+[.,]?\\d*) minggu lalu" + "(\\d++[.,]?\\d*+) mgu lalu", + "(\\d++[.,]?\\d*+) minggu lalu" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) tahun lalu", - "(\\d+[.,]?\\d*) thn lalu" + "(\\d++[.,]?\\d*+) tahun lalu", + "(\\d++[.,]?\\d*+) thn lalu" ], "in \\1 day": [ - "dalam (\\d+[.,]?\\d*) hari", - "dlm (\\d+[.,]?\\d*) hari" + "dalam (\\d++[.,]?\\d*+) hari", + "dlm (\\d++[.,]?\\d*+) hari" ], "in \\1 hour": [ - "dalam (\\d+[.,]?\\d*) jam", - "dlm (\\d+[.,]?\\d*) jam" + "dalam (\\d++[.,]?\\d*+) jam", + "dlm (\\d++[.,]?\\d*+) jam" ], "in \\1 minute": [ - "dalam (\\d+[.,]?\\d*) minit", - "dlm (\\d+[.,]?\\d*) min" + "dalam (\\d++[.,]?\\d*+) minit", + "dlm (\\d++[.,]?\\d*+) min" ], "in \\1 month": [ - "dalam (\\d+[.,]?\\d*) bulan", - "dlm (\\d+[.,]?\\d*) bln" + "dalam (\\d++[.,]?\\d*+) bulan", + "dlm (\\d++[.,]?\\d*+) bln" ], "in \\1 second": [ - "dalam (\\d+[.,]?\\d*) saat", - "dlm (\\d+[.,]?\\d*) saat" + "dalam (\\d++[.,]?\\d*+) saat", + "dlm (\\d++[.,]?\\d*+) saat" ], "in \\1 week": [ - "dalam (\\d+[.,]?\\d*) minggu", - "dlm (\\d+[.,]?\\d*) mgu" + "dalam (\\d++[.,]?\\d*+) minggu", + "dlm (\\d++[.,]?\\d*+) mgu" ], "in \\1 year": [ - "dalam (\\d+[.,]?\\d*) saat", - "dalam (\\d+[.,]?\\d*) thn" + "dalam (\\d++[.,]?\\d*+) saat", + "dalam (\\d++[.,]?\\d*+) thn" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/mt.py b/dateparser/data/date_translation_data/mt.py index d11cb0580..bc6c487d4 100644 --- a/dateparser/data/date_translation_data/mt.py +++ b/dateparser/data/date_translation_data/mt.py @@ -153,8 +153,8 @@ }, "relative-type-regex": { "\\1 year ago": [ - "(\\d+[.,]?\\d*) sena ilu", - "(\\d+[.,]?\\d*) snin ilu" + "(\\d++[.,]?\\d*+) sena ilu", + "(\\d++[.,]?\\d*+) snin ilu" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/my.py b/dateparser/data/date_translation_data/my.py index 9564fa91d..b59b5cd78 100644 --- a/dateparser/data/date_translation_data/my.py +++ b/dateparser/data/date_translation_data/my.py @@ -143,46 +143,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) ရက်" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) ရက်" ], "\\1 hour ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) နာရီ" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) နာရီ" ], "\\1 minute ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) မိနစ်" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) မိနစ်" ], "\\1 month ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) လ" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) လ" ], "\\1 second ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) စက္ကန့်" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) စက္ကန့်" ], "\\1 week ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) ပတ်" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) ပတ်" ], "\\1 year ago": [ - "ပြီးခဲ့သည့် (\\d+[.,]?\\d*) နှစ်" + "ပြီးခဲ့သည့် (\\d++[.,]?\\d*+) နှစ်" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ရက်အတွင်း" + "(\\d++[.,]?\\d*+) ရက်အတွင်း" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) နာရီအတွင်း" + "(\\d++[.,]?\\d*+) နာရီအတွင်း" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) မိနစ်အတွင်း" + "(\\d++[.,]?\\d*+) မိနစ်အတွင်း" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) လအတွင်း" + "(\\d++[.,]?\\d*+) လအတွင်း" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) စက္ကန့်အတွင်း" + "(\\d++[.,]?\\d*+) စက္ကန့်အတွင်း" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ပတ်အတွင်း" + "(\\d++[.,]?\\d*+) ပတ်အတွင်း" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) နှစ်အတွင်း" + "(\\d++[.,]?\\d*+) နှစ်အတွင်း" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/mzn.py b/dateparser/data/date_translation_data/mzn.py index 8a9fc6e15..6bc87e95d 100644 --- a/dateparser/data/date_translation_data/mzn.py +++ b/dateparser/data/date_translation_data/mzn.py @@ -136,49 +136,49 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) روز پیش" + "(\\d++[.,]?\\d*+) روز پیش" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ساعت پیش", - "(\\d+[.,]?\\d*) ساعِت پیش" + "(\\d++[.,]?\\d*+) ساعت پیش", + "(\\d++[.,]?\\d*+) ساعِت پیش" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) دَقه پیش" + "(\\d++[.,]?\\d*+) دَقه پیش" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ماه پیش" + "(\\d++[.,]?\\d*+) ماه پیش" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ثانیه پیش" + "(\\d++[.,]?\\d*+) ثانیه پیش" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) هفته پیش" + "(\\d++[.,]?\\d*+) هفته پیش" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) سال پیش" + "(\\d++[.,]?\\d*+) سال پیش" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) روز دله" + "(\\d++[.,]?\\d*+) روز دله" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ساعت دله", - "(\\d+[.,]?\\d*) ساعِت دله" + "(\\d++[.,]?\\d*+) ساعت دله", + "(\\d++[.,]?\\d*+) ساعِت دله" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) دقیقه دله", - "(\\d+[.,]?\\d*) دَقه دله" + "(\\d++[.,]?\\d*+) دقیقه دله", + "(\\d++[.,]?\\d*+) دَقه دله" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ماه دله" + "(\\d++[.,]?\\d*+) ماه دله" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) ثانیه دله" + "(\\d++[.,]?\\d*+) ثانیه دله" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) هفته دله" + "(\\d++[.,]?\\d*+) هفته دله" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) سال دله" + "(\\d++[.,]?\\d*+) سال دله" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/nb.py b/dateparser/data/date_translation_data/nb.py index e3dd32447..1a78faa5b 100644 --- a/dateparser/data/date_translation_data/nb.py +++ b/dateparser/data/date_translation_data/nb.py @@ -170,70 +170,70 @@ }, "relative-type-regex": { "\\1 day ago": [ - "for (\\d+[.,]?\\d*) d siden", - "for (\\d+[.,]?\\d*) døgn siden", - "for (\\d+[.,]?\\d*) dager siden" + "for (\\d++[.,]?\\d*+) d siden", + "for (\\d++[.,]?\\d*+) døgn siden", + "for (\\d++[.,]?\\d*+) dager siden" ], "\\1 hour ago": [ - "for (\\d+[.,]?\\d*) t siden", - "for (\\d+[.,]?\\d*) time siden", - "for (\\d+[.,]?\\d*) timer siden" + "for (\\d++[.,]?\\d*+) t siden", + "for (\\d++[.,]?\\d*+) time siden", + "for (\\d++[.,]?\\d*+) timer siden" ], "\\1 minute ago": [ - "for (\\d+[.,]?\\d*) min siden", - "for (\\d+[.,]?\\d*) minutt siden", - "for (\\d+[.,]?\\d*) minutter siden" + "for (\\d++[.,]?\\d*+) min siden", + "for (\\d++[.,]?\\d*+) minutt siden", + "for (\\d++[.,]?\\d*+) minutter siden" ], "\\1 month ago": [ - "for (\\d+[.,]?\\d*) md siden", - "for (\\d+[.,]?\\d*) måned siden", - "for (\\d+[.,]?\\d*) måneder siden" + "for (\\d++[.,]?\\d*+) md siden", + "for (\\d++[.,]?\\d*+) måned siden", + "for (\\d++[.,]?\\d*+) måneder siden" ], "\\1 second ago": [ - "for (\\d+[.,]?\\d*) sek siden", - "for (\\d+[.,]?\\d*) sekund siden", - "for (\\d+[.,]?\\d*) sekunder siden" + "for (\\d++[.,]?\\d*+) sek siden", + "for (\\d++[.,]?\\d*+) sekund siden", + "for (\\d++[.,]?\\d*+) sekunder siden" ], "\\1 week ago": [ - "for (\\d+[.,]?\\d*) u siden", - "for (\\d+[.,]?\\d*) uke siden", - "for (\\d+[.,]?\\d*) uker siden" + "for (\\d++[.,]?\\d*+) u siden", + "for (\\d++[.,]?\\d*+) uke siden", + "for (\\d++[.,]?\\d*+) uker siden" ], "\\1 year ago": [ - "for (\\d+[.,]?\\d*) år siden", - "–(\\d+[.,]?\\d*) år" + "for (\\d++[.,]?\\d*+) år siden", + "–(\\d++[.,]?\\d*+) år" ], "in \\1 day": [ - "om (\\d+[.,]?\\d*) d", - "om (\\d+[.,]?\\d*) døgn" + "om (\\d++[.,]?\\d*+) d", + "om (\\d++[.,]?\\d*+) døgn" ], "in \\1 hour": [ - "om (\\d+[.,]?\\d*) t", - "om (\\d+[.,]?\\d*) time", - "om (\\d+[.,]?\\d*) timer" + "om (\\d++[.,]?\\d*+) t", + "om (\\d++[.,]?\\d*+) time", + "om (\\d++[.,]?\\d*+) timer" ], "in \\1 minute": [ - "om (\\d+[.,]?\\d*) min", - "om (\\d+[.,]?\\d*) minutt", - "om (\\d+[.,]?\\d*) minutter" + "om (\\d++[.,]?\\d*+) min", + "om (\\d++[.,]?\\d*+) minutt", + "om (\\d++[.,]?\\d*+) minutter" ], "in \\1 month": [ - "om (\\d+[.,]?\\d*) md", - "om (\\d+[.,]?\\d*) måned", - "om (\\d+[.,]?\\d*) måneder" + "om (\\d++[.,]?\\d*+) md", + "om (\\d++[.,]?\\d*+) måned", + "om (\\d++[.,]?\\d*+) måneder" ], "in \\1 second": [ - "om (\\d+[.,]?\\d*) sek", - "om (\\d+[.,]?\\d*) sekund", - "om (\\d+[.,]?\\d*) sekunder" + "om (\\d++[.,]?\\d*+) sek", + "om (\\d++[.,]?\\d*+) sekund", + "om (\\d++[.,]?\\d*+) sekunder" ], "in \\1 week": [ - "om (\\d+[.,]?\\d*) u", - "om (\\d+[.,]?\\d*) uke", - "om (\\d+[.,]?\\d*) uker" + "om (\\d++[.,]?\\d*+) u", + "om (\\d++[.,]?\\d*+) uke", + "om (\\d++[.,]?\\d*+) uker" ], "in \\1 year": [ - "om (\\d+[.,]?\\d*) år" + "om (\\d++[.,]?\\d*+) år" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ne.py b/dateparser/data/date_translation_data/ne.py index 1bc4fb6e5..296ef07a5 100644 --- a/dateparser/data/date_translation_data/ne.py +++ b/dateparser/data/date_translation_data/ne.py @@ -143,46 +143,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) दिन पहिले" + "(\\d++[.,]?\\d*+) दिन पहिले" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) घण्टा पहिले" + "(\\d++[.,]?\\d*+) घण्टा पहिले" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) मिनेट पहिले" + "(\\d++[.,]?\\d*+) मिनेट पहिले" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) महिना पहिले" + "(\\d++[.,]?\\d*+) महिना पहिले" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) सेकेण्ड पहिले" + "(\\d++[.,]?\\d*+) सेकेण्ड पहिले" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) हप्ता पहिले" + "(\\d++[.,]?\\d*+) हप्ता पहिले" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) वर्ष अघि" + "(\\d++[.,]?\\d*+) वर्ष अघि" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) दिनमा" + "(\\d++[.,]?\\d*+) दिनमा" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) घण्टामा" + "(\\d++[.,]?\\d*+) घण्टामा" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) मिनेटमा" + "(\\d++[.,]?\\d*+) मिनेटमा" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) महिनामा" + "(\\d++[.,]?\\d*+) महिनामा" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) सेकेण्डमा" + "(\\d++[.,]?\\d*+) सेकेण्डमा" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) हप्तामा" + "(\\d++[.,]?\\d*+) हप्तामा" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) वर्षमा" + "(\\d++[.,]?\\d*+) वर्षमा" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/nl.py b/dateparser/data/date_translation_data/nl.py index 4acb1f060..376a5274e 100644 --- a/dateparser/data/date_translation_data/nl.py +++ b/dateparser/data/date_translation_data/nl.py @@ -170,62 +170,62 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) dag geleden", - "(\\d+[.,]?\\d*) dagen geleden", - "(\\d+[.,]?\\d*) dgn geleden" + "(\\d++[.,]?\\d*+) dag geleden", + "(\\d++[.,]?\\d*+) dagen geleden", + "(\\d++[.,]?\\d*+) dgn geleden" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) uur geleden" + "(\\d++[.,]?\\d*+) uur geleden" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min geleden", - "(\\d+[.,]?\\d*) minuten geleden", - "(\\d+[.,]?\\d*) minuut geleden" + "(\\d++[.,]?\\d*+) min geleden", + "(\\d++[.,]?\\d*+) minuten geleden", + "(\\d++[.,]?\\d*+) minuut geleden" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) maand geleden", - "(\\d+[.,]?\\d*) maanden geleden" + "(\\d++[.,]?\\d*+) maand geleden", + "(\\d++[.,]?\\d*+) maanden geleden" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sec geleden", - "(\\d+[.,]?\\d*) seconde geleden", - "(\\d+[.,]?\\d*) seconden geleden" + "(\\d++[.,]?\\d*+) sec geleden", + "(\\d++[.,]?\\d*+) seconde geleden", + "(\\d++[.,]?\\d*+) seconden geleden" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) week geleden", - "(\\d+[.,]?\\d*) weken geleden" + "(\\d++[.,]?\\d*+) week geleden", + "(\\d++[.,]?\\d*+) weken geleden" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) jaar geleden" + "(\\d++[.,]?\\d*+) jaar geleden" ], "in \\1 day": [ - "over (\\d+[.,]?\\d*) dag", - "over (\\d+[.,]?\\d*) dagen", - "over (\\d+[.,]?\\d*) dgn" + "over (\\d++[.,]?\\d*+) dag", + "over (\\d++[.,]?\\d*+) dagen", + "over (\\d++[.,]?\\d*+) dgn" ], "in \\1 hour": [ - "over (\\d+[.,]?\\d*) uur" + "over (\\d++[.,]?\\d*+) uur" ], "in \\1 minute": [ - "over (\\d+[.,]?\\d*) min", - "over (\\d+[.,]?\\d*) minuten", - "over (\\d+[.,]?\\d*) minuut" + "over (\\d++[.,]?\\d*+) min", + "over (\\d++[.,]?\\d*+) minuten", + "over (\\d++[.,]?\\d*+) minuut" ], "in \\1 month": [ - "over (\\d+[.,]?\\d*) maand", - "over (\\d+[.,]?\\d*) maanden" + "over (\\d++[.,]?\\d*+) maand", + "over (\\d++[.,]?\\d*+) maanden" ], "in \\1 second": [ - "over (\\d+[.,]?\\d*) sec", - "over (\\d+[.,]?\\d*) seconde", - "over (\\d+[.,]?\\d*) seconden" + "over (\\d++[.,]?\\d*+) sec", + "over (\\d++[.,]?\\d*+) seconde", + "over (\\d++[.,]?\\d*+) seconden" ], "in \\1 week": [ - "over (\\d+[.,]?\\d*) week", - "over (\\d+[.,]?\\d*) weken" + "over (\\d++[.,]?\\d*+) week", + "over (\\d++[.,]?\\d*+) weken" ], "in \\1 year": [ - "over (\\d+[.,]?\\d*) jaar" + "over (\\d++[.,]?\\d*+) jaar" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/nn.py b/dateparser/data/date_translation_data/nn.py index a0a4bb6b7..593e8c9e8 100644 --- a/dateparser/data/date_translation_data/nn.py +++ b/dateparser/data/date_translation_data/nn.py @@ -161,56 +161,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "for (\\d+[.,]?\\d*) døgn siden" + "for (\\d++[.,]?\\d*+) døgn siden" ], "\\1 hour ago": [ - "for (\\d+[.,]?\\d*) time siden", - "for (\\d+[.,]?\\d*) timer siden" + "for (\\d++[.,]?\\d*+) time siden", + "for (\\d++[.,]?\\d*+) timer siden" ], "\\1 minute ago": [ - "for (\\d+[.,]?\\d*) minutt siden", - "for (\\d+[.,]?\\d*) minutter siden" + "for (\\d++[.,]?\\d*+) minutt siden", + "for (\\d++[.,]?\\d*+) minutter siden" ], "\\1 month ago": [ - "for (\\d+[.,]?\\d*) måned siden", - "for (\\d+[.,]?\\d*) måneder siden" + "for (\\d++[.,]?\\d*+) måned siden", + "for (\\d++[.,]?\\d*+) måneder siden" ], "\\1 second ago": [ - "for (\\d+[.,]?\\d*) sekund siden", - "for (\\d+[.,]?\\d*) sekunder siden" + "for (\\d++[.,]?\\d*+) sekund siden", + "for (\\d++[.,]?\\d*+) sekunder siden" ], "\\1 week ago": [ - "for (\\d+[.,]?\\d*) uke siden", - "for (\\d+[.,]?\\d*) uker siden" + "for (\\d++[.,]?\\d*+) uke siden", + "for (\\d++[.,]?\\d*+) uker siden" ], "\\1 year ago": [ - "for (\\d+[.,]?\\d*) år siden" + "for (\\d++[.,]?\\d*+) år siden" ], "in \\1 day": [ - "om (\\d+[.,]?\\d*) døgn" + "om (\\d++[.,]?\\d*+) døgn" ], "in \\1 hour": [ - "om (\\d+[.,]?\\d*) time", - "om (\\d+[.,]?\\d*) timer" + "om (\\d++[.,]?\\d*+) time", + "om (\\d++[.,]?\\d*+) timer" ], "in \\1 minute": [ - "om (\\d+[.,]?\\d*) minutt", - "om (\\d+[.,]?\\d*) minutter" + "om (\\d++[.,]?\\d*+) minutt", + "om (\\d++[.,]?\\d*+) minutter" ], "in \\1 month": [ - "om (\\d+[.,]?\\d*) måned", - "om (\\d+[.,]?\\d*) måneder" + "om (\\d++[.,]?\\d*+) måned", + "om (\\d++[.,]?\\d*+) måneder" ], "in \\1 second": [ - "om (\\d+[.,]?\\d*) sekund", - "om (\\d+[.,]?\\d*) sekunder" + "om (\\d++[.,]?\\d*+) sekund", + "om (\\d++[.,]?\\d*+) sekunder" ], "in \\1 week": [ - "om (\\d+[.,]?\\d*) uke", - "om (\\d+[.,]?\\d*) uker" + "om (\\d++[.,]?\\d*+) uke", + "om (\\d++[.,]?\\d*+) uker" ], "in \\1 year": [ - "om (\\d+[.,]?\\d*) år" + "om (\\d++[.,]?\\d*+) år" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/os.py b/dateparser/data/date_translation_data/os.py index 62ff4867e..07cad7333 100644 --- a/dateparser/data/date_translation_data/os.py +++ b/dateparser/data/date_translation_data/os.py @@ -168,17 +168,17 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) бон раздӕр", - "(\\d+[.,]?\\d*) боны размӕ" + "(\\d++[.,]?\\d*+) бон раздӕр", + "(\\d++[.,]?\\d*+) боны размӕ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) сахаты размӕ" + "(\\d++[.,]?\\d*+) сахаты размӕ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) боны фӕстӕ" + "(\\d++[.,]?\\d*+) боны фӕстӕ" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) сахаты фӕстӕ" + "(\\d++[.,]?\\d*+) сахаты фӕстӕ" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/pa-Guru.py b/dateparser/data/date_translation_data/pa-Guru.py index 4b8d6ccc8..91fe08f7c 100644 --- a/dateparser/data/date_translation_data/pa-Guru.py +++ b/dateparser/data/date_translation_data/pa-Guru.py @@ -151,56 +151,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ਦਿਨ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਦਿਨ ਪਹਿਲਾਂ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ਘੰਟਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਘੰਟੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਘੰਟਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਘੰਟੇ ਪਹਿਲਾਂ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) ਮਿੰਟ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਮਿੰਟ ਪਹਿਲਾਂ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ਮਹੀਨਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਮਹੀਨੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਮਹੀਨਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਮਹੀਨੇ ਪਹਿਲਾਂ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ਸਕਿੰਟ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਸਕਿੰਟ ਪਹਿਲਾਂ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ਹਫ਼ਤਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਹਫ਼ਤੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਹਫ਼ਤਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਹਫ਼ਤੇ ਪਹਿਲਾਂ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ਸਾਲ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਸਾਲ ਪਹਿਲਾਂ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ਦਿਨ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਦਿਨਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਦਿਨ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਦਿਨਾਂ ਵਿੱਚ" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ਘੰਟਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਘੰਟੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਘੰਟਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਘੰਟੇ ਵਿੱਚ" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) ਮਿੰਟ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਮਿੰਟਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਮਿੰਟ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਮਿੰਟਾਂ ਵਿੱਚ" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ਮਹੀਨਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਮਹੀਨੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਮਹੀਨਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਮਹੀਨੇ ਵਿੱਚ" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) ਸਕਿੰਟ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਸਕਿੰਟਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਸਕਿੰਟ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਸਕਿੰਟਾਂ ਵਿੱਚ" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ਹਫ਼ਤਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਹਫ਼ਤੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਹਫ਼ਤਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਹਫ਼ਤੇ ਵਿੱਚ" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ਸਾਲ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਸਾਲਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਸਾਲ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਸਾਲਾਂ ਵਿੱਚ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/pa.py b/dateparser/data/date_translation_data/pa.py index 60a6425b2..2914543ee 100644 --- a/dateparser/data/date_translation_data/pa.py +++ b/dateparser/data/date_translation_data/pa.py @@ -151,56 +151,56 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ਦਿਨ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਦਿਨ ਪਹਿਲਾਂ" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ਘੰਟਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਘੰਟੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਘੰਟਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਘੰਟੇ ਪਹਿਲਾਂ" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) ਮਿੰਟ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਮਿੰਟ ਪਹਿਲਾਂ" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ਮਹੀਨਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਮਹੀਨੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਮਹੀਨਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਮਹੀਨੇ ਪਹਿਲਾਂ" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) ਸਕਿੰਟ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਸਕਿੰਟ ਪਹਿਲਾਂ" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ਹਫ਼ਤਾ ਪਹਿਲਾਂ", - "(\\d+[.,]?\\d*) ਹਫ਼ਤੇ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਹਫ਼ਤਾ ਪਹਿਲਾਂ", + "(\\d++[.,]?\\d*+) ਹਫ਼ਤੇ ਪਹਿਲਾਂ" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ਸਾਲ ਪਹਿਲਾਂ" + "(\\d++[.,]?\\d*+) ਸਾਲ ਪਹਿਲਾਂ" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) ਦਿਨ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਦਿਨਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਦਿਨ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਦਿਨਾਂ ਵਿੱਚ" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ਘੰਟਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਘੰਟੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਘੰਟਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਘੰਟੇ ਵਿੱਚ" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) ਮਿੰਟ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਮਿੰਟਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਮਿੰਟ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਮਿੰਟਾਂ ਵਿੱਚ" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ਮਹੀਨਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਮਹੀਨੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਮਹੀਨਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਮਹੀਨੇ ਵਿੱਚ" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) ਸਕਿੰਟ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਸਕਿੰਟਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਸਕਿੰਟ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਸਕਿੰਟਾਂ ਵਿੱਚ" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ਹਫ਼ਤਿਆਂ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਹਫ਼ਤੇ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਹਫ਼ਤਿਆਂ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਹਫ਼ਤੇ ਵਿੱਚ" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ਸਾਲ ਵਿੱਚ", - "(\\d+[.,]?\\d*) ਸਾਲਾਂ ਵਿੱਚ" + "(\\d++[.,]?\\d*+) ਸਾਲ ਵਿੱਚ", + "(\\d++[.,]?\\d*+) ਸਾਲਾਂ ਵਿੱਚ" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/pl.py b/dateparser/data/date_translation_data/pl.py index 95525291c..5158a9738 100644 --- a/dateparser/data/date_translation_data/pl.py +++ b/dateparser/data/date_translation_data/pl.py @@ -293,77 +293,77 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) dnia temu", - "(\\d+[.,]?\\d*) dzień temu" + "(\\d++[.,]?\\d*+) dnia temu", + "(\\d++[.,]?\\d*+) dzień temu" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) g temu", - "(\\d+[.,]?\\d*) godz temu", - "(\\d+[.,]?\\d*) godziny temu", - "(\\d+[.,]?\\d*) godzinę temu" + "(\\d++[.,]?\\d*+) g temu", + "(\\d++[.,]?\\d*+) godz temu", + "(\\d++[.,]?\\d*+) godziny temu", + "(\\d++[.,]?\\d*+) godzinę temu" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min temu", - "(\\d+[.,]?\\d*) minuty temu", - "(\\d+[.,]?\\d*) minutę temu" + "(\\d++[.,]?\\d*+) min temu", + "(\\d++[.,]?\\d*+) minuty temu", + "(\\d++[.,]?\\d*+) minutę temu" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mies temu", - "(\\d+[.,]?\\d*) miesiąc temu", - "(\\d+[.,]?\\d*) miesiąca temu", - "–(\\d+[.,]?\\d*) mies" + "(\\d++[.,]?\\d*+) mies temu", + "(\\d++[.,]?\\d*+) miesiąc temu", + "(\\d++[.,]?\\d*+) miesiąca temu", + "–(\\d++[.,]?\\d*+) mies" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) s temu", - "(\\d+[.,]?\\d*) sek temu", - "(\\d+[.,]?\\d*) sekundy temu", - "(\\d+[.,]?\\d*) sekundę temu" + "(\\d++[.,]?\\d*+) s temu", + "(\\d++[.,]?\\d*+) sek temu", + "(\\d++[.,]?\\d*+) sekundy temu", + "(\\d++[.,]?\\d*+) sekundę temu" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) tydz temu", - "(\\d+[.,]?\\d*) tydzień temu", - "(\\d+[.,]?\\d*) tyg temu", - "(\\d+[.,]?\\d*) tygodnia temu" + "(\\d++[.,]?\\d*+) tydz temu", + "(\\d++[.,]?\\d*+) tydzień temu", + "(\\d++[.,]?\\d*+) tyg temu", + "(\\d++[.,]?\\d*+) tygodnia temu" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) rok temu", - "(\\d+[.,]?\\d*) roku temu" + "(\\d++[.,]?\\d*+) rok temu", + "(\\d++[.,]?\\d*+) roku temu" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) dnia", - "za (\\d+[.,]?\\d*) dzień" + "za (\\d++[.,]?\\d*+) dnia", + "za (\\d++[.,]?\\d*+) dzień" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) godz", - "za (\\d+[.,]?\\d*) godziny", - "za (\\d+[.,]?\\d*) godzinę" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) godz", + "za (\\d++[.,]?\\d*+) godziny", + "za (\\d++[.,]?\\d*+) godzinę" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minuty", - "za (\\d+[.,]?\\d*) minutę" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minuty", + "za (\\d++[.,]?\\d*+) minutę" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) mies", - "za (\\d+[.,]?\\d*) miesiąc", - "za (\\d+[.,]?\\d*) miesiąca" + "za (\\d++[.,]?\\d*+) mies", + "za (\\d++[.,]?\\d*+) miesiąc", + "za (\\d++[.,]?\\d*+) miesiąca" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundy", - "za (\\d+[.,]?\\d*) sekundę" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundy", + "za (\\d++[.,]?\\d*+) sekundę" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) tydz", - "za (\\d+[.,]?\\d*) tydzień", - "za (\\d+[.,]?\\d*) tyg", - "za (\\d+[.,]?\\d*) tygodnia" + "za (\\d++[.,]?\\d*+) tydz", + "za (\\d++[.,]?\\d*+) tydzień", + "za (\\d++[.,]?\\d*+) tyg", + "za (\\d++[.,]?\\d*+) tygodnia" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) rok", - "za (\\d+[.,]?\\d*) roku" + "za (\\d++[.,]?\\d*+) rok", + "za (\\d++[.,]?\\d*+) roku" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/pt.py b/dateparser/data/date_translation_data/pt.py index db908355b..366b5bca4 100644 --- a/dateparser/data/date_translation_data/pt.py +++ b/dateparser/data/date_translation_data/pt.py @@ -176,71 +176,71 @@ }, "relative-type-regex": { "\\1 day ago": [ - "há (\\d+[.,]?\\d*) dia", - "há (\\d+[.,]?\\d*) dias" + "há (\\d++[.,]?\\d*+) dia", + "há (\\d++[.,]?\\d*+) dias" ], "\\1 hour ago": [ - "há (\\d+[.,]?\\d*) h", - "há (\\d+[.,]?\\d*) hora", - "há (\\d+[.,]?\\d*) horas" + "há (\\d++[.,]?\\d*+) h", + "há (\\d++[.,]?\\d*+) hora", + "há (\\d++[.,]?\\d*+) horas" ], "\\1 minute ago": [ - "há (\\d+[.,]?\\d*) min", - "há (\\d+[.,]?\\d*) mins", - "há (\\d+[.,]?\\d*) minuto", - "há (\\d+[.,]?\\d*) minutos" + "há (\\d++[.,]?\\d*+) min", + "há (\\d++[.,]?\\d*+) mins", + "há (\\d++[.,]?\\d*+) minuto", + "há (\\d++[.,]?\\d*+) minutos" ], "\\1 month ago": [ - "há (\\d+[.,]?\\d*) meses", - "há (\\d+[.,]?\\d*) mês" + "há (\\d++[.,]?\\d*+) meses", + "há (\\d++[.,]?\\d*+) mês" ], "\\1 second ago": [ - "há (\\d+[.,]?\\d*) seg", - "há (\\d+[.,]?\\d*) segundo", - "há (\\d+[.,]?\\d*) segundos" + "há (\\d++[.,]?\\d*+) seg", + "há (\\d++[.,]?\\d*+) segundo", + "há (\\d++[.,]?\\d*+) segundos" ], "\\1 week ago": [ - "há (\\d+[.,]?\\d*) sem", - "há (\\d+[.,]?\\d*) semana", - "há (\\d+[.,]?\\d*) semanas" + "há (\\d++[.,]?\\d*+) sem", + "há (\\d++[.,]?\\d*+) semana", + "há (\\d++[.,]?\\d*+) semanas" ], "\\1 year ago": [ - "há (\\d+[.,]?\\d*) ano", - "há (\\d+[.,]?\\d*) anos" + "há (\\d++[.,]?\\d*+) ano", + "há (\\d++[.,]?\\d*+) anos" ], "in \\1 day": [ - "em (\\d+[.,]?\\d*) dia", - "em (\\d+[.,]?\\d*) dias" + "em (\\d++[.,]?\\d*+) dia", + "em (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "em (\\d+[.,]?\\d*) h", - "em (\\d+[.,]?\\d*) hora", - "em (\\d+[.,]?\\d*) horas" + "em (\\d++[.,]?\\d*+) h", + "em (\\d++[.,]?\\d*+) hora", + "em (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "em (\\d+[.,]?\\d*) min", - "em (\\d+[.,]?\\d*) mins", - "em (\\d+[.,]?\\d*) minuto", - "em (\\d+[.,]?\\d*) minutos" + "em (\\d++[.,]?\\d*+) min", + "em (\\d++[.,]?\\d*+) mins", + "em (\\d++[.,]?\\d*+) minuto", + "em (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "em (\\d+[.,]?\\d*) meses", - "em (\\d+[.,]?\\d*) mês" + "em (\\d++[.,]?\\d*+) meses", + "em (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "em (\\d+[.,]?\\d*) seg", - "em (\\d+[.,]?\\d*) segs", - "em (\\d+[.,]?\\d*) segundo", - "em (\\d+[.,]?\\d*) segundos" + "em (\\d++[.,]?\\d*+) seg", + "em (\\d++[.,]?\\d*+) segs", + "em (\\d++[.,]?\\d*+) segundo", + "em (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "em (\\d+[.,]?\\d*) sem", - "em (\\d+[.,]?\\d*) semana", - "em (\\d+[.,]?\\d*) semanas" + "em (\\d++[.,]?\\d*+) sem", + "em (\\d++[.,]?\\d*+) semana", + "em (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "em (\\d+[.,]?\\d*) ano", - "em (\\d+[.,]?\\d*) anos" + "em (\\d++[.,]?\\d*+) ano", + "em (\\d++[.,]?\\d*+) anos" ] }, "locale_specific": { @@ -271,39 +271,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -334,39 +334,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -397,39 +397,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -460,39 +460,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -523,39 +523,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -586,39 +586,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -649,39 +649,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -712,39 +712,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -775,39 +775,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -838,39 +838,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } }, @@ -901,39 +901,39 @@ ], "relative-type-regex": { "\\1 second ago": [ - "há (\\d+[.,]?\\d*) s" + "há (\\d++[.,]?\\d*+) s" ], "in \\1 day": [ - "dentro de (\\d+[.,]?\\d*) dia", - "dentro de (\\d+[.,]?\\d*) dias" + "dentro de (\\d++[.,]?\\d*+) dia", + "dentro de (\\d++[.,]?\\d*+) dias" ], "in \\1 hour": [ - "dentro de (\\d+[.,]?\\d*) h", - "dentro de (\\d+[.,]?\\d*) hora", - "dentro de (\\d+[.,]?\\d*) horas" + "dentro de (\\d++[.,]?\\d*+) h", + "dentro de (\\d++[.,]?\\d*+) hora", + "dentro de (\\d++[.,]?\\d*+) horas" ], "in \\1 minute": [ - "dentro de (\\d+[.,]?\\d*) min", - "dentro de (\\d+[.,]?\\d*) minuto", - "dentro de (\\d+[.,]?\\d*) minutos" + "dentro de (\\d++[.,]?\\d*+) min", + "dentro de (\\d++[.,]?\\d*+) minuto", + "dentro de (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "dentro de (\\d+[.,]?\\d*) meses", - "dentro de (\\d+[.,]?\\d*) mês" + "dentro de (\\d++[.,]?\\d*+) meses", + "dentro de (\\d++[.,]?\\d*+) mês" ], "in \\1 second": [ - "dentro de (\\d+[.,]?\\d*) s", - "dentro de (\\d+[.,]?\\d*) segundo", - "dentro de (\\d+[.,]?\\d*) segundos" + "dentro de (\\d++[.,]?\\d*+) s", + "dentro de (\\d++[.,]?\\d*+) segundo", + "dentro de (\\d++[.,]?\\d*+) segundos" ], "in \\1 week": [ - "dentro de (\\d+[.,]?\\d*) sem", - "dentro de (\\d+[.,]?\\d*) semana", - "dentro de (\\d+[.,]?\\d*) semanas" + "dentro de (\\d++[.,]?\\d*+) sem", + "dentro de (\\d++[.,]?\\d*+) semana", + "dentro de (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "dentro de (\\d+[.,]?\\d*) ano", - "dentro de (\\d+[.,]?\\d*) anos" + "dentro de (\\d++[.,]?\\d*+) ano", + "dentro de (\\d++[.,]?\\d*+) anos" ] } } diff --git a/dateparser/data/date_translation_data/ro.py b/dateparser/data/date_translation_data/ro.py index 6dcfb16e8..181f53dc8 100644 --- a/dateparser/data/date_translation_data/ro.py +++ b/dateparser/data/date_translation_data/ro.py @@ -170,73 +170,73 @@ }, "relative-type-regex": { "\\1 day ago": [ - "acum (\\d+[.,]?\\d*) de zile", - "acum (\\d+[.,]?\\d*) zi", - "acum (\\d+[.,]?\\d*) zile" + "acum (\\d++[.,]?\\d*+) de zile", + "acum (\\d++[.,]?\\d*+) zi", + "acum (\\d++[.,]?\\d*+) zile" ], "\\1 hour ago": [ - "acum (\\d+[.,]?\\d*) de ore", - "acum (\\d+[.,]?\\d*) h", - "acum (\\d+[.,]?\\d*) oră" + "acum (\\d++[.,]?\\d*+) de ore", + "acum (\\d++[.,]?\\d*+) h", + "acum (\\d++[.,]?\\d*+) oră" ], "\\1 minute ago": [ - "acum (\\d+[.,]?\\d*) de minute", - "acum (\\d+[.,]?\\d*) min", - "acum (\\d+[.,]?\\d*) minut" + "acum (\\d++[.,]?\\d*+) de minute", + "acum (\\d++[.,]?\\d*+) min", + "acum (\\d++[.,]?\\d*+) minut" ], "\\1 month ago": [ - "acum (\\d+[.,]?\\d*) de luni", - "acum (\\d+[.,]?\\d*) luni", - "acum (\\d+[.,]?\\d*) lună" + "acum (\\d++[.,]?\\d*+) de luni", + "acum (\\d++[.,]?\\d*+) luni", + "acum (\\d++[.,]?\\d*+) lună" ], "\\1 second ago": [ - "acum (\\d+[.,]?\\d*) de secunde", - "acum (\\d+[.,]?\\d*) sec", - "acum (\\d+[.,]?\\d*) secundă" + "acum (\\d++[.,]?\\d*+) de secunde", + "acum (\\d++[.,]?\\d*+) sec", + "acum (\\d++[.,]?\\d*+) secundă" ], "\\1 week ago": [ - "acum (\\d+[.,]?\\d*) de săptămâni", - "acum (\\d+[.,]?\\d*) săpt", - "acum (\\d+[.,]?\\d*) săptămână" + "acum (\\d++[.,]?\\d*+) de săptămâni", + "acum (\\d++[.,]?\\d*+) săpt", + "acum (\\d++[.,]?\\d*+) săptămână" ], "\\1 year ago": [ - "acum (\\d+[.,]?\\d*) an", - "acum (\\d+[.,]?\\d*) de ani" + "acum (\\d++[.,]?\\d*+) an", + "acum (\\d++[.,]?\\d*+) de ani" ], "in \\1 day": [ - "peste (\\d+[.,]?\\d*) de zile", - "peste (\\d+[.,]?\\d*) zi", - "peste (\\d+[.,]?\\d*) zile" + "peste (\\d++[.,]?\\d*+) de zile", + "peste (\\d++[.,]?\\d*+) zi", + "peste (\\d++[.,]?\\d*+) zile" ], "in \\1 hour": [ - "peste (\\d+[.,]?\\d*) de ore", - "peste (\\d+[.,]?\\d*) h", - "peste (\\d+[.,]?\\d*) oră" + "peste (\\d++[.,]?\\d*+) de ore", + "peste (\\d++[.,]?\\d*+) h", + "peste (\\d++[.,]?\\d*+) oră" ], "in \\1 minute": [ - "peste (\\d+[.,]?\\d*) de minute", - "peste (\\d+[.,]?\\d*) min", - "peste (\\d+[.,]?\\d*) minut" + "peste (\\d++[.,]?\\d*+) de minute", + "peste (\\d++[.,]?\\d*+) min", + "peste (\\d++[.,]?\\d*+) minut" ], "in \\1 month": [ - "peste (\\d+[.,]?\\d*) de luni", - "peste (\\d+[.,]?\\d*) luni", - "peste (\\d+[.,]?\\d*) lună" + "peste (\\d++[.,]?\\d*+) de luni", + "peste (\\d++[.,]?\\d*+) luni", + "peste (\\d++[.,]?\\d*+) lună" ], "in \\1 second": [ - "peste (\\d+[.,]?\\d*) de secunde", - "peste (\\d+[.,]?\\d*) sec", - "peste (\\d+[.,]?\\d*) secundă" + "peste (\\d++[.,]?\\d*+) de secunde", + "peste (\\d++[.,]?\\d*+) sec", + "peste (\\d++[.,]?\\d*+) secundă" ], "in \\1 week": [ - "peste (\\d+[.,]?\\d*) de săptămâni", - "peste (\\d+[.,]?\\d*) săpt", - "peste (\\d+[.,]?\\d*) săptămână" + "peste (\\d++[.,]?\\d*+) de săptămâni", + "peste (\\d++[.,]?\\d*+) săpt", + "peste (\\d++[.,]?\\d*+) săptămână" ], "in \\1 year": [ - "peste (\\d+[.,]?\\d*) an", - "peste (\\d+[.,]?\\d*) ani", - "peste (\\d+[.,]?\\d*) de ani" + "peste (\\d++[.,]?\\d*+) an", + "peste (\\d++[.,]?\\d*+) ani", + "peste (\\d++[.,]?\\d*+) de ani" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ru.py b/dateparser/data/date_translation_data/ru.py index 052647747..c22f24351 100644 --- a/dateparser/data/date_translation_data/ru.py +++ b/dateparser/data/date_translation_data/ru.py @@ -215,76 +215,76 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) д назад", - "(\\d+[.,]?\\d*) день назад", - "(\\d+[.,]?\\d*) дн назад", - "(\\d+[.,]?\\d*) дня назад" + "(\\d++[.,]?\\d*+) д назад", + "(\\d++[.,]?\\d*+) день назад", + "(\\d++[.,]?\\d*+) дн назад", + "(\\d++[.,]?\\d*+) дня назад" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ч назад", - "(\\d+[.,]?\\d*) час назад", - "(\\d+[.,]?\\d*) часа назад" + "(\\d++[.,]?\\d*+) ч назад", + "(\\d++[.,]?\\d*+) час назад", + "(\\d++[.,]?\\d*+) часа назад" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мин назад", - "(\\d+[.,]?\\d*) минуту назад", - "(\\d+[.,]?\\d*) минуты назад" + "(\\d++[.,]?\\d*+) мин назад", + "(\\d++[.,]?\\d*+) минуту назад", + "(\\d++[.,]?\\d*+) минуты назад" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) мес назад", - "(\\d+[.,]?\\d*) месяц назад", - "(\\d+[.,]?\\d*) месяца назад" + "(\\d++[.,]?\\d*+) мес назад", + "(\\d++[.,]?\\d*+) месяц назад", + "(\\d++[.,]?\\d*+) месяца назад" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сек назад", - "(\\d+[.,]?\\d*) секунду назад", - "(\\d+[.,]?\\d*) секунды назад" + "(\\d++[.,]?\\d*+) сек назад", + "(\\d++[.,]?\\d*+) секунду назад", + "(\\d++[.,]?\\d*+) секунды назад" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) нед назад", - "(\\d+[.,]?\\d*) недели назад", - "(\\d+[.,]?\\d*) неделю назад" + "(\\d++[.,]?\\d*+) нед назад", + "(\\d++[.,]?\\d*+) недели назад", + "(\\d++[.,]?\\d*+) неделю назад" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) г назад", - "(\\d+[.,]?\\d*) год назад", - "(\\d+[.,]?\\d*) года назад" + "(\\d++[.,]?\\d*+) г назад", + "(\\d++[.,]?\\d*+) год назад", + "(\\d++[.,]?\\d*+) года назад" ], "in \\1 day": [ - "через (\\d+[.,]?\\d*) д", - "через (\\d+[.,]?\\d*) день", - "через (\\d+[.,]?\\d*) дн", - "через (\\d+[.,]?\\d*) дня" + "через (\\d++[.,]?\\d*+) д", + "через (\\d++[.,]?\\d*+) день", + "через (\\d++[.,]?\\d*+) дн", + "через (\\d++[.,]?\\d*+) дня" ], "in \\1 hour": [ - "через (\\d+[.,]?\\d*) ч", - "через (\\d+[.,]?\\d*) час", - "через (\\d+[.,]?\\d*) часа" + "через (\\d++[.,]?\\d*+) ч", + "через (\\d++[.,]?\\d*+) час", + "через (\\d++[.,]?\\d*+) часа" ], "in \\1 minute": [ - "через (\\d+[.,]?\\d*) мин", - "через (\\d+[.,]?\\d*) минуту", - "через (\\d+[.,]?\\d*) минуты" + "через (\\d++[.,]?\\d*+) мин", + "через (\\d++[.,]?\\d*+) минуту", + "через (\\d++[.,]?\\d*+) минуты" ], "in \\1 month": [ - "через (\\d+[.,]?\\d*) мес", - "через (\\d+[.,]?\\d*) месяц", - "через (\\d+[.,]?\\d*) месяца" + "через (\\d++[.,]?\\d*+) мес", + "через (\\d++[.,]?\\d*+) месяц", + "через (\\d++[.,]?\\d*+) месяца" ], "in \\1 second": [ - "через (\\d+[.,]?\\d*) сек", - "через (\\d+[.,]?\\d*) секунду", - "через (\\d+[.,]?\\d*) секунды" + "через (\\d++[.,]?\\d*+) сек", + "через (\\d++[.,]?\\d*+) секунду", + "через (\\d++[.,]?\\d*+) секунды" ], "in \\1 week": [ - "через (\\d+[.,]?\\d*) нед", - "через (\\d+[.,]?\\d*) недели", - "через (\\d+[.,]?\\d*) неделю" + "через (\\d++[.,]?\\d*+) нед", + "через (\\d++[.,]?\\d*+) недели", + "через (\\d++[.,]?\\d*+) неделю" ], "in \\1 year": [ - "через (\\d+[.,]?\\d*) г", - "через (\\d+[.,]?\\d*) год", - "через (\\d+[.,]?\\d*) года" + "через (\\d++[.,]?\\d*+) г", + "через (\\d++[.,]?\\d*+) год", + "через (\\d++[.,]?\\d*+) года" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/sah.py b/dateparser/data/date_translation_data/sah.py index da5a7d0be..5dae996cc 100644 --- a/dateparser/data/date_translation_data/sah.py +++ b/dateparser/data/date_translation_data/sah.py @@ -158,47 +158,47 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) күн ынараа өттүгэр" + "(\\d++[.,]?\\d*+) күн ынараа өттүгэр" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) чаас ынараа өттүгэр" + "(\\d++[.,]?\\d*+) чаас ынараа өттүгэр" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) мүнүүтэ ынараа өттүгэр" + "(\\d++[.,]?\\d*+) мүнүүтэ ынараа өттүгэр" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ый ынараа өттүгэр" + "(\\d++[.,]?\\d*+) ый ынараа өттүгэр" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сөк анараа өттүгэр", - "(\\d+[.,]?\\d*) сөкүүндэ ынараа өттүгэр" + "(\\d++[.,]?\\d*+) сөк анараа өттүгэр", + "(\\d++[.,]?\\d*+) сөкүүндэ ынараа өттүгэр" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) нэдиэлэ анараа өттүгэр" + "(\\d++[.,]?\\d*+) нэдиэлэ анараа өттүгэр" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) сыл ынараа өттүгэр" + "(\\d++[.,]?\\d*+) сыл ынараа өттүгэр" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) күнүнэн" + "(\\d++[.,]?\\d*+) күнүнэн" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) чааһынан" + "(\\d++[.,]?\\d*+) чааһынан" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) мүнүүтэннэн" + "(\\d++[.,]?\\d*+) мүнүүтэннэн" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ыйынан" + "(\\d++[.,]?\\d*+) ыйынан" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сөкүүндэннэн" + "(\\d++[.,]?\\d*+) сөкүүндэннэн" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) нэдиэлэннэн" + "(\\d++[.,]?\\d*+) нэдиэлэннэн" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) сылынан" + "(\\d++[.,]?\\d*+) сылынан" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/se.py b/dateparser/data/date_translation_data/se.py index 481d63a47..eb96932ef 100644 --- a/dateparser/data/date_translation_data/se.py +++ b/dateparser/data/date_translation_data/se.py @@ -157,58 +157,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) jándor árat", - "(\\d+[.,]?\\d*) jándora árat" + "(\\d++[.,]?\\d*+) jándor árat", + "(\\d++[.,]?\\d*+) jándora árat" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) diibmu árat", - "(\\d+[.,]?\\d*) diibmur árat" + "(\\d++[.,]?\\d*+) diibmu árat", + "(\\d++[.,]?\\d*+) diibmur árat" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) minuhta árat", - "(\\d+[.,]?\\d*) minuhtta árat" + "(\\d++[.,]?\\d*+) minuhta árat", + "(\\d++[.,]?\\d*+) minuhtta árat" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) mánotbadji árat" + "(\\d++[.,]?\\d*+) mánotbadji árat" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sekunda árat", - "(\\d+[.,]?\\d*) sekundda árat" + "(\\d++[.,]?\\d*+) sekunda árat", + "(\\d++[.,]?\\d*+) sekundda árat" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) vahkku árat", - "(\\d+[.,]?\\d*) vahku árat" + "(\\d++[.,]?\\d*+) vahkku árat", + "(\\d++[.,]?\\d*+) vahku árat" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) jahki árat", - "(\\d+[.,]?\\d*) jahkki árat" + "(\\d++[.,]?\\d*+) jahki árat", + "(\\d++[.,]?\\d*+) jahkki árat" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) jándor maŋŋilit", - "(\\d+[.,]?\\d*) jándora maŋŋilit" + "(\\d++[.,]?\\d*+) jándor maŋŋilit", + "(\\d++[.,]?\\d*+) jándora maŋŋilit" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) diibmu maŋŋilit", - "(\\d+[.,]?\\d*) diibmur maŋŋilit" + "(\\d++[.,]?\\d*+) diibmu maŋŋilit", + "(\\d++[.,]?\\d*+) diibmur maŋŋilit" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) minuhta maŋŋilit", - "(\\d+[.,]?\\d*) minuhtta maŋŋilit" + "(\\d++[.,]?\\d*+) minuhta maŋŋilit", + "(\\d++[.,]?\\d*+) minuhtta maŋŋilit" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) mánotbadji maŋŋilit" + "(\\d++[.,]?\\d*+) mánotbadji maŋŋilit" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) sekunda maŋŋilit", - "(\\d+[.,]?\\d*) sekundda maŋŋilit" + "(\\d++[.,]?\\d*+) sekunda maŋŋilit", + "(\\d++[.,]?\\d*+) sekundda maŋŋilit" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) vahkku maŋŋilit", - "(\\d+[.,]?\\d*) vahku maŋŋilit" + "(\\d++[.,]?\\d*+) vahkku maŋŋilit", + "(\\d++[.,]?\\d*+) vahku maŋŋilit" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) jahki maŋŋilit", - "(\\d+[.,]?\\d*) jahkki maŋŋilit" + "(\\d++[.,]?\\d*+) jahki maŋŋilit", + "(\\d++[.,]?\\d*+) jahkki maŋŋilit" ] }, "locale_specific": { @@ -252,10 +252,10 @@ }, "relative-type-regex": { "\\1 year ago": [ - "(\\d+[.,]?\\d*) jagi árat" + "(\\d++[.,]?\\d*+) jagi árat" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) jagi siste" + "(\\d++[.,]?\\d*+) jagi siste" ] } }, diff --git a/dateparser/data/date_translation_data/si.py b/dateparser/data/date_translation_data/si.py index d69a822b8..f13a69a64 100644 --- a/dateparser/data/date_translation_data/si.py +++ b/dateparser/data/date_translation_data/si.py @@ -160,46 +160,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "දින (\\d+[.,]?\\d*)කට පෙර" + "දින (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 hour ago": [ - "පැය (\\d+[.,]?\\d*)කට පෙර" + "පැය (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 minute ago": [ - "මිනිත්තු (\\d+[.,]?\\d*)කට පෙර" + "මිනිත්තු (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 month ago": [ - "මාස (\\d+[.,]?\\d*)කට පෙර" + "මාස (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 second ago": [ - "තත්පර (\\d+[.,]?\\d*)කට පෙර" + "තත්පර (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 week ago": [ - "සති (\\d+[.,]?\\d*)කට පෙර" + "සති (\\d++[.,]?\\d*+)කට පෙර" ], "\\1 year ago": [ - "වසර (\\d+[.,]?\\d*)කට පෙර" + "වසර (\\d++[.,]?\\d*+)කට පෙර" ], "in \\1 day": [ - "දින (\\d+[.,]?\\d*)න්" + "දින (\\d++[.,]?\\d*+)න්" ], "in \\1 hour": [ - "පැය (\\d+[.,]?\\d*)කින්" + "පැය (\\d++[.,]?\\d*+)කින්" ], "in \\1 minute": [ - "මිනිත්තු (\\d+[.,]?\\d*)කින්" + "මිනිත්තු (\\d++[.,]?\\d*+)කින්" ], "in \\1 month": [ - "මාස (\\d+[.,]?\\d*)කින්" + "මාස (\\d++[.,]?\\d*+)කින්" ], "in \\1 second": [ - "තත්පර (\\d+[.,]?\\d*)කින්" + "තත්පර (\\d++[.,]?\\d*+)කින්" ], "in \\1 week": [ - "සති (\\d+[.,]?\\d*)කින්" + "සති (\\d++[.,]?\\d*+)කින්" ], "in \\1 year": [ - "වසර (\\d+[.,]?\\d*)කින්" + "වසර (\\d++[.,]?\\d*+)කින්" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/sk.py b/dateparser/data/date_translation_data/sk.py index df71e31ba..4d83899a3 100644 --- a/dateparser/data/date_translation_data/sk.py +++ b/dateparser/data/date_translation_data/sk.py @@ -178,81 +178,81 @@ }, "relative-type-regex": { "\\1 day ago": [ - "pred (\\d+[.,]?\\d*) d", - "pred (\\d+[.,]?\\d*) dňami", - "pred (\\d+[.,]?\\d*) dňom" + "pred (\\d++[.,]?\\d*+) d", + "pred (\\d++[.,]?\\d*+) dňami", + "pred (\\d++[.,]?\\d*+) dňom" ], "\\1 hour ago": [ - "pred (\\d+[.,]?\\d*) h", - "pred (\\d+[.,]?\\d*) hodinami", - "pred (\\d+[.,]?\\d*) hodinou" + "pred (\\d++[.,]?\\d*+) h", + "pred (\\d++[.,]?\\d*+) hodinami", + "pred (\\d++[.,]?\\d*+) hodinou" ], "\\1 minute ago": [ - "pred (\\d+[.,]?\\d*) min", - "pred (\\d+[.,]?\\d*) minútami", - "pred (\\d+[.,]?\\d*) minútou" + "pred (\\d++[.,]?\\d*+) min", + "pred (\\d++[.,]?\\d*+) minútami", + "pred (\\d++[.,]?\\d*+) minútou" ], "\\1 month ago": [ - "pred (\\d+[.,]?\\d*) mes", - "pred (\\d+[.,]?\\d*) mesiacmi", - "pred (\\d+[.,]?\\d*) mesiacom" + "pred (\\d++[.,]?\\d*+) mes", + "pred (\\d++[.,]?\\d*+) mesiacmi", + "pred (\\d++[.,]?\\d*+) mesiacom" ], "\\1 second ago": [ - "pred (\\d+[.,]?\\d*) s", - "pred (\\d+[.,]?\\d*) sekundami", - "pred (\\d+[.,]?\\d*) sekundou" + "pred (\\d++[.,]?\\d*+) s", + "pred (\\d++[.,]?\\d*+) sekundami", + "pred (\\d++[.,]?\\d*+) sekundou" ], "\\1 week ago": [ - "pred (\\d+[.,]?\\d*) týž", - "pred (\\d+[.,]?\\d*) týždňami", - "pred (\\d+[.,]?\\d*) týždňom" + "pred (\\d++[.,]?\\d*+) týž", + "pred (\\d++[.,]?\\d*+) týždňami", + "pred (\\d++[.,]?\\d*+) týždňom" ], "\\1 year ago": [ - "pred (\\d+[.,]?\\d*) r", - "pred (\\d+[.,]?\\d*) rokmi", - "pred (\\d+[.,]?\\d*) rokom" + "pred (\\d++[.,]?\\d*+) r", + "pred (\\d++[.,]?\\d*+) rokmi", + "pred (\\d++[.,]?\\d*+) rokom" ], "in \\1 day": [ - "o (\\d+[.,]?\\d*) d", - "o (\\d+[.,]?\\d*) deň", - "o (\\d+[.,]?\\d*) dní", - "o (\\d+[.,]?\\d*) dni" + "o (\\d++[.,]?\\d*+) d", + "o (\\d++[.,]?\\d*+) deň", + "o (\\d++[.,]?\\d*+) dní", + "o (\\d++[.,]?\\d*+) dni" ], "in \\1 hour": [ - "o (\\d+[.,]?\\d*) h", - "o (\\d+[.,]?\\d*) hodinu", - "o (\\d+[.,]?\\d*) hodín", - "o (\\d+[.,]?\\d*) hodiny" + "o (\\d++[.,]?\\d*+) h", + "o (\\d++[.,]?\\d*+) hodinu", + "o (\\d++[.,]?\\d*+) hodín", + "o (\\d++[.,]?\\d*+) hodiny" ], "in \\1 minute": [ - "o (\\d+[.,]?\\d*) min", - "o (\\d+[.,]?\\d*) minút", - "o (\\d+[.,]?\\d*) minútu", - "o (\\d+[.,]?\\d*) minúty" + "o (\\d++[.,]?\\d*+) min", + "o (\\d++[.,]?\\d*+) minút", + "o (\\d++[.,]?\\d*+) minútu", + "o (\\d++[.,]?\\d*+) minúty" ], "in \\1 month": [ - "o (\\d+[.,]?\\d*) mes", - "o (\\d+[.,]?\\d*) mesiac", - "o (\\d+[.,]?\\d*) mesiacov", - "o (\\d+[.,]?\\d*) mesiace" + "o (\\d++[.,]?\\d*+) mes", + "o (\\d++[.,]?\\d*+) mesiac", + "o (\\d++[.,]?\\d*+) mesiacov", + "o (\\d++[.,]?\\d*+) mesiace" ], "in \\1 second": [ - "o (\\d+[.,]?\\d*) s", - "o (\\d+[.,]?\\d*) sekundu", - "o (\\d+[.,]?\\d*) sekúnd", - "o (\\d+[.,]?\\d*) sekundy" + "o (\\d++[.,]?\\d*+) s", + "o (\\d++[.,]?\\d*+) sekundu", + "o (\\d++[.,]?\\d*+) sekúnd", + "o (\\d++[.,]?\\d*+) sekundy" ], "in \\1 week": [ - "o (\\d+[.,]?\\d*) týž", - "o (\\d+[.,]?\\d*) týždeň", - "o (\\d+[.,]?\\d*) týždňov", - "o (\\d+[.,]?\\d*) týždne" + "o (\\d++[.,]?\\d*+) týž", + "o (\\d++[.,]?\\d*+) týždeň", + "o (\\d++[.,]?\\d*+) týždňov", + "o (\\d++[.,]?\\d*+) týždne" ], "in \\1 year": [ - "o (\\d+[.,]?\\d*) r", - "o (\\d+[.,]?\\d*) rok", - "o (\\d+[.,]?\\d*) rokov", - "o (\\d+[.,]?\\d*) roky" + "o (\\d++[.,]?\\d*+) r", + "o (\\d++[.,]?\\d*+) rok", + "o (\\d++[.,]?\\d*+) rokov", + "o (\\d++[.,]?\\d*+) roky" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/sl.py b/dateparser/data/date_translation_data/sl.py index 4985c9b9e..3f839dc79 100644 --- a/dateparser/data/date_translation_data/sl.py +++ b/dateparser/data/date_translation_data/sl.py @@ -160,70 +160,70 @@ }, "relative-type-regex": { "\\1 day ago": [ - "pred (\\d+[.,]?\\d*) dnevi", - "pred (\\d+[.,]?\\d*) dnevom" + "pred (\\d++[.,]?\\d*+) dnevi", + "pred (\\d++[.,]?\\d*+) dnevom" ], "\\1 hour ago": [ - "pred (\\d+[.,]?\\d*) h", - "pred (\\d+[.,]?\\d*) urami", - "pred (\\d+[.,]?\\d*) uro" + "pred (\\d++[.,]?\\d*+) h", + "pred (\\d++[.,]?\\d*+) urami", + "pred (\\d++[.,]?\\d*+) uro" ], "\\1 minute ago": [ - "pred (\\d+[.,]?\\d*) min", - "pred (\\d+[.,]?\\d*) minutami", - "pred (\\d+[.,]?\\d*) minuto" + "pred (\\d++[.,]?\\d*+) min", + "pred (\\d++[.,]?\\d*+) minutami", + "pred (\\d++[.,]?\\d*+) minuto" ], "\\1 month ago": [ - "pred (\\d+[.,]?\\d*) mes", - "pred (\\d+[.,]?\\d*) mesecem", - "pred (\\d+[.,]?\\d*) meseci" + "pred (\\d++[.,]?\\d*+) mes", + "pred (\\d++[.,]?\\d*+) mesecem", + "pred (\\d++[.,]?\\d*+) meseci" ], "\\1 second ago": [ - "pred (\\d+[.,]?\\d*) s", - "pred (\\d+[.,]?\\d*) sekundami", - "pred (\\d+[.,]?\\d*) sekundo" + "pred (\\d++[.,]?\\d*+) s", + "pred (\\d++[.,]?\\d*+) sekundami", + "pred (\\d++[.,]?\\d*+) sekundo" ], "\\1 week ago": [ - "pred (\\d+[.,]?\\d*) ted", - "pred (\\d+[.,]?\\d*) tedni", - "pred (\\d+[.,]?\\d*) tednom" + "pred (\\d++[.,]?\\d*+) ted", + "pred (\\d++[.,]?\\d*+) tedni", + "pred (\\d++[.,]?\\d*+) tednom" ], "\\1 year ago": [ - "pred (\\d+[.,]?\\d*) leti", - "pred (\\d+[.,]?\\d*) letom" + "pred (\\d++[.,]?\\d*+) leti", + "pred (\\d++[.,]?\\d*+) letom" ], "in \\1 day": [ - "čez (\\d+[.,]?\\d*) dan", - "čez (\\d+[.,]?\\d*) dni" + "čez (\\d++[.,]?\\d*+) dan", + "čez (\\d++[.,]?\\d*+) dni" ], "in \\1 hour": [ - "čez (\\d+[.,]?\\d*) h", - "čez (\\d+[.,]?\\d*) ur", - "čez (\\d+[.,]?\\d*) uro" + "čez (\\d++[.,]?\\d*+) h", + "čez (\\d++[.,]?\\d*+) ur", + "čez (\\d++[.,]?\\d*+) uro" ], "in \\1 minute": [ - "čez (\\d+[.,]?\\d*) min", - "čez (\\d+[.,]?\\d*) minut", - "čez (\\d+[.,]?\\d*) minuto" + "čez (\\d++[.,]?\\d*+) min", + "čez (\\d++[.,]?\\d*+) minut", + "čez (\\d++[.,]?\\d*+) minuto" ], "in \\1 month": [ - "čez (\\d+[.,]?\\d*) mes", - "čez (\\d+[.,]?\\d*) mesec", - "čez (\\d+[.,]?\\d*) mesecev" + "čez (\\d++[.,]?\\d*+) mes", + "čez (\\d++[.,]?\\d*+) mesec", + "čez (\\d++[.,]?\\d*+) mesecev" ], "in \\1 second": [ - "čez (\\d+[.,]?\\d*) s", - "čez (\\d+[.,]?\\d*) sekund", - "čez (\\d+[.,]?\\d*) sekundo" + "čez (\\d++[.,]?\\d*+) s", + "čez (\\d++[.,]?\\d*+) sekund", + "čez (\\d++[.,]?\\d*+) sekundo" ], "in \\1 week": [ - "čez (\\d+[.,]?\\d*) ted", - "čez (\\d+[.,]?\\d*) teden", - "čez (\\d+[.,]?\\d*) tednov" + "čez (\\d++[.,]?\\d*+) ted", + "čez (\\d++[.,]?\\d*+) teden", + "čez (\\d++[.,]?\\d*+) tednov" ], "in \\1 year": [ - "čez (\\d+[.,]?\\d*) let", - "čez (\\d+[.,]?\\d*) leto" + "čez (\\d++[.,]?\\d*+) let", + "čez (\\d++[.,]?\\d*+) leto" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/sq.py b/dateparser/data/date_translation_data/sq.py index a43364af2..4cd27f3ac 100644 --- a/dateparser/data/date_translation_data/sq.py +++ b/dateparser/data/date_translation_data/sq.py @@ -156,60 +156,60 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ditë më parë" + "(\\d++[.,]?\\d*+) ditë më parë" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) orë më parë" + "(\\d++[.,]?\\d*+) orë më parë" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) min më parë", - "(\\d+[.,]?\\d*) minuta më parë", - "(\\d+[.,]?\\d*) minutë më parë" + "(\\d++[.,]?\\d*+) min më parë", + "(\\d++[.,]?\\d*+) minuta më parë", + "(\\d++[.,]?\\d*+) minutë më parë" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) muaj më parë" + "(\\d++[.,]?\\d*+) muaj më parë" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) sek më parë", - "(\\d+[.,]?\\d*) sekonda më parë", - "(\\d+[.,]?\\d*) sekondë më parë" + "(\\d++[.,]?\\d*+) sek më parë", + "(\\d++[.,]?\\d*+) sekonda më parë", + "(\\d++[.,]?\\d*+) sekondë më parë" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) javë më parë" + "(\\d++[.,]?\\d*+) javë më parë" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) vit më parë", - "(\\d+[.,]?\\d*) vjet më parë" + "(\\d++[.,]?\\d*+) vit më parë", + "(\\d++[.,]?\\d*+) vjet më parë" ], "in \\1 day": [ - "pas (\\d+[.,]?\\d*) dite", - "pas (\\d+[.,]?\\d*) ditësh" + "pas (\\d++[.,]?\\d*+) dite", + "pas (\\d++[.,]?\\d*+) ditësh" ], "in \\1 hour": [ - "pas (\\d+[.,]?\\d*) ore", - "pas (\\d+[.,]?\\d*) orësh" + "pas (\\d++[.,]?\\d*+) ore", + "pas (\\d++[.,]?\\d*+) orësh" ], "in \\1 minute": [ - "pas (\\d+[.,]?\\d*) min", - "pas (\\d+[.,]?\\d*) minutash", - "pas (\\d+[.,]?\\d*) minute" + "pas (\\d++[.,]?\\d*+) min", + "pas (\\d++[.,]?\\d*+) minutash", + "pas (\\d++[.,]?\\d*+) minute" ], "in \\1 month": [ - "pas (\\d+[.,]?\\d*) muaji", - "pas (\\d+[.,]?\\d*) muajsh" + "pas (\\d++[.,]?\\d*+) muaji", + "pas (\\d++[.,]?\\d*+) muajsh" ], "in \\1 second": [ - "pas (\\d+[.,]?\\d*) sek", - "pas (\\d+[.,]?\\d*) sekondash", - "pas (\\d+[.,]?\\d*) sekonde" + "pas (\\d++[.,]?\\d*+) sek", + "pas (\\d++[.,]?\\d*+) sekondash", + "pas (\\d++[.,]?\\d*+) sekonde" ], "in \\1 week": [ - "pas (\\d+[.,]?\\d*) jave", - "pas (\\d+[.,]?\\d*) javësh" + "pas (\\d++[.,]?\\d*+) jave", + "pas (\\d++[.,]?\\d*+) javësh" ], "in \\1 year": [ - "pas (\\d+[.,]?\\d*) viti", - "pas (\\d+[.,]?\\d*) vjetësh" + "pas (\\d++[.,]?\\d*+) viti", + "pas (\\d++[.,]?\\d*+) vjetësh" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/sr-Cyrl.py b/dateparser/data/date_translation_data/sr-Cyrl.py index 4e15696b9..4e4ca7415 100644 --- a/dateparser/data/date_translation_data/sr-Cyrl.py +++ b/dateparser/data/date_translation_data/sr-Cyrl.py @@ -161,80 +161,80 @@ }, "relative-type-regex": { "\\1 day ago": [ - "пре (\\d+[.,]?\\d*) д", - "пре (\\d+[.,]?\\d*) дана" + "пре (\\d++[.,]?\\d*+) д", + "пре (\\d++[.,]?\\d*+) дана" ], "\\1 hour ago": [ - "пре (\\d+[.,]?\\d*) сата", - "пре (\\d+[.,]?\\d*) сати", - "пре (\\d+[.,]?\\d*) ч" + "пре (\\d++[.,]?\\d*+) сата", + "пре (\\d++[.,]?\\d*+) сати", + "пре (\\d++[.,]?\\d*+) ч" ], "\\1 minute ago": [ - "пре (\\d+[.,]?\\d*) мин", - "пре (\\d+[.,]?\\d*) минута" + "пре (\\d++[.,]?\\d*+) мин", + "пре (\\d++[.,]?\\d*+) минута" ], "\\1 month ago": [ - "пре (\\d+[.,]?\\d*) м", - "пре (\\d+[.,]?\\d*) мес", - "пре (\\d+[.,]?\\d*) месеца", - "пре (\\d+[.,]?\\d*) месеци" + "пре (\\d++[.,]?\\d*+) м", + "пре (\\d++[.,]?\\d*+) мес", + "пре (\\d++[.,]?\\d*+) месеца", + "пре (\\d++[.,]?\\d*+) месеци" ], "\\1 second ago": [ - "пре (\\d+[.,]?\\d*) с", - "пре (\\d+[.,]?\\d*) сек", - "пре (\\d+[.,]?\\d*) секунде", - "пре (\\d+[.,]?\\d*) секунди" + "пре (\\d++[.,]?\\d*+) с", + "пре (\\d++[.,]?\\d*+) сек", + "пре (\\d++[.,]?\\d*+) секунде", + "пре (\\d++[.,]?\\d*+) секунди" ], "\\1 week ago": [ - "пре (\\d+[.,]?\\d*) н", - "пре (\\d+[.,]?\\d*) нед", - "пре (\\d+[.,]?\\d*) недеља", - "пре (\\d+[.,]?\\d*) недеље" + "пре (\\d++[.,]?\\d*+) н", + "пре (\\d++[.,]?\\d*+) нед", + "пре (\\d++[.,]?\\d*+) недеља", + "пре (\\d++[.,]?\\d*+) недеље" ], "\\1 year ago": [ - "пре (\\d+[.,]?\\d*) г", - "пре (\\d+[.,]?\\d*) год", - "пре (\\d+[.,]?\\d*) година", - "пре (\\d+[.,]?\\d*) године" + "пре (\\d++[.,]?\\d*+) г", + "пре (\\d++[.,]?\\d*+) год", + "пре (\\d++[.,]?\\d*+) година", + "пре (\\d++[.,]?\\d*+) године" ], "in \\1 day": [ - "за (\\d+[.,]?\\d*) д", - "за (\\d+[.,]?\\d*) дан", - "за (\\d+[.,]?\\d*) дана" + "за (\\d++[.,]?\\d*+) д", + "за (\\d++[.,]?\\d*+) дан", + "за (\\d++[.,]?\\d*+) дана" ], "in \\1 hour": [ - "за (\\d+[.,]?\\d*) сат", - "за (\\d+[.,]?\\d*) сати", - "за (\\d+[.,]?\\d*) ч" + "за (\\d++[.,]?\\d*+) сат", + "за (\\d++[.,]?\\d*+) сати", + "за (\\d++[.,]?\\d*+) ч" ], "in \\1 minute": [ - "за (\\d+[.,]?\\d*) мин", - "за (\\d+[.,]?\\d*) минут", - "за (\\d+[.,]?\\d*) минута" + "за (\\d++[.,]?\\d*+) мин", + "за (\\d++[.,]?\\d*+) минут", + "за (\\d++[.,]?\\d*+) минута" ], "in \\1 month": [ - "за (\\d+[.,]?\\d*) м", - "за (\\d+[.,]?\\d*) мес", - "за (\\d+[.,]?\\d*) месец", - "за (\\d+[.,]?\\d*) месеци" + "за (\\d++[.,]?\\d*+) м", + "за (\\d++[.,]?\\d*+) мес", + "за (\\d++[.,]?\\d*+) месец", + "за (\\d++[.,]?\\d*+) месеци" ], "in \\1 second": [ - "за (\\d+[.,]?\\d*) с", - "за (\\d+[.,]?\\d*) сек", - "за (\\d+[.,]?\\d*) секунди", - "за (\\d+[.,]?\\d*) секунду" + "за (\\d++[.,]?\\d*+) с", + "за (\\d++[.,]?\\d*+) сек", + "за (\\d++[.,]?\\d*+) секунди", + "за (\\d++[.,]?\\d*+) секунду" ], "in \\1 week": [ - "за (\\d+[.,]?\\d*) н", - "за (\\d+[.,]?\\d*) нед", - "за (\\d+[.,]?\\d*) недеља", - "за (\\d+[.,]?\\d*) недељу" + "за (\\d++[.,]?\\d*+) н", + "за (\\d++[.,]?\\d*+) нед", + "за (\\d++[.,]?\\d*+) недеља", + "за (\\d++[.,]?\\d*+) недељу" ], "in \\1 year": [ - "за (\\d+[.,]?\\d*) г", - "за (\\d+[.,]?\\d*) год", - "за (\\d+[.,]?\\d*) година", - "за (\\d+[.,]?\\d*) годину" + "за (\\d++[.,]?\\d*+) г", + "за (\\d++[.,]?\\d*+) год", + "за (\\d++[.,]?\\d*+) година", + "за (\\d++[.,]?\\d*+) годину" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/sr-Latn.py b/dateparser/data/date_translation_data/sr-Latn.py index a0daf4639..c41c6daa1 100644 --- a/dateparser/data/date_translation_data/sr-Latn.py +++ b/dateparser/data/date_translation_data/sr-Latn.py @@ -161,80 +161,80 @@ }, "relative-type-regex": { "\\1 day ago": [ - "pre (\\d+[.,]?\\d*) d", - "pre (\\d+[.,]?\\d*) dana" + "pre (\\d++[.,]?\\d*+) d", + "pre (\\d++[.,]?\\d*+) dana" ], "\\1 hour ago": [ - "pre (\\d+[.,]?\\d*) sata", - "pre (\\d+[.,]?\\d*) sati", - "pre (\\d+[.,]?\\d*) č" + "pre (\\d++[.,]?\\d*+) sata", + "pre (\\d++[.,]?\\d*+) sati", + "pre (\\d++[.,]?\\d*+) č" ], "\\1 minute ago": [ - "pre (\\d+[.,]?\\d*) min", - "pre (\\d+[.,]?\\d*) minuta" + "pre (\\d++[.,]?\\d*+) min", + "pre (\\d++[.,]?\\d*+) minuta" ], "\\1 month ago": [ - "pre (\\d+[.,]?\\d*) m", - "pre (\\d+[.,]?\\d*) mes", - "pre (\\d+[.,]?\\d*) meseca", - "pre (\\d+[.,]?\\d*) meseci" + "pre (\\d++[.,]?\\d*+) m", + "pre (\\d++[.,]?\\d*+) mes", + "pre (\\d++[.,]?\\d*+) meseca", + "pre (\\d++[.,]?\\d*+) meseci" ], "\\1 second ago": [ - "pre (\\d+[.,]?\\d*) s", - "pre (\\d+[.,]?\\d*) sek", - "pre (\\d+[.,]?\\d*) sekunde", - "pre (\\d+[.,]?\\d*) sekundi" + "pre (\\d++[.,]?\\d*+) s", + "pre (\\d++[.,]?\\d*+) sek", + "pre (\\d++[.,]?\\d*+) sekunde", + "pre (\\d++[.,]?\\d*+) sekundi" ], "\\1 week ago": [ - "pre (\\d+[.,]?\\d*) n", - "pre (\\d+[.,]?\\d*) ned", - "pre (\\d+[.,]?\\d*) nedelja", - "pre (\\d+[.,]?\\d*) nedelje" + "pre (\\d++[.,]?\\d*+) n", + "pre (\\d++[.,]?\\d*+) ned", + "pre (\\d++[.,]?\\d*+) nedelja", + "pre (\\d++[.,]?\\d*+) nedelje" ], "\\1 year ago": [ - "pre (\\d+[.,]?\\d*) g", - "pre (\\d+[.,]?\\d*) god", - "pre (\\d+[.,]?\\d*) godina", - "pre (\\d+[.,]?\\d*) godine" + "pre (\\d++[.,]?\\d*+) g", + "pre (\\d++[.,]?\\d*+) god", + "pre (\\d++[.,]?\\d*+) godina", + "pre (\\d++[.,]?\\d*+) godine" ], "in \\1 day": [ - "za (\\d+[.,]?\\d*) d", - "za (\\d+[.,]?\\d*) dan", - "za (\\d+[.,]?\\d*) dana" + "za (\\d++[.,]?\\d*+) d", + "za (\\d++[.,]?\\d*+) dan", + "za (\\d++[.,]?\\d*+) dana" ], "in \\1 hour": [ - "za (\\d+[.,]?\\d*) sat", - "za (\\d+[.,]?\\d*) sati", - "za (\\d+[.,]?\\d*) č" + "za (\\d++[.,]?\\d*+) sat", + "za (\\d++[.,]?\\d*+) sati", + "za (\\d++[.,]?\\d*+) č" ], "in \\1 minute": [ - "za (\\d+[.,]?\\d*) min", - "za (\\d+[.,]?\\d*) minut", - "za (\\d+[.,]?\\d*) minuta" + "za (\\d++[.,]?\\d*+) min", + "za (\\d++[.,]?\\d*+) minut", + "za (\\d++[.,]?\\d*+) minuta" ], "in \\1 month": [ - "za (\\d+[.,]?\\d*) m", - "za (\\d+[.,]?\\d*) mes", - "za (\\d+[.,]?\\d*) mesec", - "za (\\d+[.,]?\\d*) meseci" + "za (\\d++[.,]?\\d*+) m", + "za (\\d++[.,]?\\d*+) mes", + "za (\\d++[.,]?\\d*+) mesec", + "za (\\d++[.,]?\\d*+) meseci" ], "in \\1 second": [ - "za (\\d+[.,]?\\d*) s", - "za (\\d+[.,]?\\d*) sek", - "za (\\d+[.,]?\\d*) sekundi", - "za (\\d+[.,]?\\d*) sekundu" + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sek", + "za (\\d++[.,]?\\d*+) sekundi", + "za (\\d++[.,]?\\d*+) sekundu" ], "in \\1 week": [ - "za (\\d+[.,]?\\d*) n", - "za (\\d+[.,]?\\d*) ned", - "za (\\d+[.,]?\\d*) nedelja", - "za (\\d+[.,]?\\d*) nedelju" + "za (\\d++[.,]?\\d*+) n", + "za (\\d++[.,]?\\d*+) ned", + "za (\\d++[.,]?\\d*+) nedelja", + "za (\\d++[.,]?\\d*+) nedelju" ], "in \\1 year": [ - "za (\\d+[.,]?\\d*) g", - "za (\\d+[.,]?\\d*) god", - "za (\\d+[.,]?\\d*) godina", - "za (\\d+[.,]?\\d*) godinu" + "za (\\d++[.,]?\\d*+) g", + "za (\\d++[.,]?\\d*+) god", + "za (\\d++[.,]?\\d*+) godina", + "za (\\d++[.,]?\\d*+) godinu" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/sr.py b/dateparser/data/date_translation_data/sr.py index 42a967bc9..f93b76224 100644 --- a/dateparser/data/date_translation_data/sr.py +++ b/dateparser/data/date_translation_data/sr.py @@ -161,80 +161,80 @@ }, "relative-type-regex": { "\\1 day ago": [ - "пре (\\d+[.,]?\\d*) д", - "пре (\\d+[.,]?\\d*) дана" + "пре (\\d++[.,]?\\d*+) д", + "пре (\\d++[.,]?\\d*+) дана" ], "\\1 hour ago": [ - "пре (\\d+[.,]?\\d*) сата", - "пре (\\d+[.,]?\\d*) сати", - "пре (\\d+[.,]?\\d*) ч" + "пре (\\d++[.,]?\\d*+) сата", + "пре (\\d++[.,]?\\d*+) сати", + "пре (\\d++[.,]?\\d*+) ч" ], "\\1 minute ago": [ - "пре (\\d+[.,]?\\d*) мин", - "пре (\\d+[.,]?\\d*) минута" + "пре (\\d++[.,]?\\d*+) мин", + "пре (\\d++[.,]?\\d*+) минута" ], "\\1 month ago": [ - "пре (\\d+[.,]?\\d*) м", - "пре (\\d+[.,]?\\d*) мес", - "пре (\\d+[.,]?\\d*) месеца", - "пре (\\d+[.,]?\\d*) месеци" + "пре (\\d++[.,]?\\d*+) м", + "пре (\\d++[.,]?\\d*+) мес", + "пре (\\d++[.,]?\\d*+) месеца", + "пре (\\d++[.,]?\\d*+) месеци" ], "\\1 second ago": [ - "пре (\\d+[.,]?\\d*) с", - "пре (\\d+[.,]?\\d*) сек", - "пре (\\d+[.,]?\\d*) секунде", - "пре (\\d+[.,]?\\d*) секунди" + "пре (\\d++[.,]?\\d*+) с", + "пре (\\d++[.,]?\\d*+) сек", + "пре (\\d++[.,]?\\d*+) секунде", + "пре (\\d++[.,]?\\d*+) секунди" ], "\\1 week ago": [ - "пре (\\d+[.,]?\\d*) н", - "пре (\\d+[.,]?\\d*) нед", - "пре (\\d+[.,]?\\d*) недеља", - "пре (\\d+[.,]?\\d*) недеље" + "пре (\\d++[.,]?\\d*+) н", + "пре (\\d++[.,]?\\d*+) нед", + "пре (\\d++[.,]?\\d*+) недеља", + "пре (\\d++[.,]?\\d*+) недеље" ], "\\1 year ago": [ - "пре (\\d+[.,]?\\d*) г", - "пре (\\d+[.,]?\\d*) год", - "пре (\\d+[.,]?\\d*) година", - "пре (\\d+[.,]?\\d*) године" + "пре (\\d++[.,]?\\d*+) г", + "пре (\\d++[.,]?\\d*+) год", + "пре (\\d++[.,]?\\d*+) година", + "пре (\\d++[.,]?\\d*+) године" ], "in \\1 day": [ - "за (\\d+[.,]?\\d*) д", - "за (\\d+[.,]?\\d*) дан", - "за (\\d+[.,]?\\d*) дана" + "за (\\d++[.,]?\\d*+) д", + "за (\\d++[.,]?\\d*+) дан", + "за (\\d++[.,]?\\d*+) дана" ], "in \\1 hour": [ - "за (\\d+[.,]?\\d*) сат", - "за (\\d+[.,]?\\d*) сати", - "за (\\d+[.,]?\\d*) ч" + "за (\\d++[.,]?\\d*+) сат", + "за (\\d++[.,]?\\d*+) сати", + "за (\\d++[.,]?\\d*+) ч" ], "in \\1 minute": [ - "за (\\d+[.,]?\\d*) мин", - "за (\\d+[.,]?\\d*) минут", - "за (\\d+[.,]?\\d*) минута" + "за (\\d++[.,]?\\d*+) мин", + "за (\\d++[.,]?\\d*+) минут", + "за (\\d++[.,]?\\d*+) минута" ], "in \\1 month": [ - "за (\\d+[.,]?\\d*) м", - "за (\\d+[.,]?\\d*) мес", - "за (\\d+[.,]?\\d*) месец", - "за (\\d+[.,]?\\d*) месеци" + "за (\\d++[.,]?\\d*+) м", + "за (\\d++[.,]?\\d*+) мес", + "за (\\d++[.,]?\\d*+) месец", + "за (\\d++[.,]?\\d*+) месеци" ], "in \\1 second": [ - "за (\\d+[.,]?\\d*) с", - "за (\\d+[.,]?\\d*) сек", - "за (\\d+[.,]?\\d*) секунди", - "за (\\d+[.,]?\\d*) секунду" + "за (\\d++[.,]?\\d*+) с", + "за (\\d++[.,]?\\d*+) сек", + "за (\\d++[.,]?\\d*+) секунди", + "за (\\d++[.,]?\\d*+) секунду" ], "in \\1 week": [ - "за (\\d+[.,]?\\d*) н", - "за (\\d+[.,]?\\d*) нед", - "за (\\d+[.,]?\\d*) недеља", - "за (\\d+[.,]?\\d*) недељу" + "за (\\d++[.,]?\\d*+) н", + "за (\\d++[.,]?\\d*+) нед", + "за (\\d++[.,]?\\d*+) недеља", + "за (\\d++[.,]?\\d*+) недељу" ], "in \\1 year": [ - "за (\\d+[.,]?\\d*) г", - "за (\\d+[.,]?\\d*) год", - "за (\\d+[.,]?\\d*) година", - "за (\\d+[.,]?\\d*) годину" + "за (\\d++[.,]?\\d*+) г", + "за (\\d++[.,]?\\d*+) год", + "за (\\d++[.,]?\\d*+) година", + "за (\\d++[.,]?\\d*+) годину" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/sv.py b/dateparser/data/date_translation_data/sv.py index 5f10e71e9..1ac211789 100644 --- a/dateparser/data/date_translation_data/sv.py +++ b/dateparser/data/date_translation_data/sv.py @@ -192,77 +192,77 @@ }, "relative-type-regex": { "\\1 day ago": [ - "för (\\d+[.,]?\\d*) d sedan", - "för (\\d+[.,]?\\d*) dag sedan", - "för (\\d+[.,]?\\d*) dagar sedan", - "−(\\d+[.,]?\\d*) d" + "för (\\d++[.,]?\\d*+) d sedan", + "för (\\d++[.,]?\\d*+) dag sedan", + "för (\\d++[.,]?\\d*+) dagar sedan", + "−(\\d++[.,]?\\d*+) d" ], "\\1 hour ago": [ - "för (\\d+[.,]?\\d*) tim sedan", - "för (\\d+[.,]?\\d*) timmar sedan", - "för (\\d+[.,]?\\d*) timme sedan", - "−(\\d+[.,]?\\d*) h" + "för (\\d++[.,]?\\d*+) tim sedan", + "för (\\d++[.,]?\\d*+) timmar sedan", + "för (\\d++[.,]?\\d*+) timme sedan", + "−(\\d++[.,]?\\d*+) h" ], "\\1 minute ago": [ - "för (\\d+[.,]?\\d*) min sedan", - "för (\\d+[.,]?\\d*) minut sedan", - "för (\\d+[.,]?\\d*) minuter sedan", - "−(\\d+[.,]?\\d*) min" + "för (\\d++[.,]?\\d*+) min sedan", + "för (\\d++[.,]?\\d*+) minut sedan", + "för (\\d++[.,]?\\d*+) minuter sedan", + "−(\\d++[.,]?\\d*+) min" ], "\\1 month ago": [ - "för (\\d+[.,]?\\d*) mån sedan", - "för (\\d+[.,]?\\d*) månad sedan", - "för (\\d+[.,]?\\d*) månader sedan", - "−(\\d+[.,]?\\d*) mån" + "för (\\d++[.,]?\\d*+) mån sedan", + "för (\\d++[.,]?\\d*+) månad sedan", + "för (\\d++[.,]?\\d*+) månader sedan", + "−(\\d++[.,]?\\d*+) mån" ], "\\1 second ago": [ - "för (\\d+[.,]?\\d*) sek sedan", - "för (\\d+[.,]?\\d*) sekund sedan", - "för (\\d+[.,]?\\d*) sekunder sedan", - "−(\\d+[.,]?\\d*) s" + "för (\\d++[.,]?\\d*+) sek sedan", + "för (\\d++[.,]?\\d*+) sekund sedan", + "för (\\d++[.,]?\\d*+) sekunder sedan", + "−(\\d++[.,]?\\d*+) s" ], "\\1 week ago": [ - "för (\\d+[.,]?\\d*) v sedan", - "för (\\d+[.,]?\\d*) vecka sedan", - "för (\\d+[.,]?\\d*) veckor sedan", - "−(\\d+[.,]?\\d*) v" + "för (\\d++[.,]?\\d*+) v sedan", + "för (\\d++[.,]?\\d*+) vecka sedan", + "för (\\d++[.,]?\\d*+) veckor sedan", + "−(\\d++[.,]?\\d*+) v" ], "\\1 year ago": [ - "för (\\d+[.,]?\\d*) år sedan", - "−(\\d+[.,]?\\d*) år" + "för (\\d++[.,]?\\d*+) år sedan", + "−(\\d++[.,]?\\d*+) år" ], "in \\1 day": [ - "om (\\d+[.,]?\\d*) d", - "om (\\d+[.,]?\\d*) dag", - "om (\\d+[.,]?\\d*) dagar" + "om (\\d++[.,]?\\d*+) d", + "om (\\d++[.,]?\\d*+) dag", + "om (\\d++[.,]?\\d*+) dagar" ], "in \\1 hour": [ - "om (\\d+[.,]?\\d*) tim", - "om (\\d+[.,]?\\d*) timmar", - "om (\\d+[.,]?\\d*) timme" + "om (\\d++[.,]?\\d*+) tim", + "om (\\d++[.,]?\\d*+) timmar", + "om (\\d++[.,]?\\d*+) timme" ], "in \\1 minute": [ - "om (\\d+[.,]?\\d*) min", - "om (\\d+[.,]?\\d*) minut", - "om (\\d+[.,]?\\d*) minuter" + "om (\\d++[.,]?\\d*+) min", + "om (\\d++[.,]?\\d*+) minut", + "om (\\d++[.,]?\\d*+) minuter" ], "in \\1 month": [ - "om (\\d+[.,]?\\d*) mån", - "om (\\d+[.,]?\\d*) månad", - "om (\\d+[.,]?\\d*) månader" + "om (\\d++[.,]?\\d*+) mån", + "om (\\d++[.,]?\\d*+) månad", + "om (\\d++[.,]?\\d*+) månader" ], "in \\1 second": [ - "om (\\d+[.,]?\\d*) sek", - "om (\\d+[.,]?\\d*) sekund", - "om (\\d+[.,]?\\d*) sekunder" + "om (\\d++[.,]?\\d*+) sek", + "om (\\d++[.,]?\\d*+) sekund", + "om (\\d++[.,]?\\d*+) sekunder" ], "in \\1 week": [ - "om (\\d+[.,]?\\d*) v", - "om (\\d+[.,]?\\d*) vecka", - "om (\\d+[.,]?\\d*) veckor" + "om (\\d++[.,]?\\d*+) v", + "om (\\d++[.,]?\\d*+) vecka", + "om (\\d++[.,]?\\d*+) veckor" ], "in \\1 year": [ - "om (\\d+[.,]?\\d*) år" + "om (\\d++[.,]?\\d*+) år" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/sw.py b/dateparser/data/date_translation_data/sw.py index eee516e31..979e5ac5b 100644 --- a/dateparser/data/date_translation_data/sw.py +++ b/dateparser/data/date_translation_data/sw.py @@ -149,55 +149,55 @@ }, "relative-type-regex": { "\\1 day ago": [ - "siku (\\d+[.,]?\\d*) iliyopita", - "siku (\\d+[.,]?\\d*) zilizopita" + "siku (\\d++[.,]?\\d*+) iliyopita", + "siku (\\d++[.,]?\\d*+) zilizopita" ], "\\1 hour ago": [ - "saa (\\d+[.,]?\\d*) iliyopita", - "saa (\\d+[.,]?\\d*) zilizopita" + "saa (\\d++[.,]?\\d*+) iliyopita", + "saa (\\d++[.,]?\\d*+) zilizopita" ], "\\1 minute ago": [ - "dakika (\\d+[.,]?\\d*) iliyopita", - "dakika (\\d+[.,]?\\d*) zilizopita" + "dakika (\\d++[.,]?\\d*+) iliyopita", + "dakika (\\d++[.,]?\\d*+) zilizopita" ], "\\1 month ago": [ - "miezi (\\d+[.,]?\\d*) iliyopita", - "mwezi (\\d+[.,]?\\d*) uliopita" + "miezi (\\d++[.,]?\\d*+) iliyopita", + "mwezi (\\d++[.,]?\\d*+) uliopita" ], "\\1 second ago": [ - "sekunde (\\d+[.,]?\\d*) iliyopita", - "sekunde (\\d+[.,]?\\d*) zilizopita" + "sekunde (\\d++[.,]?\\d*+) iliyopita", + "sekunde (\\d++[.,]?\\d*+) zilizopita" ], "\\1 week ago": [ - "wiki (\\d+[.,]?\\d*) iliyopita", - "wiki (\\d+[.,]?\\d*) zilizopita" + "wiki (\\d++[.,]?\\d*+) iliyopita", + "wiki (\\d++[.,]?\\d*+) zilizopita" ], "\\1 year ago": [ - "miaka (\\d+[.,]?\\d*) iliyopita", - "mwaka (\\d+[.,]?\\d*) uliopita" + "miaka (\\d++[.,]?\\d*+) iliyopita", + "mwaka (\\d++[.,]?\\d*+) uliopita" ], "in \\1 day": [ - "baada ya siku (\\d+[.,]?\\d*)" + "baada ya siku (\\d++[.,]?\\d*+)" ], "in \\1 hour": [ - "baada ya saa (\\d+[.,]?\\d*)" + "baada ya saa (\\d++[.,]?\\d*+)" ], "in \\1 minute": [ - "baada ya dakika (\\d+[.,]?\\d*)" + "baada ya dakika (\\d++[.,]?\\d*+)" ], "in \\1 month": [ - "baada ya miezi (\\d+[.,]?\\d*)", - "baada ya mwezi (\\d+[.,]?\\d*)" + "baada ya miezi (\\d++[.,]?\\d*+)", + "baada ya mwezi (\\d++[.,]?\\d*+)" ], "in \\1 second": [ - "baada ya sekunde (\\d+[.,]?\\d*)" + "baada ya sekunde (\\d++[.,]?\\d*+)" ], "in \\1 week": [ - "baada ya wiki (\\d+[.,]?\\d*)" + "baada ya wiki (\\d++[.,]?\\d*+)" ], "in \\1 year": [ - "baada ya miaka (\\d+[.,]?\\d*)", - "baada ya mwaka (\\d+[.,]?\\d*)" + "baada ya miaka (\\d++[.,]?\\d*+)", + "baada ya mwaka (\\d++[.,]?\\d*+)" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ta.py b/dateparser/data/date_translation_data/ta.py index 43c53f1b6..1ea21b793 100644 --- a/dateparser/data/date_translation_data/ta.py +++ b/dateparser/data/date_translation_data/ta.py @@ -158,82 +158,82 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) நா முன்", - "(\\d+[.,]?\\d*) நாட்களுக்கு முன்", - "(\\d+[.,]?\\d*) நாளுக்கு முன்" + "(\\d++[.,]?\\d*+) நா முன்", + "(\\d++[.,]?\\d*+) நாட்களுக்கு முன்", + "(\\d++[.,]?\\d*+) நாளுக்கு முன்" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ம முன்", - "(\\d+[.,]?\\d*) மணி முன்", - "(\\d+[.,]?\\d*) மணிநேரம் முன்" + "(\\d++[.,]?\\d*+) ம முன்", + "(\\d++[.,]?\\d*+) மணி முன்", + "(\\d++[.,]?\\d*+) மணிநேரம் முன்" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) நி முன்", - "(\\d+[.,]?\\d*) நிமி முன்", - "(\\d+[.,]?\\d*) நிமிடங்களுக்கு முன்", - "(\\d+[.,]?\\d*) நிமிடத்திற்கு முன்" + "(\\d++[.,]?\\d*+) நி முன்", + "(\\d++[.,]?\\d*+) நிமி முன்", + "(\\d++[.,]?\\d*+) நிமிடங்களுக்கு முன்", + "(\\d++[.,]?\\d*+) நிமிடத்திற்கு முன்" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) மா முன்", - "(\\d+[.,]?\\d*) மாத முன்", - "(\\d+[.,]?\\d*) மாதங்களுக்கு முன்", - "(\\d+[.,]?\\d*) மாதத்துக்கு முன்" + "(\\d++[.,]?\\d*+) மா முன்", + "(\\d++[.,]?\\d*+) மாத முன்", + "(\\d++[.,]?\\d*+) மாதங்களுக்கு முன்", + "(\\d++[.,]?\\d*+) மாதத்துக்கு முன்" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) வி முன்", - "(\\d+[.,]?\\d*) விநா முன்", - "(\\d+[.,]?\\d*) விநாடிகளுக்கு முன்", - "(\\d+[.,]?\\d*) விநாடிக்கு முன்" + "(\\d++[.,]?\\d*+) வி முன்", + "(\\d++[.,]?\\d*+) விநா முன்", + "(\\d++[.,]?\\d*+) விநாடிகளுக்கு முன்", + "(\\d++[.,]?\\d*+) விநாடிக்கு முன்" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) வா முன்", - "(\\d+[.,]?\\d*) வார முன்", - "(\\d+[.,]?\\d*) வாரங்களுக்கு முன்", - "(\\d+[.,]?\\d*) வாரத்திற்கு முன்பு" + "(\\d++[.,]?\\d*+) வா முன்", + "(\\d++[.,]?\\d*+) வார முன்", + "(\\d++[.,]?\\d*+) வாரங்களுக்கு முன்", + "(\\d++[.,]?\\d*+) வாரத்திற்கு முன்பு" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ஆ முன்", - "(\\d+[.,]?\\d*) ஆண்டிற்கு முன்", - "(\\d+[.,]?\\d*) ஆண்டுகளுக்கு முன்" + "(\\d++[.,]?\\d*+) ஆ முன்", + "(\\d++[.,]?\\d*+) ஆண்டிற்கு முன்", + "(\\d++[.,]?\\d*+) ஆண்டுகளுக்கு முன்" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) நா", - "(\\d+[.,]?\\d*) நாட்களில்", - "(\\d+[.,]?\\d*) நாளில்" + "(\\d++[.,]?\\d*+) நா", + "(\\d++[.,]?\\d*+) நாட்களில்", + "(\\d++[.,]?\\d*+) நாளில்" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) ம", - "(\\d+[.,]?\\d*) மணி", - "(\\d+[.,]?\\d*) மணிநேரத்தில்" + "(\\d++[.,]?\\d*+) ம", + "(\\d++[.,]?\\d*+) மணி", + "(\\d++[.,]?\\d*+) மணிநேரத்தில்" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) நி", - "(\\d+[.,]?\\d*) நிமி", - "(\\d+[.,]?\\d*) நிமிடங்களில்", - "(\\d+[.,]?\\d*) நிமிடத்தில்" + "(\\d++[.,]?\\d*+) நி", + "(\\d++[.,]?\\d*+) நிமி", + "(\\d++[.,]?\\d*+) நிமிடங்களில்", + "(\\d++[.,]?\\d*+) நிமிடத்தில்" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) மா", - "(\\d+[.,]?\\d*) மாத", - "(\\d+[.,]?\\d*) மாதங்களில்", - "(\\d+[.,]?\\d*) மாதத்தில்" + "(\\d++[.,]?\\d*+) மா", + "(\\d++[.,]?\\d*+) மாத", + "(\\d++[.,]?\\d*+) மாதங்களில்", + "(\\d++[.,]?\\d*+) மாதத்தில்" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) வி", - "(\\d+[.,]?\\d*) விநா", - "(\\d+[.,]?\\d*) விநாடிகளில்", - "(\\d+[.,]?\\d*) விநாடியில்" + "(\\d++[.,]?\\d*+) வி", + "(\\d++[.,]?\\d*+) விநா", + "(\\d++[.,]?\\d*+) விநாடிகளில்", + "(\\d++[.,]?\\d*+) விநாடியில்" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) வா", - "(\\d+[.,]?\\d*) வார", - "(\\d+[.,]?\\d*) வாரங்களில்", - "(\\d+[.,]?\\d*) வாரத்தில்" + "(\\d++[.,]?\\d*+) வா", + "(\\d++[.,]?\\d*+) வார", + "(\\d++[.,]?\\d*+) வாரங்களில்", + "(\\d++[.,]?\\d*+) வாரத்தில்" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) ஆ", - "(\\d+[.,]?\\d*) ஆண்டில்", - "(\\d+[.,]?\\d*) ஆண்டுகளில்" + "(\\d++[.,]?\\d*+) ஆ", + "(\\d++[.,]?\\d*+) ஆண்டில்", + "(\\d++[.,]?\\d*+) ஆண்டுகளில்" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/te.py b/dateparser/data/date_translation_data/te.py index c488d68fa..78693c960 100644 --- a/dateparser/data/date_translation_data/te.py +++ b/dateparser/data/date_translation_data/te.py @@ -157,68 +157,68 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) రోజు క్రితం", - "(\\d+[.,]?\\d*) రోజుల క్రితం" + "(\\d++[.,]?\\d*+) రోజు క్రితం", + "(\\d++[.,]?\\d*+) రోజుల క్రితం" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) గం క్రితం", - "(\\d+[.,]?\\d*) గంట క్రితం", - "(\\d+[.,]?\\d*) గంటల క్రితం" + "(\\d++[.,]?\\d*+) గం క్రితం", + "(\\d++[.,]?\\d*+) గంట క్రితం", + "(\\d++[.,]?\\d*+) గంటల క్రితం" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) నిమి క్రితం", - "(\\d+[.,]?\\d*) నిమిషం క్రితం", - "(\\d+[.,]?\\d*) నిమిషాల క్రితం" + "(\\d++[.,]?\\d*+) నిమి క్రితం", + "(\\d++[.,]?\\d*+) నిమిషం క్రితం", + "(\\d++[.,]?\\d*+) నిమిషాల క్రితం" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) నెల క్రితం", - "(\\d+[.,]?\\d*) నెలల క్రితం" + "(\\d++[.,]?\\d*+) నెల క్రితం", + "(\\d++[.,]?\\d*+) నెలల క్రితం" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) సెక క్రితం", - "(\\d+[.,]?\\d*) సెకను క్రితం", - "(\\d+[.,]?\\d*) సెకన్ల క్రితం" + "(\\d++[.,]?\\d*+) సెక క్రితం", + "(\\d++[.,]?\\d*+) సెకను క్రితం", + "(\\d++[.,]?\\d*+) సెకన్ల క్రితం" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) వారం క్రితం", - "(\\d+[.,]?\\d*) వారాల క్రితం" + "(\\d++[.,]?\\d*+) వారం క్రితం", + "(\\d++[.,]?\\d*+) వారాల క్రితం" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) సం క్రితం", - "(\\d+[.,]?\\d*) సంవత్సరం క్రితం", - "(\\d+[.,]?\\d*) సంవత్సరాల క్రితం" + "(\\d++[.,]?\\d*+) సం క్రితం", + "(\\d++[.,]?\\d*+) సంవత్సరం క్రితం", + "(\\d++[.,]?\\d*+) సంవత్సరాల క్రితం" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) రోజులో", - "(\\d+[.,]?\\d*) రోజుల్లో" + "(\\d++[.,]?\\d*+) రోజులో", + "(\\d++[.,]?\\d*+) రోజుల్లో" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) గంటలో", - "(\\d+[.,]?\\d*) గంటల్లో", - "(\\d+[.,]?\\d*) గంలో" + "(\\d++[.,]?\\d*+) గంటలో", + "(\\d++[.,]?\\d*+) గంటల్లో", + "(\\d++[.,]?\\d*+) గంలో" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) నిమిలో", - "(\\d+[.,]?\\d*) నిమిషంలో", - "(\\d+[.,]?\\d*) నిమిషాల్లో" + "(\\d++[.,]?\\d*+) నిమిలో", + "(\\d++[.,]?\\d*+) నిమిషంలో", + "(\\d++[.,]?\\d*+) నిమిషాల్లో" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) నెలలో", - "(\\d+[.,]?\\d*) నెలల్లో" + "(\\d++[.,]?\\d*+) నెలలో", + "(\\d++[.,]?\\d*+) నెలల్లో" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) సెక లో", - "(\\d+[.,]?\\d*) సెకనులో", - "(\\d+[.,]?\\d*) సెకన్లలో" + "(\\d++[.,]?\\d*+) సెక లో", + "(\\d++[.,]?\\d*+) సెకనులో", + "(\\d++[.,]?\\d*+) సెకన్లలో" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) వారంలో", - "(\\d+[.,]?\\d*) వారాల్లో" + "(\\d++[.,]?\\d*+) వారంలో", + "(\\d++[.,]?\\d*+) వారాల్లో" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) సంలో", - "(\\d+[.,]?\\d*) సంవత్సరంలో", - "(\\d+[.,]?\\d*) సంవత్సరాల్లో" + "(\\d++[.,]?\\d*+) సంలో", + "(\\d++[.,]?\\d*+) సంవత్సరంలో", + "(\\d++[.,]?\\d*+) సంవత్సరాల్లో" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/th.py b/dateparser/data/date_translation_data/th.py index 031920ced..208765477 100644 --- a/dateparser/data/date_translation_data/th.py +++ b/dateparser/data/date_translation_data/th.py @@ -195,59 +195,59 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) วันที่ผ่านมา", - "(\\d+[.,]?\\d*) วันที่แล้ว" + "(\\d++[.,]?\\d*+) วันที่ผ่านมา", + "(\\d++[.,]?\\d*+) วันที่แล้ว" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) ชม ที่แล้ว", - "(\\d+[.,]?\\d*) ชั่วโมงที่ผ่านมา" + "(\\d++[.,]?\\d*+) ชม ที่แล้ว", + "(\\d++[.,]?\\d*+) ชั่วโมงที่ผ่านมา" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) นาทีที่ผ่านมา", - "(\\d+[.,]?\\d*) นาทีที่แล้ว" + "(\\d++[.,]?\\d*+) นาทีที่ผ่านมา", + "(\\d++[.,]?\\d*+) นาทีที่แล้ว" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) เดือนที่ผ่านมา", - "(\\d+[.,]?\\d*) เดือนที่แล้ว" + "(\\d++[.,]?\\d*+) เดือนที่ผ่านมา", + "(\\d++[.,]?\\d*+) เดือนที่แล้ว" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) วินาทีที่ผ่านมา", - "(\\d+[.,]?\\d*) วินาทีที่แล้ว" + "(\\d++[.,]?\\d*+) วินาทีที่ผ่านมา", + "(\\d++[.,]?\\d*+) วินาทีที่แล้ว" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) สัปดาห์ที่ผ่านมา", - "(\\d+[.,]?\\d*) สัปดาห์ที่แล้ว" + "(\\d++[.,]?\\d*+) สัปดาห์ที่ผ่านมา", + "(\\d++[.,]?\\d*+) สัปดาห์ที่แล้ว" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) ปีที่แล้ว" + "(\\d++[.,]?\\d*+) ปีที่แล้ว" ], "in \\1 day": [ - "ใน (\\d+[.,]?\\d*) วัน", - "ในอีก (\\d+[.,]?\\d*) วัน" + "ใน (\\d++[.,]?\\d*+) วัน", + "ในอีก (\\d++[.,]?\\d*+) วัน" ], "in \\1 hour": [ - "ใน (\\d+[.,]?\\d*) ชม", - "ในอีก (\\d+[.,]?\\d*) ชั่วโมง" + "ใน (\\d++[.,]?\\d*+) ชม", + "ในอีก (\\d++[.,]?\\d*+) ชั่วโมง" ], "in \\1 minute": [ - "ใน (\\d+[.,]?\\d*) นาที", - "ในอีก (\\d+[.,]?\\d*) นาที" + "ใน (\\d++[.,]?\\d*+) นาที", + "ในอีก (\\d++[.,]?\\d*+) นาที" ], "in \\1 month": [ - "ใน (\\d+[.,]?\\d*) เดือน", - "ในอีก (\\d+[.,]?\\d*) เดือน" + "ใน (\\d++[.,]?\\d*+) เดือน", + "ในอีก (\\d++[.,]?\\d*+) เดือน" ], "in \\1 second": [ - "ใน (\\d+[.,]?\\d*) วินาที", - "ในอีก (\\d+[.,]?\\d*) วินาที" + "ใน (\\d++[.,]?\\d*+) วินาที", + "ในอีก (\\d++[.,]?\\d*+) วินาที" ], "in \\1 week": [ - "ใน (\\d+[.,]?\\d*) สัปดาห์", - "ในอีก (\\d+[.,]?\\d*) สัปดาห์" + "ใน (\\d++[.,]?\\d*+) สัปดาห์", + "ในอีก (\\d++[.,]?\\d*+) สัปดาห์" ], "in \\1 year": [ - "ใน (\\d+[.,]?\\d*) ปี", - "ในอีก (\\d+[.,]?\\d*) ปี" + "ใน (\\d++[.,]?\\d*+) ปี", + "ในอีก (\\d++[.,]?\\d*+) ปี" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/to.py b/dateparser/data/date_translation_data/to.py index ea4d3b411..05cb62fdf 100644 --- a/dateparser/data/date_translation_data/to.py +++ b/dateparser/data/date_translation_data/to.py @@ -156,46 +156,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "'aho 'e (\\d+[.,]?\\d*) kuo'osi" + "'aho 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 hour ago": [ - "houa 'e (\\d+[.,]?\\d*) kuo'osi" + "houa 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 minute ago": [ - "miniti 'e (\\d+[.,]?\\d*) kuo'osi" + "miniti 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 month ago": [ - "māhina 'e (\\d+[.,]?\\d*) kuo'osi" + "māhina 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 second ago": [ - "sekoni 'e (\\d+[.,]?\\d*) kuo'osi" + "sekoni 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 week ago": [ - "uike 'e (\\d+[.,]?\\d*) kuo'osi" + "uike 'e (\\d++[.,]?\\d*+) kuo'osi" ], "\\1 year ago": [ - "ta'u 'e (\\d+[.,]?\\d*) kuo'osi" + "ta'u 'e (\\d++[.,]?\\d*+) kuo'osi" ], "in \\1 day": [ - "'i he 'aho 'e (\\d+[.,]?\\d*)" + "'i he 'aho 'e (\\d++[.,]?\\d*+)" ], "in \\1 hour": [ - "'i he houa 'e (\\d+[.,]?\\d*)" + "'i he houa 'e (\\d++[.,]?\\d*+)" ], "in \\1 minute": [ - "'i he miniti 'e (\\d+[.,]?\\d*)" + "'i he miniti 'e (\\d++[.,]?\\d*+)" ], "in \\1 month": [ - "'i he māhina 'e (\\d+[.,]?\\d*)" + "'i he māhina 'e (\\d++[.,]?\\d*+)" ], "in \\1 second": [ - "'i he sekoni 'e (\\d+[.,]?\\d*)" + "'i he sekoni 'e (\\d++[.,]?\\d*+)" ], "in \\1 week": [ - "'i he uike 'e (\\d+[.,]?\\d*)" + "'i he uike 'e (\\d++[.,]?\\d*+)" ], "in \\1 year": [ - "'i he ta'u 'e (\\d+[.,]?\\d*)" + "'i he ta'u 'e (\\d++[.,]?\\d*+)" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/tr.py b/dateparser/data/date_translation_data/tr.py index 8688a4438..62c42fd1c 100644 --- a/dateparser/data/date_translation_data/tr.py +++ b/dateparser/data/date_translation_data/tr.py @@ -176,54 +176,54 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) gün önce" + "(\\d++[.,]?\\d*+) gün önce" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) sa önce", - "(\\d+[.,]?\\d*) saat önce" + "(\\d++[.,]?\\d*+) sa önce", + "(\\d++[.,]?\\d*+) saat önce" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) dakika önce", - "(\\d+[.,]?\\d*) dk önce" + "(\\d++[.,]?\\d*+) dakika önce", + "(\\d++[.,]?\\d*+) dk önce" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ay önce" + "(\\d++[.,]?\\d*+) ay önce" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) saniye önce", - "(\\d+[.,]?\\d*) sn önce" + "(\\d++[.,]?\\d*+) saniye önce", + "(\\d++[.,]?\\d*+) sn önce" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) hafta önce", - "(\\d+[.,]?\\d*) hf önce" + "(\\d++[.,]?\\d*+) hafta önce", + "(\\d++[.,]?\\d*+) hf önce" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) yıl önce" + "(\\d++[.,]?\\d*+) yıl önce" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) gün sonra" + "(\\d++[.,]?\\d*+) gün sonra" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) sa sonra", - "(\\d+[.,]?\\d*) saat sonra" + "(\\d++[.,]?\\d*+) sa sonra", + "(\\d++[.,]?\\d*+) saat sonra" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) dakika sonra", - "(\\d+[.,]?\\d*) dk sonra" + "(\\d++[.,]?\\d*+) dakika sonra", + "(\\d++[.,]?\\d*+) dk sonra" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ay sonra" + "(\\d++[.,]?\\d*+) ay sonra" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) saniye sonra", - "(\\d+[.,]?\\d*) sn sonra" + "(\\d++[.,]?\\d*+) saniye sonra", + "(\\d++[.,]?\\d*+) sn sonra" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) hafta sonra", - "(\\d+[.,]?\\d*) hf sonra" + "(\\d++[.,]?\\d*+) hafta sonra", + "(\\d++[.,]?\\d*+) hf sonra" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) yıl sonra" + "(\\d++[.,]?\\d*+) yıl sonra" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/ug.py b/dateparser/data/date_translation_data/ug.py index b55b8419b..6aacd554f 100644 --- a/dateparser/data/date_translation_data/ug.py +++ b/dateparser/data/date_translation_data/ug.py @@ -143,46 +143,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) كۈن ئىلگىرى" + "(\\d++[.,]?\\d*+) كۈن ئىلگىرى" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) سائەت ئىلگىرى" + "(\\d++[.,]?\\d*+) سائەت ئىلگىرى" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) مىنۇت ئىلگىرى" + "(\\d++[.,]?\\d*+) مىنۇت ئىلگىرى" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ئاي ئىلگىرى" + "(\\d++[.,]?\\d*+) ئاي ئىلگىرى" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) سېكۇنت ئىلگىرى" + "(\\d++[.,]?\\d*+) سېكۇنت ئىلگىرى" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ھەپتە ئىلگىرى" + "(\\d++[.,]?\\d*+) ھەپتە ئىلگىرى" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) يىل ئىلگىرى" + "(\\d++[.,]?\\d*+) يىل ئىلگىرى" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) كۈندىن كېيىن" + "(\\d++[.,]?\\d*+) كۈندىن كېيىن" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) سائەتتىن كېيىن" + "(\\d++[.,]?\\d*+) سائەتتىن كېيىن" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) مىنۇتتىن كېيىن" + "(\\d++[.,]?\\d*+) مىنۇتتىن كېيىن" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ئايدىن كېيىن" + "(\\d++[.,]?\\d*+) ئايدىن كېيىن" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) سېكۇنتتىن كېيىن" + "(\\d++[.,]?\\d*+) سېكۇنتتىن كېيىن" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ھەپتىدىن كېيىن" + "(\\d++[.,]?\\d*+) ھەپتىدىن كېيىن" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) يىلدىن كېيىن" + "(\\d++[.,]?\\d*+) يىلدىن كېيىن" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/uk.py b/dateparser/data/date_translation_data/uk.py index 4733942cf..94adb39b6 100644 --- a/dateparser/data/date_translation_data/uk.py +++ b/dateparser/data/date_translation_data/uk.py @@ -290,85 +290,85 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) д тому", - "(\\d+[.,]?\\d*) день тому", - "(\\d+[.,]?\\d*) дн тому", - "(\\d+[.,]?\\d*) дня тому" + "(\\d++[.,]?\\d*+) д тому", + "(\\d++[.,]?\\d*+) день тому", + "(\\d++[.,]?\\d*+) дн тому", + "(\\d++[.,]?\\d*+) дня тому" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) год тому", - "(\\d+[.,]?\\d*) години тому", - "(\\d+[.,]?\\d*) годину тому", - "(\\d+[.,]?\\d*) година тому" + "(\\d++[.,]?\\d*+) год тому", + "(\\d++[.,]?\\d*+) години тому", + "(\\d++[.,]?\\d*+) годину тому", + "(\\d++[.,]?\\d*+) година тому" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) хв тому", - "(\\d+[.,]?\\d*) хвилини тому", - "(\\d+[.,]?\\d*) хвилину тому", - "(\\d+[.,]?\\d*) хвилина тому" + "(\\d++[.,]?\\d*+) хв тому", + "(\\d++[.,]?\\d*+) хвилини тому", + "(\\d++[.,]?\\d*+) хвилину тому", + "(\\d++[.,]?\\d*+) хвилина тому" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) міс тому", - "(\\d+[.,]?\\d*) місяць тому", - "(\\d+[.,]?\\d*) місяця тому" + "(\\d++[.,]?\\d*+) міс тому", + "(\\d++[.,]?\\d*+) місяць тому", + "(\\d++[.,]?\\d*+) місяця тому" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) с тому", - "(\\d+[.,]?\\d*) секунди тому", - "(\\d+[.,]?\\d*) секунду тому", - "(\\d+[.,]?\\d*) секунда тому" + "(\\d++[.,]?\\d*+) с тому", + "(\\d++[.,]?\\d*+) секунди тому", + "(\\d++[.,]?\\d*+) секунду тому", + "(\\d++[.,]?\\d*+) секунда тому" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) тиж тому", - "(\\d+[.,]?\\d*) тиждень тому", - "(\\d+[.,]?\\d*) тижня тому" + "(\\d++[.,]?\\d*+) тиж тому", + "(\\d++[.,]?\\d*+) тиждень тому", + "(\\d++[.,]?\\d*+) тижня тому" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) р тому", - "(\\d+[.,]?\\d*) року тому", - "(\\d+[.,]?\\d*) рік тому" + "(\\d++[.,]?\\d*+) р тому", + "(\\d++[.,]?\\d*+) року тому", + "(\\d++[.,]?\\d*+) рік тому" ], "in \\1 day": [ - "за (\\d+[.,]?\\d*) д", - "через (\\d+[.,]?\\d*) день", - "через (\\d+[.,]?\\d*) дн", - "через (\\d+[.,]?\\d*) дня" + "за (\\d++[.,]?\\d*+) д", + "через (\\d++[.,]?\\d*+) день", + "через (\\d++[.,]?\\d*+) дн", + "через (\\d++[.,]?\\d*+) дня" ], "in \\1 hour": [ - "за (\\d+[.,]?\\d*) год", - "через (\\d+[.,]?\\d*) год", - "через (\\d+[.,]?\\d*) години", - "через (\\d+[.,]?\\d*) годину" + "за (\\d++[.,]?\\d*+) год", + "через (\\d++[.,]?\\d*+) год", + "через (\\d++[.,]?\\d*+) години", + "через (\\d++[.,]?\\d*+) годину" ], "in \\1 minute": [ - "за (\\d+[.,]?\\d*) хв", - "через (\\d+[.,]?\\d*) хв", - "через (\\d+[.,]?\\d*) хвилини", - "через (\\d+[.,]?\\d*) хвилину" + "за (\\d++[.,]?\\d*+) хв", + "через (\\d++[.,]?\\d*+) хв", + "через (\\d++[.,]?\\d*+) хвилини", + "через (\\d++[.,]?\\d*+) хвилину" ], "in \\1 month": [ - "за (\\d+[.,]?\\d*) міс", - "через (\\d+[.,]?\\d*) міс", - "через (\\d+[.,]?\\d*) місяць", - "через (\\d+[.,]?\\d*) місяця" + "за (\\d++[.,]?\\d*+) міс", + "через (\\d++[.,]?\\d*+) міс", + "через (\\d++[.,]?\\d*+) місяць", + "через (\\d++[.,]?\\d*+) місяця" ], "in \\1 second": [ - "за (\\d+[.,]?\\d*) с", - "через (\\d+[.,]?\\d*) с", - "через (\\d+[.,]?\\d*) секунди", - "через (\\d+[.,]?\\d*) секунду" + "за (\\d++[.,]?\\d*+) с", + "через (\\d++[.,]?\\d*+) с", + "через (\\d++[.,]?\\d*+) секунди", + "через (\\d++[.,]?\\d*+) секунду" ], "in \\1 week": [ - "за (\\d+[.,]?\\d*) тиж", - "через (\\d+[.,]?\\d*) тиж", - "через (\\d+[.,]?\\d*) тиждень", - "через (\\d+[.,]?\\d*) тижня" + "за (\\d++[.,]?\\d*+) тиж", + "через (\\d++[.,]?\\d*+) тиж", + "через (\\d++[.,]?\\d*+) тиждень", + "через (\\d++[.,]?\\d*+) тижня" ], "in \\1 year": [ - "за (\\d+[.,]?\\d*) р", - "через (\\d+[.,]?\\d*) р", - "через (\\d+[.,]?\\d*) року", - "через (\\d+[.,]?\\d*) рік" + "за (\\d++[.,]?\\d*+) р", + "через (\\d++[.,]?\\d*+) р", + "через (\\d++[.,]?\\d*+) року", + "через (\\d++[.,]?\\d*+) рік" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ur.py b/dateparser/data/date_translation_data/ur.py index c00110d60..0acb9671e 100644 --- a/dateparser/data/date_translation_data/ur.py +++ b/dateparser/data/date_translation_data/ur.py @@ -135,58 +135,58 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) دن پہلے", - "(\\d+[.,]?\\d*) دنوں پہلے" + "(\\d++[.,]?\\d*+) دن پہلے", + "(\\d++[.,]?\\d*+) دنوں پہلے" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) گھنٹہ پہلے", - "(\\d+[.,]?\\d*) گھنٹے پہلے" + "(\\d++[.,]?\\d*+) گھنٹہ پہلے", + "(\\d++[.,]?\\d*+) گھنٹے پہلے" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) منٹ پہلے" + "(\\d++[.,]?\\d*+) منٹ پہلے" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ماہ قبل", - "(\\d+[.,]?\\d*) ماہ پہلے", - "(\\d+[.,]?\\d*) مہینہ پہلے", - "(\\d+[.,]?\\d*) مہینے پہلے" + "(\\d++[.,]?\\d*+) ماہ قبل", + "(\\d++[.,]?\\d*+) ماہ پہلے", + "(\\d++[.,]?\\d*+) مہینہ پہلے", + "(\\d++[.,]?\\d*+) مہینے پہلے" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) سیکنڈ پہلے" + "(\\d++[.,]?\\d*+) سیکنڈ پہلے" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ہفتہ پہلے", - "(\\d+[.,]?\\d*) ہفتے پہلے" + "(\\d++[.,]?\\d*+) ہفتہ پہلے", + "(\\d++[.,]?\\d*+) ہفتے پہلے" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) سال پہلے" + "(\\d++[.,]?\\d*+) سال پہلے" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) دن میں", - "(\\d+[.,]?\\d*) دنوں میں" + "(\\d++[.,]?\\d*+) دن میں", + "(\\d++[.,]?\\d*+) دنوں میں" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) گھنٹوں میں", - "(\\d+[.,]?\\d*) گھنٹہ میں", - "(\\d+[.,]?\\d*) گھنٹے میں" + "(\\d++[.,]?\\d*+) گھنٹوں میں", + "(\\d++[.,]?\\d*+) گھنٹہ میں", + "(\\d++[.,]?\\d*+) گھنٹے میں" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) منٹ میں" + "(\\d++[.,]?\\d*+) منٹ میں" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ماہ میں", - "(\\d+[.,]?\\d*) مہینہ میں", - "(\\d+[.,]?\\d*) مہینے میں" + "(\\d++[.,]?\\d*+) ماہ میں", + "(\\d++[.,]?\\d*+) مہینہ میں", + "(\\d++[.,]?\\d*+) مہینے میں" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) سیکنڈ میں" + "(\\d++[.,]?\\d*+) سیکنڈ میں" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ہفتہ میں", - "(\\d+[.,]?\\d*) ہفتے میں" + "(\\d++[.,]?\\d*+) ہفتہ میں", + "(\\d++[.,]?\\d*+) ہفتے میں" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) سال میں" + "(\\d++[.,]?\\d*+) سال میں" ] }, "locale_specific": { @@ -211,30 +211,30 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) دن قبل" + "(\\d++[.,]?\\d*+) دن قبل" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) گھنٹہ قبل", - "(\\d+[.,]?\\d*) گھنٹے قبل" + "(\\d++[.,]?\\d*+) گھنٹہ قبل", + "(\\d++[.,]?\\d*+) گھنٹے قبل" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) منٹ قبل" + "(\\d++[.,]?\\d*+) منٹ قبل" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) سیکنڈ قبل" + "(\\d++[.,]?\\d*+) سیکنڈ قبل" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ہفتہ قبل", - "(\\d+[.,]?\\d*) ہفتے قبل" + "(\\d++[.,]?\\d*+) ہفتہ قبل", + "(\\d++[.,]?\\d*+) ہفتے قبل" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) سالوں پہلے" + "(\\d++[.,]?\\d*+) سالوں پہلے" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ہفتوں میں" + "(\\d++[.,]?\\d*+) ہفتوں میں" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) سالوں میں" + "(\\d++[.,]?\\d*+) سالوں میں" ] } } diff --git a/dateparser/data/date_translation_data/uz-Cyrl.py b/dateparser/data/date_translation_data/uz-Cyrl.py index 44c3d0974..3074a773b 100644 --- a/dateparser/data/date_translation_data/uz-Cyrl.py +++ b/dateparser/data/date_translation_data/uz-Cyrl.py @@ -150,46 +150,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) кун олдин" + "(\\d++[.,]?\\d*+) кун олдин" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) соат олдин" + "(\\d++[.,]?\\d*+) соат олдин" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) дақиқа олдин" + "(\\d++[.,]?\\d*+) дақиқа олдин" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) ой аввал" + "(\\d++[.,]?\\d*+) ой аввал" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) сония олдин" + "(\\d++[.,]?\\d*+) сония олдин" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) ҳафта олдин" + "(\\d++[.,]?\\d*+) ҳафта олдин" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) йил аввал" + "(\\d++[.,]?\\d*+) йил аввал" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) кундан сўнг" + "(\\d++[.,]?\\d*+) кундан сўнг" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) соатдан сўнг" + "(\\d++[.,]?\\d*+) соатдан сўнг" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) дақиқадан сўнг" + "(\\d++[.,]?\\d*+) дақиқадан сўнг" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) ойдан сўнг" + "(\\d++[.,]?\\d*+) ойдан сўнг" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) сониядан сўнг" + "(\\d++[.,]?\\d*+) сониядан сўнг" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) ҳафтадан сўнг" + "(\\d++[.,]?\\d*+) ҳафтадан сўнг" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) йилдан сўнг" + "(\\d++[.,]?\\d*+) йилдан сўнг" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/uz-Latn.py b/dateparser/data/date_translation_data/uz-Latn.py index 5435fafa0..d49fbf56d 100644 --- a/dateparser/data/date_translation_data/uz-Latn.py +++ b/dateparser/data/date_translation_data/uz-Latn.py @@ -156,46 +156,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) kun oldin" + "(\\d++[.,]?\\d*+) kun oldin" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) soat oldin" + "(\\d++[.,]?\\d*+) soat oldin" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) daqiqa oldin" + "(\\d++[.,]?\\d*+) daqiqa oldin" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) oy oldin" + "(\\d++[.,]?\\d*+) oy oldin" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) soniya oldin" + "(\\d++[.,]?\\d*+) soniya oldin" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) hafta oldin" + "(\\d++[.,]?\\d*+) hafta oldin" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) yil oldin" + "(\\d++[.,]?\\d*+) yil oldin" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) kundan keyin" + "(\\d++[.,]?\\d*+) kundan keyin" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) soatdan keyin" + "(\\d++[.,]?\\d*+) soatdan keyin" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) daqiqadan keyin" + "(\\d++[.,]?\\d*+) daqiqadan keyin" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) oydan keyin" + "(\\d++[.,]?\\d*+) oydan keyin" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) soniyadan keyin" + "(\\d++[.,]?\\d*+) soniyadan keyin" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) haftadan keyin" + "(\\d++[.,]?\\d*+) haftadan keyin" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) yildan keyin" + "(\\d++[.,]?\\d*+) yildan keyin" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/uz.py b/dateparser/data/date_translation_data/uz.py index 488e9cbdf..0ac605960 100644 --- a/dateparser/data/date_translation_data/uz.py +++ b/dateparser/data/date_translation_data/uz.py @@ -156,46 +156,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) kun oldin" + "(\\d++[.,]?\\d*+) kun oldin" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) soat oldin" + "(\\d++[.,]?\\d*+) soat oldin" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) daqiqa oldin" + "(\\d++[.,]?\\d*+) daqiqa oldin" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) oy oldin" + "(\\d++[.,]?\\d*+) oy oldin" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) soniya oldin" + "(\\d++[.,]?\\d*+) soniya oldin" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) hafta oldin" + "(\\d++[.,]?\\d*+) hafta oldin" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) yil oldin" + "(\\d++[.,]?\\d*+) yil oldin" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) kundan keyin" + "(\\d++[.,]?\\d*+) kundan keyin" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) soatdan keyin" + "(\\d++[.,]?\\d*+) soatdan keyin" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) daqiqadan keyin" + "(\\d++[.,]?\\d*+) daqiqadan keyin" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) oydan keyin" + "(\\d++[.,]?\\d*+) oydan keyin" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) soniyadan keyin" + "(\\d++[.,]?\\d*+) soniyadan keyin" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) haftadan keyin" + "(\\d++[.,]?\\d*+) haftadan keyin" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) yildan keyin" + "(\\d++[.,]?\\d*+) yildan keyin" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/vi.py b/dateparser/data/date_translation_data/vi.py index 10cfd5b94..3b9a5e51d 100644 --- a/dateparser/data/date_translation_data/vi.py +++ b/dateparser/data/date_translation_data/vi.py @@ -182,46 +182,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) ngày trước" + "(\\d++[.,]?\\d*+) ngày trước" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) giờ trước" + "(\\d++[.,]?\\d*+) giờ trước" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) phút trước" + "(\\d++[.,]?\\d*+) phút trước" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) tháng trước" + "(\\d++[.,]?\\d*+) tháng trước" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) giây trước" + "(\\d++[.,]?\\d*+) giây trước" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) tuần trước" + "(\\d++[.,]?\\d*+) tuần trước" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) năm trước" + "(\\d++[.,]?\\d*+) năm trước" ], "in \\1 day": [ - "sau (\\d+[.,]?\\d*) ngày nữa" + "sau (\\d++[.,]?\\d*+) ngày nữa" ], "in \\1 hour": [ - "sau (\\d+[.,]?\\d*) giờ nữa" + "sau (\\d++[.,]?\\d*+) giờ nữa" ], "in \\1 minute": [ - "sau (\\d+[.,]?\\d*) phút nữa" + "sau (\\d++[.,]?\\d*+) phút nữa" ], "in \\1 month": [ - "sau (\\d+[.,]?\\d*) tháng nữa" + "sau (\\d++[.,]?\\d*+) tháng nữa" ], "in \\1 second": [ - "sau (\\d+[.,]?\\d*) giây nữa" + "sau (\\d++[.,]?\\d*+) giây nữa" ], "in \\1 week": [ - "sau (\\d+[.,]?\\d*) tuần nữa" + "sau (\\d++[.,]?\\d*+) tuần nữa" ], "in \\1 year": [ - "sau (\\d+[.,]?\\d*) năm nữa" + "sau (\\d++[.,]?\\d*+) năm nữa" ] }, "locale_specific": {}, @@ -240,7 +240,7 @@ ], "simplifications": [ { - "(?:ngày|năm)\\s(\\d+[.,]?\\d*)": "\\1" + "(?:ngày|năm)\\s(\\d++[.,]?\\d*+)": "\\1" } ], "skip": [ diff --git a/dateparser/data/date_translation_data/wae.py b/dateparser/data/date_translation_data/wae.py index e24dd1176..c894ab959 100644 --- a/dateparser/data/date_translation_data/wae.py +++ b/dateparser/data/date_translation_data/wae.py @@ -153,57 +153,57 @@ }, "relative-type-regex": { "\\1 day ago": [ - "vor (\\d+[.,]?\\d*) tag", - "vor (\\d+[.,]?\\d*) täg" + "vor (\\d++[.,]?\\d*+) tag", + "vor (\\d++[.,]?\\d*+) täg" ], "\\1 hour ago": [ - "vor (\\d+[.,]?\\d*) stund", - "vor (\\d+[.,]?\\d*) stunde" + "vor (\\d++[.,]?\\d*+) stund", + "vor (\\d++[.,]?\\d*+) stunde" ], "\\1 minute ago": [ - "vor (\\d+[.,]?\\d*) minüta", - "vor (\\d+[.,]?\\d*) minüte" + "vor (\\d++[.,]?\\d*+) minüta", + "vor (\\d++[.,]?\\d*+) minüte" ], "\\1 month ago": [ - "vor (\\d+[.,]?\\d*) mánet" + "vor (\\d++[.,]?\\d*+) mánet" ], "\\1 second ago": [ - "vor (\\d+[.,]?\\d*) sekund", - "vor (\\d+[.,]?\\d*) sekunde" + "vor (\\d++[.,]?\\d*+) sekund", + "vor (\\d++[.,]?\\d*+) sekunde" ], "\\1 week ago": [ - "cor (\\d+[.,]?\\d*) wučä", - "vor (\\d+[.,]?\\d*) wuča" + "cor (\\d++[.,]?\\d*+) wučä", + "vor (\\d++[.,]?\\d*+) wuča" ], "\\1 year ago": [ - "cor (\\d+[.,]?\\d*) jár", - "vor (\\d+[.,]?\\d*) jár" + "cor (\\d++[.,]?\\d*+) jár", + "vor (\\d++[.,]?\\d*+) jár" ], "in \\1 day": [ - "i (\\d+[.,]?\\d*) tag", - "i (\\d+[.,]?\\d*) täg" + "i (\\d++[.,]?\\d*+) tag", + "i (\\d++[.,]?\\d*+) täg" ], "in \\1 hour": [ - "i (\\d+[.,]?\\d*) stund", - "i (\\d+[.,]?\\d*) stunde" + "i (\\d++[.,]?\\d*+) stund", + "i (\\d++[.,]?\\d*+) stunde" ], "in \\1 minute": [ - "i (\\d+[.,]?\\d*) minüta", - "i (\\d+[.,]?\\d*) minüte" + "i (\\d++[.,]?\\d*+) minüta", + "i (\\d++[.,]?\\d*+) minüte" ], "in \\1 month": [ - "i (\\d+[.,]?\\d*) mánet" + "i (\\d++[.,]?\\d*+) mánet" ], "in \\1 second": [ - "i (\\d+[.,]?\\d*) sekund", - "i (\\d+[.,]?\\d*) sekunde" + "i (\\d++[.,]?\\d*+) sekund", + "i (\\d++[.,]?\\d*+) sekunde" ], "in \\1 week": [ - "i (\\d+[.,]?\\d*) wuča", - "i (\\d+[.,]?\\d*) wučä" + "i (\\d++[.,]?\\d*+) wuča", + "i (\\d++[.,]?\\d*+) wučä" ], "in \\1 year": [ - "i (\\d+[.,]?\\d*) jár" + "i (\\d++[.,]?\\d*+) jár" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/yi.py b/dateparser/data/date_translation_data/yi.py index 6d10a8935..45544ec2c 100644 --- a/dateparser/data/date_translation_data/yi.py +++ b/dateparser/data/date_translation_data/yi.py @@ -142,22 +142,22 @@ }, "relative-type-regex": { "\\1 month ago": [ - "פֿאַר (\\d+[.,]?\\d*) חדשים", - "פֿאַר (\\d+[.,]?\\d*) חודש" + "פֿאַר (\\d++[.,]?\\d*+) חדשים", + "פֿאַר (\\d++[.,]?\\d*+) חודש" ], "\\1 year ago": [ - "פֿאַר (\\d+[.,]?\\d*) יאָר" + "פֿאַר (\\d++[.,]?\\d*+) יאָר" ], "in \\1 day": [ - "אין (\\d+[.,]?\\d*) טאָג אַרום", - "אין (\\d+[.,]?\\d*) טעג אַרום" + "אין (\\d++[.,]?\\d*+) טאָג אַרום", + "אין (\\d++[.,]?\\d*+) טעג אַרום" ], "in \\1 month": [ - "איבער (\\d+[.,]?\\d*) חדשים", - "איבער (\\d+[.,]?\\d*) חודש" + "איבער (\\d++[.,]?\\d*+) חדשים", + "איבער (\\d++[.,]?\\d*+) חודש" ], "in \\1 year": [ - "איבער (\\d+[.,]?\\d*) יאָר" + "איבער (\\d++[.,]?\\d*+) יאָר" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/yue.py b/dateparser/data/date_translation_data/yue.py index aabf0ec61..207726931 100644 --- a/dateparser/data/date_translation_data/yue.py +++ b/dateparser/data/date_translation_data/yue.py @@ -141,46 +141,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) 日前" + "(\\d++[.,]?\\d*+) 日前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) 小時前" + "(\\d++[.,]?\\d*+) 小時前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) 分鐘前" + "(\\d++[.,]?\\d*+) 分鐘前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) 個月前" + "(\\d++[.,]?\\d*+) 個月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) 秒前" + "(\\d++[.,]?\\d*+) 秒前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 個星期前" + "(\\d++[.,]?\\d*+) 個星期前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) 年前" + "(\\d++[.,]?\\d*+) 年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) 日後" + "(\\d++[.,]?\\d*+) 日後" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) 小時後" + "(\\d++[.,]?\\d*+) 小時後" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) 分鐘後" + "(\\d++[.,]?\\d*+) 分鐘後" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) 個月後" + "(\\d++[.,]?\\d*+) 個月後" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) 秒後" + "(\\d++[.,]?\\d*+) 秒後" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 個星期後" + "(\\d++[.,]?\\d*+) 個星期後" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) 年後" + "(\\d++[.,]?\\d*+) 年後" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/zh-Hans.py b/dateparser/data/date_translation_data/zh-Hans.py index af855eeaf..c92e9cbb1 100644 --- a/dateparser/data/date_translation_data/zh-Hans.py +++ b/dateparser/data/date_translation_data/zh-Hans.py @@ -163,48 +163,48 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*)天前" + "(\\d++[.,]?\\d*+)天前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*)小时前" + "(\\d++[.,]?\\d*+)小时前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*)分钟前" + "(\\d++[.,]?\\d*+)分钟前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*)个月前" + "(\\d++[.,]?\\d*+)个月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*)秒前", - "(\\d+[.,]?\\d*)秒钟前" + "(\\d++[.,]?\\d*+)秒前", + "(\\d++[.,]?\\d*+)秒钟前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*)周前" + "(\\d++[.,]?\\d*+)周前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*)年前" + "(\\d++[.,]?\\d*+)年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*)天后" + "(\\d++[.,]?\\d*+)天后" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*)小时后" + "(\\d++[.,]?\\d*+)小时后" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*)分钟后" + "(\\d++[.,]?\\d*+)分钟后" ], "in \\1 month": [ - "(\\d+[.,]?\\d*)个月后" + "(\\d++[.,]?\\d*+)个月后" ], "in \\1 second": [ - "(\\d+[.,]?\\d*)秒后", - "(\\d+[.,]?\\d*)秒钟后" + "(\\d++[.,]?\\d*+)秒后", + "(\\d++[.,]?\\d*+)秒钟后" ], "in \\1 week": [ - "(\\d+[.,]?\\d*)周后" + "(\\d++[.,]?\\d*+)周后" ], "in \\1 year": [ - "(\\d+[.,]?\\d*)年后" + "(\\d++[.,]?\\d*+)年后" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/zh-Hant.py b/dateparser/data/date_translation_data/zh-Hant.py index 9a51ecd32..16f7f3bee 100644 --- a/dateparser/data/date_translation_data/zh-Hant.py +++ b/dateparser/data/date_translation_data/zh-Hant.py @@ -141,46 +141,46 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) 天前" + "(\\d++[.,]?\\d*+) 天前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) 小時前" + "(\\d++[.,]?\\d*+) 小時前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) 分鐘前" + "(\\d++[.,]?\\d*+) 分鐘前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) 個月前" + "(\\d++[.,]?\\d*+) 個月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) 秒前" + "(\\d++[.,]?\\d*+) 秒前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 週前" + "(\\d++[.,]?\\d*+) 週前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) 年前" + "(\\d++[.,]?\\d*+) 年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) 天後" + "(\\d++[.,]?\\d*+) 天後" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*) 小時後" + "(\\d++[.,]?\\d*+) 小時後" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*) 分鐘後" + "(\\d++[.,]?\\d*+) 分鐘後" ], "in \\1 month": [ - "(\\d+[.,]?\\d*) 個月後" + "(\\d++[.,]?\\d*+) 個月後" ], "in \\1 second": [ - "(\\d+[.,]?\\d*) 秒後" + "(\\d++[.,]?\\d*+) 秒後" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 週後" + "(\\d++[.,]?\\d*+) 週後" ], "in \\1 year": [ - "(\\d+[.,]?\\d*) 年後" + "(\\d++[.,]?\\d*+) 年後" ] }, "locale_specific": { @@ -236,50 +236,50 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) 日前", - "(\\d+[.,]?\\d*)日前" + "(\\d++[.,]?\\d*+) 日前", + "(\\d++[.,]?\\d*+)日前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*)小時前" + "(\\d++[.,]?\\d*+)小時前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*)分前" + "(\\d++[.,]?\\d*+)分前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*)個月前" + "(\\d++[.,]?\\d*+)個月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*)秒前" + "(\\d++[.,]?\\d*+)秒前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 星期前", - "(\\d+[.,]?\\d*)週前" + "(\\d++[.,]?\\d*+) 星期前", + "(\\d++[.,]?\\d*+)週前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*)年前" + "(\\d++[.,]?\\d*+)年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) 日後", - "(\\d+[.,]?\\d*)日後" + "(\\d++[.,]?\\d*+) 日後", + "(\\d++[.,]?\\d*+)日後" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*)小時後" + "(\\d++[.,]?\\d*+)小時後" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*)分後" + "(\\d++[.,]?\\d*+)分後" ], "in \\1 month": [ - "(\\d+[.,]?\\d*)個月後" + "(\\d++[.,]?\\d*+)個月後" ], "in \\1 second": [ - "(\\d+[.,]?\\d*)秒後" + "(\\d++[.,]?\\d*+)秒後" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 星期後", - "(\\d+[.,]?\\d*)週後" + "(\\d++[.,]?\\d*+) 星期後", + "(\\d++[.,]?\\d*+)週後" ], "in \\1 year": [ - "(\\d+[.,]?\\d*)年後" + "(\\d++[.,]?\\d*+)年後" ] } }, @@ -335,50 +335,50 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) 日前", - "(\\d+[.,]?\\d*)日前" + "(\\d++[.,]?\\d*+) 日前", + "(\\d++[.,]?\\d*+)日前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*)小時前" + "(\\d++[.,]?\\d*+)小時前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*)分前" + "(\\d++[.,]?\\d*+)分前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*)個月前" + "(\\d++[.,]?\\d*+)個月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*)秒前" + "(\\d++[.,]?\\d*+)秒前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*) 星期前", - "(\\d+[.,]?\\d*)週前" + "(\\d++[.,]?\\d*+) 星期前", + "(\\d++[.,]?\\d*+)週前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*)年前" + "(\\d++[.,]?\\d*+)年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*) 日後", - "(\\d+[.,]?\\d*)日後" + "(\\d++[.,]?\\d*+) 日後", + "(\\d++[.,]?\\d*+)日後" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*)小時後" + "(\\d++[.,]?\\d*+)小時後" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*)分後" + "(\\d++[.,]?\\d*+)分後" ], "in \\1 month": [ - "(\\d+[.,]?\\d*)個月後" + "(\\d++[.,]?\\d*+)個月後" ], "in \\1 second": [ - "(\\d+[.,]?\\d*)秒後" + "(\\d++[.,]?\\d*+)秒後" ], "in \\1 week": [ - "(\\d+[.,]?\\d*) 星期後", - "(\\d+[.,]?\\d*)週後" + "(\\d++[.,]?\\d*+) 星期後", + "(\\d++[.,]?\\d*+)週後" ], "in \\1 year": [ - "(\\d+[.,]?\\d*)年後" + "(\\d++[.,]?\\d*+)年後" ] } } diff --git a/dateparser/data/date_translation_data/zh.py b/dateparser/data/date_translation_data/zh.py index 6a5ad288e..62b9d7caf 100644 --- a/dateparser/data/date_translation_data/zh.py +++ b/dateparser/data/date_translation_data/zh.py @@ -176,48 +176,48 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*)天前" + "(\\d++[.,]?\\d*+)天前" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*)小时前" + "(\\d++[.,]?\\d*+)小时前" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*)分钟前" + "(\\d++[.,]?\\d*+)分钟前" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*)个月前" + "(\\d++[.,]?\\d*+)个月前" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*)秒前", - "(\\d+[.,]?\\d*)秒钟前" + "(\\d++[.,]?\\d*+)秒前", + "(\\d++[.,]?\\d*+)秒钟前" ], "\\1 week ago": [ - "(\\d+[.,]?\\d*)周前" + "(\\d++[.,]?\\d*+)周前" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*)年前" + "(\\d++[.,]?\\d*+)年前" ], "in \\1 day": [ - "(\\d+[.,]?\\d*)天后" + "(\\d++[.,]?\\d*+)天后" ], "in \\1 hour": [ - "(\\d+[.,]?\\d*)小时后" + "(\\d++[.,]?\\d*+)小时后" ], "in \\1 minute": [ - "(\\d+[.,]?\\d*)分钟后" + "(\\d++[.,]?\\d*+)分钟后" ], "in \\1 month": [ - "(\\d+[.,]?\\d*)个月后" + "(\\d++[.,]?\\d*+)个月后" ], "in \\1 second": [ - "(\\d+[.,]?\\d*)秒后", - "(\\d+[.,]?\\d*)秒钟后" + "(\\d++[.,]?\\d*+)秒后", + "(\\d++[.,]?\\d*+)秒钟后" ], "in \\1 week": [ - "(\\d+[.,]?\\d*)周后" + "(\\d++[.,]?\\d*+)周后" ], "in \\1 year": [ - "(\\d+[.,]?\\d*)年后" + "(\\d++[.,]?\\d*+)年后" ] }, "locale_specific": {}, @@ -249,25 +249,25 @@ "半小时前": "30分前" }, { - "(?:中午|下午|(?:晚上?))(?:\\s*)(\\d+[.,]?\\d*)(?:\\s*):(?:\\s+|:)?(\\d+[.,]?\\d*)": "\\1:\\2 pm" + "(?:中午|下午|(?:晚上?))(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+)": "\\1:\\2 pm" }, { - "(?:上午|早上|凌晨)(?:\\s*)(\\d+[.,]?\\d*)(?:\\s*):(?:\\s+|:)?(\\d+[.,]?\\d*)": "\\1:\\2 am" + "(?:上午|早上|凌晨)(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+)": "\\1:\\2 am" }, { "中午": "12:00" }, { - "(\\d+[.,]?\\d*)年(?:\\s+)?(\\d+[.,]?\\d*)月(?:\\s+)?(\\d+[.,]?\\d*)日(?:\\s+)?(\\d+[.,]?\\d*)时(?:\\s+)?(\\d+[.,]?\\d*)分": "\\1-\\2-\\3 \\4:\\5" + "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日(?:\\s+)?(\\d++[.,]?\\d*+)时(?:\\s+)?(\\d++[.,]?\\d*+)分": "\\1-\\2-\\3 \\4:\\5" }, { - "(\\d+[.,]?\\d*)年(?:\\s+)?(\\d+[.,]?\\d*)月(?:\\s+)?(\\d{1,2})(?:日)?(?:\\s+)?(\\d{1,2})(?:点|:)(\\d{1,2})": "\\1-\\2-\\3 \\4:\\5" + "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d{1,2})(?:日)?(?:\\s+)?(\\d{1,2})(?:点|:)(\\d{1,2})": "\\1-\\2-\\3 \\4:\\5" }, { - "(\\d+[.,]?\\d*)年(?:\\s+)?(\\d+[.,]?\\d*)月(?:\\s+)?(\\d{1,2})(?:日)?": "\\1-\\2-\\3" + "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d{1,2})(?:日)?": "\\1-\\2-\\3" }, { - "(\\d+[.,]?\\d*)月(?=.*[前后])": "\\1 月" + "(\\d++[.,]?\\d*+)月(?=.*[前后])": "\\1 月" } ] } diff --git a/dateparser/data/date_translation_data/zu.py b/dateparser/data/date_translation_data/zu.py index 5c6c8d931..e608a7edb 100644 --- a/dateparser/data/date_translation_data/zu.py +++ b/dateparser/data/date_translation_data/zu.py @@ -154,28 +154,28 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d+[.,]?\\d*) izinsuku ezedlule", - "(\\d+[.,]?\\d*) usuku olwedlule" + "(\\d++[.,]?\\d*+) izinsuku ezedlule", + "(\\d++[.,]?\\d*+) usuku olwedlule" ], "\\1 hour ago": [ - "(\\d+[.,]?\\d*) amahora edlule", - "(\\d+[.,]?\\d*) ihora eledlule" + "(\\d++[.,]?\\d*+) amahora edlule", + "(\\d++[.,]?\\d*+) ihora eledlule" ], "\\1 minute ago": [ - "(\\d+[.,]?\\d*) amaminithi edlule", - "(\\d+[.,]?\\d*) iminithi eledlule" + "(\\d++[.,]?\\d*+) amaminithi edlule", + "(\\d++[.,]?\\d*+) iminithi eledlule" ], "\\1 month ago": [ - "(\\d+[.,]?\\d*) inyanga edlule", - "(\\d+[.,]?\\d*) izinyanga ezedlule" + "(\\d++[.,]?\\d*+) inyanga edlule", + "(\\d++[.,]?\\d*+) izinyanga ezedlule" ], "\\1 second ago": [ - "(\\d+[.,]?\\d*) amasekhondi edlule", - "(\\d+[.,]?\\d*) isekhondi eledlule" + "(\\d++[.,]?\\d*+) amasekhondi edlule", + "(\\d++[.,]?\\d*+) isekhondi eledlule" ], "\\1 year ago": [ - "(\\d+[.,]?\\d*) iminyaka edlule", - "(\\d+[.,]?\\d*) unyaka odlule" + "(\\d++[.,]?\\d*+) iminyaka edlule", + "(\\d++[.,]?\\d*+) unyaka odlule" ] }, "locale_specific": {}, diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 37596afae..a96136baf 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -10,7 +10,7 @@ from .timezone_parser import pop_tz_offset_from_string _UNITS = r"decade|year|month|week|day|hour|minute|second" -PATTERN = re.compile(r"([+-]?\s*\d+[.,]?\d*)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) +PATTERN = re.compile(r"([+-]?\s*\d++[.,]?\d*+)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) class FreshnessDateDataParser: diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index 7e71ef227..b888b31be 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -25,6 +25,11 @@ all_languages = set(cldr_languages).union(set(supplementary_languages)) RELATIVE_PATTERN = re.compile(r"\{0\}") +POSSESSIVE_DIGIT_PATTERN = re.compile(r"\\d\+\[\.,\]\?\\d\*") + + +def _make_possessive(s): + return POSSESSIVE_DIGIT_PATTERN.sub(r"\\d++[.,]?\\d*+", s) def _to_plain_types(obj): @@ -50,15 +55,26 @@ def _modify_relative_data(relative_data): modified_relative_data = {} for key, value in relative_data.items(): for i, string in enumerate(value): - string = RELATIVE_PATTERN.sub(r"(\\d+[.,]?\\d*)", string) + string = RELATIVE_PATTERN.sub(r"(\\d++[.,]?\\d*+)", string) + string = _make_possessive(string) value[i] = string modified_relative_data[key] = value return modified_relative_data +def _modify_simplifications(simplifications): + for simplification in simplifications: + for pattern in list(simplification.keys()): + new_pattern = _make_possessive(pattern) + if new_pattern != pattern: + simplification[new_pattern] = simplification.pop(pattern) + + def _modify_data(language_data): relative_data = language_data.get("relative-type-regex", {}) relative_data = _modify_relative_data(relative_data) + simplifications = language_data.get("simplifications", []) + _modify_simplifications(simplifications) locale_specific_data = language_data.get("locale_specific", {}) for _, info in locale_specific_data.items(): locale_relative_data = info.get("relative-type-regex", {}) diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 60672f0f7..ef1477e9c 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -2634,6 +2634,32 @@ def test_freshness_date_with_relative_base_future(self, date_string, date, time) self.then_date_is(date) self.then_time_is(time) + def test_long_digit_run_does_not_hang(self): + # Possessive quantifiers (\d++[.,]?\d*+) prevent quadratic backtracking. + # Without the fix, PATTERN.findall('9' * 3200) takes ~23 s; with it, ~0.02 s. + import time + from dateparser.freshness_date_parser import PATTERN + from dateparser.languages.dictionary import Dictionary + from dateparser.conf import settings + import dateparser.data.date_translation_data.en as en_data + + long_digits = "9" * 3200 + + start = time.monotonic() + PATTERN.findall(long_digits) + elapsed = time.monotonic() - start + self.assertLess(elapsed, 1.0, "PATTERN.findall backtracked on long digit run") + + d = Dictionary(en_data.info, settings) + split_re = d._get_split_relative_regex_cache() + + start = time.monotonic() + split_re.split(long_digits) + elapsed = time.monotonic() - start + self.assertLess( + elapsed, 1.0, "split_relative_regex backtracked on long digit run" + ) + def given_date_string(self, date_string): self.date_string = date_string From a049fd1cb93dbfb1dfba8e0ee57e0352fb433421 Mon Sep 17 00:00:00 2001 From: "Jeus (seungwoo-ji)" Date: Tue, 9 Jun 2026 17:02:52 +0900 Subject: [PATCH 035/107] Add Korean alternative date expressions (#1289) * feat: add alternative Korean date expressions * feat: update tests for Korean date expression variants --------- Co-authored-by: Serhii A Co-authored-by: Claude Opus 4.8 (1M context) --- dateparser/data/date_translation_data/ko.py | 15 ++++++++++----- .../date_translation_data/ko.yaml | 14 ++++++++++++++ tests/test_languages.py | 5 +++++ 3 files changed, 29 insertions(+), 5 deletions(-) create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ko.yaml diff --git a/dateparser/data/date_translation_data/ko.py b/dateparser/data/date_translation_data/ko.py index 841257fb7..c817bac83 100644 --- a/dateparser/data/date_translation_data/ko.py +++ b/dateparser/data/date_translation_data/ko.py @@ -96,7 +96,8 @@ ], "relative-type": { "0 day ago": [ - "오늘" + "오늘", + "금일" ], "0 hour ago": [ "현재 시간" @@ -117,7 +118,8 @@ "올해" ], "1 day ago": [ - "어제" + "어제", + "작일" ], "1 month ago": [ "지난달" @@ -129,7 +131,8 @@ "작년" ], "in 1 day": [ - "내일" + "내일", + "명일" ], "in 1 month": [ "다음 달" @@ -152,7 +155,8 @@ "(\\d++[.,]?\\d*+)분 전" ], "\\1 month ago": [ - "(\\d++[.,]?\\d*+)개월 전" + "(\\d++[.,]?\\d*+)개월 전", + "(\\d++[.,]?\\d*+)달 전" ], "\\1 second ago": [ "(\\d++[.,]?\\d*+)초 전" @@ -173,7 +177,8 @@ "(\\d++[.,]?\\d*+)분 후" ], "in \\1 month": [ - "(\\d++[.,]?\\d*+)개월 후" + "(\\d++[.,]?\\d*+)개월 후", + "(\\d++[.,]?\\d*+)달 후" ], "in \\1 second": [ "(\\d++[.,]?\\d*+)초 후" diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ko.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ko.yaml new file mode 100644 index 000000000..3f0688071 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ko.yaml @@ -0,0 +1,14 @@ +relative-type: + 0 day ago: + - 금일 + 1 day ago: + - 작일 + in 1 day: + - 명일 + +relative-type-regex: + \1 month ago: + - (\d+[.,]?\d*)달 전 + in \1 month: + - (\d+[.,]?\d*)달 후 + diff --git a/tests/test_languages.py b/tests/test_languages.py index e9870575a..17f5f5bf7 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1738,6 +1738,11 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("ko", "2분 후", "in 2 minute"), param("ko", "5년 전", "5 year ago"), param("ko", "다음 달", "in 1 month"), + param("ko", "금일", "0 day ago"), + param("ko", "작일", "1 day ago"), + param("ko", "명일", "in 1 day"), + param("ko", "3달 전", "3 month ago"), + param("ko", "2달 후", "in 2 month"), # ksb param("ksb", "keloi", "in 1 day"), param("ksb", "evi eo", "0 day ago"), From 08c78d3b8bcdd2f721dff8ffaf25de482fd696dd Mon Sep 17 00:00:00 2001 From: Serhii A Date: Mon, 15 Jun 2026 10:41:54 +0200 Subject: [PATCH 036/107] 1.4.1 release (#1337) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 1.4.1 release notes Co-Authored-By: Claude Fable 5 * Bump version: 1.4.0 → 1.4.1 --------- Co-authored-by: Claude Fable 5 --- HISTORY.rst | 47 ++++++++++++++++++++++++++++++++++++++++++ dateparser/__init__.py | 2 +- pyproject.toml | 2 +- 3 files changed, 49 insertions(+), 2 deletions(-) diff --git a/HISTORY.rst b/HISTORY.rst index f854f5767..f5eddaff5 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,6 +3,53 @@ History ======= +1.4.1 (2026-06-15) +------------------ + +Breaking changes: + +- Remove fastText language detection support: the ``fasttext`` extra is + dropped and ``detect_languages()`` now raises ``ImportError``. Migrate to + the ``langdetect`` extra, which also unblocks ``numpy`` 2.x compatibility + (#1315) + +Security fixes: + +- Make digit quantifiers possessive in the relative-date regexes to prevent + quadratic backtracking (ReDoS) on long digit runs (#1335) + +New features: + +- Add the ``USE_GIVEN_LANGUAGE_ORDER`` setting to try ``languages`` and + ``locales`` in the order given rather than by frequency (#789) + +Fixes: + +- Preserve explicit signs on individual components when parsing relative + dates that combine decades with years, such as "-1 decade +2 years" (#1330) +- Fall back to other provided languages in ``search_dates`` when the + detected language yields no dates (#1331) +- Parse relative date expressions with spaces between the sign and number, + such as "now - 2 hours" and "now + 1 day" (#1327) +- Use the parser-relative ``now`` for the current month when filling in + incomplete dates so the month and day stay consistent (#1332) +- Fix Norwegian Bokmål (``nb``) parsing of relative date expressions such + as "3 måneder siden" and "om 2 måneder" (#1334) +- Parse abbreviated English month expressions such as "1mon ago" and + "3mons ago" (#1329) +- Preserve surrounding whitespace when removing skip tokens during + translation to avoid spurious double spaces (#1324) + +Improvements: + +- Move project metadata and build configuration to ``pyproject.toml`` (#1311) +- Add alternative Korean date expressions for today, yesterday, tomorrow, + and "N months ago/later" (#1289) +- Expand Czech date translations with additional inflections, word numbers, + decade and century expressions, and clock phrases like "čtvrt na tři" + (#1325) +- Replace internal ``OrderedDict`` usage with the built-in ``dict`` (#1328) + 1.4.0 (2026-03-26) ------------------ diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 669317a0b..36e2b45fd 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,4 +1,4 @@ -__version__ = "1.4.0" +__version__ = "1.4.1" from .conf import apply_settings from .date import DateDataParser diff --git a/pyproject.toml b/pyproject.toml index c4e55aa5d..0600ea6e2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ requires = [ [project] name = "dateparser" -version = "1.4.0" +version = "1.4.1" description = "Date parsing library designed to parse dates from HTML pages" authors = [ { name = "Scrapinghub", email = "opensource@zyte.com" }, From eb111c2039a661949aacfb5b1f7096bdf9a55548 Mon Sep 17 00:00:00 2001 From: Robert Sokola <76487619+TheXer@users.noreply.github.com> Date: Mon, 22 Jun 2026 13:04:20 +0200 Subject: [PATCH 037/107] Improve Czech (cs) language data (#1172) (#1172) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add month locative/dative forms (lednu, únoru, březnu, dubnu, květnu, červnu, červenci, srpnu, říjnu, prosinci) for dates like "v lednu 2023" - Add July abbreviation "črv" - Fix "za měsíc/týden/rok" not parsing: add accusative simplification patterns (previous patterns only matched instrumental -em forms) - Add tests covering the new expressions Co-authored-by: Serhii A Co-authored-by: Claude Sonnet 4.6 (1M context) --- dateparser/data/date_translation_data/cs.py | 40 ++++++++++++++----- .../date_translation_data/cs.yaml | 22 ++++++++++ tests/test_languages.py | 6 +++ 3 files changed, 58 insertions(+), 10 deletions(-) diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index 0e21e416a..aaadcdf2b 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -4,45 +4,54 @@ "january": [ "led", "leden", - "ledna" + "ledna", + "lednu" ], "february": [ "úno", "únor", "února", - "únr" + "únr", + "únoru" ], "march": [ "bře", "březen", - "března" + "března", + "březnu" ], "april": [ "dub", "duben", - "dubna" + "dubna", + "dubnu" ], "may": [ "kvě", "květen", - "května" + "května", + "květnu" ], "june": [ "červen", "června", "čvn", - "Čer" + "Čer", + "červnu" ], "july": [ "července", "červenec", "čvc", - "Črc" + "Črc", + "červenci", + "črv" ], "august": [ "srp", "srpen", - "srpna" + "srpna", + "srpnu" ], "september": [ "zář", @@ -51,7 +60,8 @@ "october": [ "říj", "říjen", - "října" + "října", + "říjnu" ], "november": [ "lis", @@ -61,7 +71,8 @@ "december": [ "pro", "prosince", - "prosinec" + "prosinec", + "prosinci" ], "monday": [ "po", @@ -512,6 +523,15 @@ { "(?<=(za|před)\\s)den(em)\\b": "1 den" }, + { + "(?<=za\\s)týden\\b": "1 týden" + }, + { + "(?<=za\\s)měsíc\\b": "1 měsíc" + }, + { + "(?<=za\\s)rok\\b": "1 rok" + }, { "čtvrt\\s*hodin(y|u)": "15 minut" }, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml index 569841a6d..7697d5567 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml @@ -24,12 +24,30 @@ sunday: - Ned - Neděli +january: + - lednu february: - únr + - únoru +march: + - březnu +april: + - dubnu +may: + - květnu june: - Čer + - červnu july: - Črc + - červenci + - črv +august: + - srpnu +october: + - říjnu +december: + - prosinci year: - roků - roky @@ -176,6 +194,10 @@ simplifications: - '(?<=(za|před)\s)měsíc(em)\b': '1 měsíc' - '(?<=(za|před)\s)rok(em)\b': '1 rok' - '(?<=(za|před)\s)den(em)\b': '1 den' + # Accusative forms used with "za" (e.g. "za týden" = "in a week") + - '(?<=za\s)týden\b': '1 týden' + - '(?<=za\s)měsíc\b': '1 měsíc' + - '(?<=za\s)rok\b': '1 rok' # Fractions of hours (For relative time) - 'čtvrt\s*hodin(y|u)': 15 minut diff --git a/tests/test_languages.py b/tests/test_languages.py index 17f5f5bf7..7d8b35942 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1205,6 +1205,12 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("cs", "čtvrt na tři", "2:15"), param("cs", "zítra o půlnoci", "in 1 day 0:00"), param("cs", "v sedum třicet odpoledne", " 7 30 pm"), + param("cs", "za měsíc", "in 1 month"), + param("cs", "za týden", "in 1 week"), + param("cs", "za rok", "in 1 year"), + param("cs", "v lednu", " january"), + param("cs", "v červenci 2020", " july 2020"), + param("cs", "v únoru", " february"), # Chinese param("zh", "昨天", "1 day ago"), param("zh", "前天", "2 day ago"), From 33e913cbfa57bf1b0c86753ab527ccc2b6d0b9b2 Mon Sep 17 00:00:00 2001 From: Claudio Klingler Date: Tue, 23 Jun 2026 10:11:16 +0200 Subject: [PATCH 038/107] italian: support 'un ora fa', 'un'ora fa', 'oggi alle 11:00'. (#1049) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Improve Czech (cs) language data (#1172) - Add month locative/dative forms (lednu, únoru, březnu, dubnu, květnu, červnu, červenci, srpnu, říjnu, prosinci) for dates like "v lednu 2023" - Add July abbreviation "črv" - Fix "za měsíc/týden/rok" not parsing: add accusative simplification patterns (previous patterns only matched instrumental -em forms) - Add tests covering the new expressions Co-Authored-By: Claude Sonnet 4.6 (1M context) * italian: support 'un ora fa', 'un'ora fa', 'oggi alle 11:00'. Finishes PR #1049 and resolves conflicts with master: - Keep master's improved "(\d+[.,]?\d*)\s+ora" simplification and add a new one mapping "un ora"/"un'ora" to "1 ore". - Anchor the new simplification with word boundaries (\bun[' ]ora\b) so it no longer corrupts words such as "un orario" / "ciascun orario". - Add "alle" to the skip tokens so "oggi alle 11:00" parses as "oggi 11:00". - Regenerate it.py from it.yaml. - Drop an accidental duplicate test line from the original PR and add a regression test that locks in the word-boundary fix. Co-Authored-By: Serhii A Co-Authored-By: Claude Opus 4.8 (1M context) --------- Co-authored-by: Serhii A Co-authored-by: Claude Sonnet 4.6 (1M context) Co-authored-by: Serhii A --- dateparser/data/date_translation_data/it.py | 4 ++++ .../date_translation_data/it.yaml | 3 ++- tests/test_languages.py | 6 ++++++ 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/dateparser/data/date_translation_data/it.py b/dateparser/data/date_translation_data/it.py index 9dcdd4f6a..ef56aaeeb 100644 --- a/dateparser/data/date_translation_data/it.py +++ b/dateparser/data/date_translation_data/it.py @@ -254,6 +254,7 @@ "skip": [ "circa", "e", + "alle", " ", "'", ",", @@ -277,6 +278,9 @@ "simplifications": [ { "(\\d++[.,]?\\d*+)\\s+ora": "\\1 ore" + }, + { + "\\bun[' ]ora\\b": "1 ore" } ] } diff --git a/dateparser_data/supplementary_language_data/date_translation_data/it.yaml b/dateparser_data/supplementary_language_data/date_translation_data/it.yaml index 100f41217..f05e8fbdb 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/it.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/it.yaml @@ -1,4 +1,4 @@ -skip: ["circa", "e"] +skip: ["circa", "e", "alle"] sentence_splitter_group : 1 @@ -28,3 +28,4 @@ relative-type: simplifications: - (\d+[.,]?\d*)\s+ora: \1 ore + - \bun[' ]ora\b: 1 ore diff --git a/tests/test_languages.py b/tests/test_languages.py index 7d8b35942..88fcb1f4b 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1141,6 +1141,12 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("it", "oggi", "0 day ago"), param("it", "2 settimana fa", "2 week ago"), param("it", "2 anno fa", "2 year ago"), + param("it", "un ora fa", "1 hour ago"), + param("it", "un'ora fa", "1 hour ago"), + param("it", "oggi alle 11:00", "0 day ago 11:00"), + param("it", "oggi 11:00", "0 day ago 11:00"), + # "un'ora" simplification must not corrupt words like "orario" + param("it", "un orario", "un orario"), # Portuguese param("pt", "anteontem", "2 day ago"), param("pt", "ontem", "1 day ago"), From 273eb23e4263b3dbbfd6981fcf6f7c48bcb9d662 Mon Sep 17 00:00:00 2001 From: Vincent Gao Date: Fri, 26 Jun 2026 12:32:48 +0200 Subject: [PATCH 039/107] fix: %j (day of year) format directive ignored month/day in parse_with_formats (#1345) When a user-supplied date format contained %j (day of year), parse_with_formats incorrectly treated the parsed date as having no month and no day. This caused it to overwrite the correctly-parsed month and day with the current-date defaults instead of preserving what strptime extracted. Root cause: missing_day was computed as '"%d" not in date_format', missing %j (and %-j) as day-of-year directives. A successful strptime with %j always populates both the day and month fields (e.g. day 100 of 2023 = April 10). The pre-existing _get_missing_parts helper already listed %j in the day directive mapping but not in month. Fix: add %j and %-j to the month directive mapping in _get_missing_parts, and replace the ad-hoc missing_month/missing_day checks in parse_with_formats with _get_missing_parts, which is the authoritative source for this logic. Before: dateparser.parse("2023-100", date_formats=["%Y-%j"]) -> datetime(2023, 6, 25) # wrong: June 25 = today After: dateparser.parse("2023-100", date_formats=["%Y-%j"]) -> datetime(2023, 4, 10) # correct: day 100 of 2023 --- dateparser/date.py | 6 ++++-- dateparser/utils/__init__.py | 4 +++- tests/test_date.py | 28 ++++++++++++++++++++++++++++ 3 files changed, 35 insertions(+), 3 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index 094591707..cef23338b 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -14,6 +14,7 @@ from dateparser.parser import _parse_absolute, _parse_nospaces from dateparser.timezone_parser import pop_tz_offset_from_string from dateparser.utils import ( + _get_missing_parts, apply_timezone_from_settings, get_timezone_from_tz_string, set_correct_day_from_settings, @@ -187,8 +188,9 @@ def parse_with_formats(date_string, date_formats, settings): except ValueError: continue else: - missing_month = not any(m in date_format for m in ["%m", "%b", "%B"]) - missing_day = "%d" not in date_format + _missing = _get_missing_parts(date_format) + missing_month = "month" in _missing + missing_day = "day" in _missing if missing_month and missing_day: period = "year" date_obj = set_correct_month_from_settings(date_obj, settings) diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 023c5fbb3..ccbe9eac5 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -57,7 +57,9 @@ def _get_missing_parts(fmt): """ directive_mapping = { "day": ["%d", "%-d", "%j", "%-j"], - "month": ["%b", "%B", "%m", "%-m"], + # %j (day of year) encodes month implicitly: a successful strptime with %j always + # populates the month field, so %j should count as providing month information. + "month": ["%b", "%B", "%m", "%-m", "%j", "%-j"], "year": ["%y", "%-y", "%Y"], } diff --git a/tests/test_date.py b/tests/test_date.py index 7c8759b89..d2bd2987e 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -374,6 +374,34 @@ def test_should_parse_date(self, date_string, date_formats, expected_result): self.then_parsed_period_is("day") self.then_parsed_date_is(expected_result) + @parameterized.expand( + [ + param( + date_string="2023-100", + date_formats=["%Y-%j"], + expected_result=datetime(2023, 4, 10), + ), + param( + date_string="2024-060", + date_formats=["%Y-%j"], + expected_result=datetime(2024, 2, 29), + ), + param( + date_string="2023 060", + date_formats=["%Y %j"], + expected_result=datetime(2023, 3, 1), + ), + ] + ) + def test_should_parse_day_of_year_format( + self, date_string, date_formats, expected_result + ): + """Format %%j (day of year) should correctly set both month and day.""" + self.when_date_is_parsed_with_formats(date_string, date_formats) + self.then_date_was_parsed() + self.then_parsed_period_is("day") + self.then_parsed_date_is(expected_result) + @parameterized.expand( [ param( From 762dfff88a4b7ed003ddb1d0c7bf6055a621562b Mon Sep 17 00:00:00 2001 From: Adnan Awan Date: Wed, 8 Jul 2026 14:38:54 +0500 Subject: [PATCH 040/107] fix: Apply PREFER_DATES_FROM logic to custom date formats (Fixes #445) (#1342) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: Apply PREFER_DATES_FROM logic to custom date formats Fixes #445 - settings.PREFER_DATES_FROM setting now correctly applies when date_formats are explicitly specified with 2-digit year formats (%y). Previously, when date_formats were provided, the parser would bypass the PREFER_DATES_FROM logic and directly use strptime(), causing ambiguous 2-digit years to be interpreted in the wrong century. Changes: - Enhanced parse_with_formats() to detect 2-digit year formats (%y) - Apply year adjustment logic based on PREFER_DATES_FROM setting - Added comprehensive test coverage for date_formats + PREFER_DATES_FROM Test results: - All 24,056 existing tests pass - Added 5 new test cases covering various scenarios * fix: respect PREFER_DATES_FROM and RELATIVE_BASE in date_formats path (closes #445) When date_formats is provided, parse_with_formats() bypassed the PREFER_DATES_FROM setting entirely, always returning future-century dates for 2-digit year formats (%y). Changes: - Apply PREFER_DATES_FROM logic in parse_with_formats() for 2-digit year formats: subtract 100 years when preference is 'past' and the parsed date is in the future; add 100 years when preference is 'future' and the parsed date is in the past - Respect settings.RELATIVE_BASE as the reference point (matching the NLP path in parser.py), falling back to datetime.now(tz=utc) when unset - Use == instead of 'in' for PREFER_DATES_FROM string comparisons - Use datetime.now(tz=timezone.utc) consistently, replacing datetime.today() Tests: - Add 5 parameterised cases covering past/future preference with 2-digit years, and 4-digit year isolation - Add dedicated test asserting RELATIVE_BASE is honoured * fix: respect PREFER_DATES_FROM and RELATIVE_BASE in date_formats path (closes #445) - Add _apply_century_preference() helper to date.py, mirroring the _get_correct_leap_year pattern from parser.py for consistency. - Helper shifts 2-digit year dates ±100 years based on PREFER_DATES_FROM; on ValueError (Feb 29 → non-leap year) it finds the nearest valid leap year in the preferred direction using get_next/previous_leap_year. - parse_with_formats now uses RELATIVE_BASE (falling back to UTC now) for both the missing-year branch and the 2-digit-year branch. - Fix tz-aware RELATIVE_BASE crash: now is normalised to naive before comparison, preventing TypeError between offset-naive and offset-aware datetimes. - Add 8 regression tests pinned to RELATIVE_BASE=datetime(2026, 1, 1) to avoid time-bomb failures. --- dateparser/date.py | 45 +++++++++++- tests/test_date_parser.py | 143 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 185 insertions(+), 3 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index cef23338b..74806fea1 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -1,6 +1,6 @@ import collections from collections.abc import Set -from datetime import datetime, timedelta +from datetime import datetime, timedelta, timezone import regex as re from dateutil.relativedelta import relativedelta @@ -16,6 +16,8 @@ from dateparser.utils import ( _get_missing_parts, apply_timezone_from_settings, + get_next_leap_year, + get_previous_leap_year, get_timezone_from_tz_string, set_correct_day_from_settings, set_correct_month_from_settings, @@ -175,6 +177,37 @@ def get_date_from_timestamp(date_string, settings, negative=False): return date_obj +def _apply_century_preference(date_obj, now, prefer_from): + """Shift *date_obj* by ±100 years to satisfy PREFER_DATES_FROM. + + *now* is normalised to naive so a tz-aware RELATIVE_BASE does not raise + TypeError. When the shifted year falls on Feb 29 in a non-leap year, the + nearest valid leap year in the preferred direction is used — matching the + behaviour of the NLP path in ``parser.py``. + + Returns the adjusted datetime, or the original when no shift is needed. + """ + now_naive = now.replace(tzinfo=None) if now.tzinfo is not None else now + + if now_naive < date_obj and prefer_from == "past": + target_year = date_obj.year - 100 + elif now_naive >= date_obj and prefer_from == "future": + target_year = date_obj.year + 100 + else: + return date_obj + + try: + return date_obj.replace(year=target_year) + except ValueError: + # Feb 29 shifted into a non-leap year — find the nearest valid one + target_year = ( + get_next_leap_year(target_year) + if prefer_from == "future" + else get_previous_leap_year(target_year) + ) + return date_obj.replace(year=target_year) + + def parse_with_formats(date_string, date_formats, settings): """Parse with formats and return a dictionary with 'period' and 'obj_date'. @@ -204,9 +237,15 @@ def parse_with_formats(date_string, date_formats, settings): period = "month" date_obj = set_correct_day_from_settings(date_obj, settings) + now = settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( + tzinfo=None + ) if not ("%y" in date_format or "%Y" in date_format): - today = datetime.today() - date_obj = date_obj.replace(year=today.year) + date_obj = date_obj.replace(year=now.year) + elif "%y" in date_format and "%Y" not in date_format: + date_obj = _apply_century_preference( + date_obj, now, settings.PREFER_DATES_FROM + ) date_obj = apply_timezone_from_settings(date_obj, settings) diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 2233ec8d1..4bbf36c55 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1701,6 +1701,149 @@ def test_word_numbers_advanced(self, date_string, expected_delta, description): f"{description}: Expected {expected}, got {result}", ) + @parameterized.expand( + [ + # Test PREFER_DATES_FROM='past' with 2-digit year format (Issue #445) + param( + date_string="1/15/64", + date_format="%m/%d/%y", + prefer_from="past", + expected_year=1964, + description="PREFER_DATES_FROM='past' with 2-digit year", + ), + # Test PREFER_DATES_FROM='future' with 2-digit year format + param( + date_string="1/15/64", + date_format="%m/%d/%y", + prefer_from="future", + expected_year=2064, + description="PREFER_DATES_FROM='future' with 2-digit year", + ), + # Test with past date and prefer future + param( + date_string="1/15/24", + date_format="%m/%d/%y", + prefer_from="future", + expected_year=2124, + description="Past date (24) with PREFER_DATES_FROM='future'", + ), + # Test with future date and prefer past + param( + date_string="1/15/35", + date_format="%m/%d/%y", + prefer_from="past", + expected_year=1935, + description="Future date (35) with PREFER_DATES_FROM='past'", + ), + # Test 4-digit year format (should not apply PREFER_DATES_FROM adjustment) + param( + date_string="1/15/2050", + date_format="%m/%d/%Y", + prefer_from="past", + expected_year=2050, + description="4-digit year format ignores PREFER_DATES_FROM", + ), + ] + ) + def test_prefer_dates_from_with_date_formats( + self, + date_string, + date_format, + prefer_from, + expected_year, + description, + ): + """Test that PREFER_DATES_FROM setting works with date_formats parameter (Issue #445).""" + result = parse( + date_string, + date_formats=[date_format], + settings={ + "PREFER_DATES_FROM": prefer_from, + "RELATIVE_BASE": datetime(2026, 1, 1), + }, + ) + + self.assertIsNotNone(result, f"Failed to parse: {description}") + self.assertEqual( + expected_year, + result.year, + f"{description}: Expected year {expected_year}, got {result.year}", + ) + + def test_prefer_dates_from_with_date_formats_and_relative_base(self): + """Test that PREFER_DATES_FROM respects RELATIVE_BASE with date_formats.""" + # Use a relative base in the past (e.g., 1980-01-01) + # When parsing '1/15/64' with RELATIVE_BASE='1980-01-01' and PREFER_DATES_FROM='past', + # it should be interpreted as 1964 (past relative to 1980) + relative_base = datetime(1980, 1, 1) + result = parse( + "1/15/64", + date_formats=["%m/%d/%y"], + settings={ + "PREFER_DATES_FROM": "past", + "RELATIVE_BASE": relative_base, + }, + ) + + self.assertIsNotNone(result) + self.assertEqual( + 1964, + result.year, + f"RELATIVE_BASE not respected: Expected 1964, got {result.year}", + ) + + # Now test with a relative base in the future + # When parsing '1/15/64' with RELATIVE_BASE='2020-01-01' and PREFER_DATES_FROM='future', + # it should be interpreted as 2064 (future relative to 2020) + relative_base = datetime(2020, 1, 1) + result = parse( + "1/15/64", + date_formats=["%m/%d/%y"], + settings={ + "PREFER_DATES_FROM": "future", + "RELATIVE_BASE": relative_base, + }, + ) + + self.assertIsNotNone(result) + self.assertEqual( + 2064, + result.year, + f"RELATIVE_BASE not respected: Expected 2064, got {result.year}", + ) + + def test_prefer_dates_from_with_date_formats_tz_aware_relative_base(self): + """Test that a tz-aware RELATIVE_BASE does not crash (Bug #1 fix).""" + from datetime import timezone as tz + + result = parse( + "1/15/64", + date_formats=["%m/%d/%y"], + settings={ + "PREFER_DATES_FROM": "past", + "RELATIVE_BASE": datetime(1980, 1, 1, tzinfo=tz.utc), + }, + ) + self.assertIsNotNone(result) + self.assertEqual(1964, result.year) + + def test_prefer_dates_from_with_date_formats_feb29_non_leap(self): + """Test that Feb 29 shifted to a non-leap year finds the next valid leap year (Bug #2 fix).""" + # 2/29/00 parses as 2000-02-29; shifting +100 → 2100 which is not a leap year. + # _apply_century_preference finds the next valid leap year: 2104. + result = parse( + "2/29/00", + date_formats=["%m/%d/%y"], + settings={ + "PREFER_DATES_FROM": "future", + "RELATIVE_BASE": datetime(2026, 1, 1), + }, + ) + self.assertIsNotNone(result) + self.assertEqual(2104, result.year) + self.assertEqual(2, result.month) + self.assertEqual(29, result.day) + if __name__ == "__main__": unittest.main() From 93b3c63050a9399e6ab2cc8e80c1ced1dd330763 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 22 Jul 2026 10:59:27 +0200 Subject: [PATCH 041/107] Update CLDR data to 44.1.0 and add hour/duration support (#1343) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Update CLDR data to 44.1.0 and add hour/duration support - Upgrade CLDR source data from version 31.0.1 to 44.1.0: 288 new locales added, all existing locale JSONs updated in dateparser_data/cldr_language_data/date_translation_data/ - Add hour/duration unit to relative-type data for all locales - Regenerate all dateparser/data/date_translation_data/*.py from the new source data, keeping master's possessive-quantifier optimization in relative-type-regex patterns - Modernize dateparser_scripts/ to use pathlib.Path and unified cldr-json repository layout (utils.py, write_complete_data.py, get_cldr_data.py, order_languages.py) - Restore Ukrainian words removed by the CLDR upgrade (uk.yaml) - Update docs/supported_locales.rst and languages_info.py - Update 34 test inputs in test_languages.py to reflect CLDR 44.1.0 abbreviation/name changes (bs-Latn, ce, kl, qu, so, sr, sw, zu, am, as, brx, hy, ig, kok, mr, nn, de, eu, gu, mk, chr, bs-Cyrl) - Add /cldr-json/ to .gitignore Finishes PR #1216 (Gallaecio:cldr-update). Co-Authored-By: Claude Sonnet 4.6 (1M context) * Fix 7 regressions from CLDR 44.1.0 update - en.yaml: restore 'in {0} weeks time' and 'in {0} weeks\' time' patterns for 'in \1 week' that CLDR 44 dropped; regenerate en.py - af.yaml: restore 'sek' (second abbreviation) dropped by CLDR 44; regenerate af.py - en-US: CLDR 44 has no en-US.json (US settings merged into base en); add minimal en-US.json, regenerate en-US.py, add en-US back to languages_info.py locale list for 'en' - tests/test_freshness_date_parser.py: update Cherokee (chr) test input from uppercase to lowercase Cherokee encoding used by CLDR 44 patterns - tests/test_search.py: update Danish detection test to text that includes 'tirsdag' and 'januar' (distinctly Danish vs Swedish), since CLDR 44 sv.py changes caused the old text to be ambiguous Co-Authored-By: Claude Sonnet 4.6 (1M context) * Fix en-US locale name: add to en.yaml locale_specific section The en-US locale is loaded via en.py's locale_specific["en-US"] section, not as a standalone language file. Adding it to en.yaml ensures the locale_specific entry gets the correct name ("en-US") and date_order (MDY). Remove the standalone en-US.json that was added by mistake. Co-Authored-By: Claude Sonnet 4.6 (1M context) * Finalize CLDR 44 update: keep supported locale set and address review Regenerating the data files for CLDR 44 also produced ~144 new low-resource locales, but languages_info.py (the locale registry) was never regenerated, so those files were shipped unused (parse(locales=['ceb']) raised ValueError). Rather than expand the auto-detected language set in this data-refresh PR, keep the supported set identical to master and defer the new locales to a dedicated change. - order_languages.py: exclude the 144 new CLDR 44 locales via avoid_languages so generation stays limited to the already-supported set. - Regenerate data: drop the 144 unused locale files and their intermediate JSON; the 205 supported locales are byte-identical. - Restore ff-CM/ff-GN/ff-MR (dropped by CLDR 44, moved under ff-Latn): keep them registered and add supplementary ff.yaml so they resolve to the base `ff` data, preserving backwards compatibility. - languages_info.py and docs/supported_locales.rst: revert to master now that the supported set is unchanged (en-US stays in sorted order, ff keeps its locales). - Drop the unnecessary OrderedDict usage from the generation scripts: dict keeps insertion order on all supported Python versions and the output is sorted, so the generated data is byte-identical. - Add tests for the new hour/duration parsing (ca "2 hores") and ff-CM/GN/MR backwards compatibility. Co-Authored-By: Claude Fable 5 * Restore vocabulary dropped by CLDR 44 so original tests pass unchanged The CLDR 31->44 refresh silently dropped ~690 previously-recognized words/patterns across 87 languages (e.g. ru "5 д назад", de "nachm.", pt "há 5 mins", hi "5 मि पहले", mk "минатата година", da "tir"/"tor"). Restore all of them through supplementary_language_data YAMLs - the mechanism already used for uk/en/af/ff - so the update becomes purely additive: every form that parsed before still parses, plus ~1,800 new CLDR 44 forms. Excluded from the restore are 8 forms that CLDR corrected deliberately (dsb/hsb "now" is a November abbreviation, mk "недела" moved from week to sunday, hi "से" moved from second to skip, bg "с" moved from second to week, af "oor N minuut" was wrongly mapped to in-N-days/months, and ms "dalam N saat" was wrongly mapped to in-N-years). Revert all test-expectation edits back to master, keeping only the additive tests (ff-CM/ff-GN/ff-MR locales, ca standalone hour unit). Add "den" as a Danish skip word: CLDR 44 gave Swedish "den här veckan" style phrases, which made Danish text win-by-tie-break as "sv" in language detection. Danish dates routinely use "den" ("den 8. maj 1945"), so this restores correct detection and makes such strings parseable; the two Danish search_dates spans now include "den", like "de" in Spanish. Co-Authored-By: Claude Fable 5 --------- Co-authored-by: Claude Sonnet 4.6 (1M context) --- .gitignore | 3 + dateparser/data/__init__.py | 3 +- dateparser/data/date_translation_data/af.py | 41 +- dateparser/data/date_translation_data/agq.py | 1 + dateparser/data/date_translation_data/ak.py | 3 +- dateparser/data/date_translation_data/am.py | 7 +- dateparser/data/date_translation_data/ar.py | 1 + dateparser/data/date_translation_data/as.py | 73 ++- dateparser/data/date_translation_data/asa.py | 1 + dateparser/data/date_translation_data/ast.py | 3 +- .../data/date_translation_data/az-Cyrl.py | 3 +- dateparser/data/date_translation_data/bas.py | 1 + dateparser/data/date_translation_data/be.py | 17 +- dateparser/data/date_translation_data/bem.py | 1 + dateparser/data/date_translation_data/bez.py | 1 + dateparser/data/date_translation_data/bg.py | 13 +- dateparser/data/date_translation_data/bm.py | 1 + dateparser/data/date_translation_data/bn.py | 26 +- dateparser/data/date_translation_data/bo.py | 1 + dateparser/data/date_translation_data/br.py | 22 +- dateparser/data/date_translation_data/brx.py | 90 ++- .../data/date_translation_data/bs-Cyrl.py | 176 ++++-- .../data/date_translation_data/bs-Latn.py | 7 +- dateparser/data/date_translation_data/bs.py | 7 +- dateparser/data/date_translation_data/ca.py | 7 +- dateparser/data/date_translation_data/ce.py | 20 +- dateparser/data/date_translation_data/cgg.py | 1 + dateparser/data/date_translation_data/chr.py | 19 + dateparser/data/date_translation_data/ckb.py | 3 +- dateparser/data/date_translation_data/cs.py | 4 + dateparser/data/date_translation_data/cy.py | 15 +- dateparser/data/date_translation_data/da.py | 45 +- dateparser/data/date_translation_data/dav.py | 1 + dateparser/data/date_translation_data/de.py | 4 + dateparser/data/date_translation_data/dje.py | 3 +- dateparser/data/date_translation_data/dsb.py | 43 +- dateparser/data/date_translation_data/dua.py | 1 + dateparser/data/date_translation_data/dyo.py | 3 +- dateparser/data/date_translation_data/dz.py | 1 + dateparser/data/date_translation_data/ebu.py | 1 + dateparser/data/date_translation_data/ee.py | 3 +- dateparser/data/date_translation_data/el.py | 28 +- dateparser/data/date_translation_data/en.py | 567 ++++++++++++++---- dateparser/data/date_translation_data/eo.py | 3 +- dateparser/data/date_translation_data/es.py | 147 ++++- dateparser/data/date_translation_data/et.py | 27 +- dateparser/data/date_translation_data/eu.py | 15 +- dateparser/data/date_translation_data/ewo.py | 3 +- dateparser/data/date_translation_data/fa.py | 7 +- dateparser/data/date_translation_data/ff.py | 1 + dateparser/data/date_translation_data/fi.py | 1 + dateparser/data/date_translation_data/fil.py | 5 +- dateparser/data/date_translation_data/fo.py | 10 + dateparser/data/date_translation_data/fr.py | 1 + dateparser/data/date_translation_data/fur.py | 3 +- dateparser/data/date_translation_data/ga.py | 21 +- dateparser/data/date_translation_data/gd.py | 6 + dateparser/data/date_translation_data/gl.py | 65 +- dateparser/data/date_translation_data/gsw.py | 1 + dateparser/data/date_translation_data/gu.py | 4 +- dateparser/data/date_translation_data/guz.py | 3 +- dateparser/data/date_translation_data/gv.py | 3 +- dateparser/data/date_translation_data/ha.py | 71 ++- dateparser/data/date_translation_data/haw.py | 3 +- dateparser/data/date_translation_data/he.py | 14 +- dateparser/data/date_translation_data/hi.py | 60 +- dateparser/data/date_translation_data/hr.py | 3 +- dateparser/data/date_translation_data/hsb.py | 33 +- dateparser/data/date_translation_data/hu.py | 11 +- dateparser/data/date_translation_data/hy.py | 8 +- dateparser/data/date_translation_data/id.py | 30 +- dateparser/data/date_translation_data/ig.py | 25 +- dateparser/data/date_translation_data/ii.py | 1 + dateparser/data/date_translation_data/is.py | 9 +- dateparser/data/date_translation_data/it.py | 12 +- dateparser/data/date_translation_data/ja.py | 4 + dateparser/data/date_translation_data/jgo.py | 3 +- dateparser/data/date_translation_data/jmc.py | 1 + dateparser/data/date_translation_data/kab.py | 1 + dateparser/data/date_translation_data/kam.py | 1 + dateparser/data/date_translation_data/kde.py | 1 + dateparser/data/date_translation_data/kea.py | 8 +- dateparser/data/date_translation_data/khq.py | 3 +- dateparser/data/date_translation_data/ki.py | 1 + dateparser/data/date_translation_data/kl.py | 31 +- dateparser/data/date_translation_data/kln.py | 1 + dateparser/data/date_translation_data/km.py | 2 + dateparser/data/date_translation_data/kn.py | 3 +- dateparser/data/date_translation_data/ko.py | 6 +- dateparser/data/date_translation_data/kok.py | 103 +++- dateparser/data/date_translation_data/ks.py | 30 +- dateparser/data/date_translation_data/ksb.py | 1 + dateparser/data/date_translation_data/ksf.py | 3 +- dateparser/data/date_translation_data/ksh.py | 1 + dateparser/data/date_translation_data/kw.py | 3 +- dateparser/data/date_translation_data/ky.py | 1 + dateparser/data/date_translation_data/lag.py | 1 + dateparser/data/date_translation_data/lb.py | 3 +- dateparser/data/date_translation_data/lg.py | 1 + dateparser/data/date_translation_data/lkt.py | 3 +- dateparser/data/date_translation_data/ln.py | 1 + dateparser/data/date_translation_data/lo.py | 5 +- dateparser/data/date_translation_data/lrc.py | 1 + dateparser/data/date_translation_data/lt.py | 3 +- dateparser/data/date_translation_data/lu.py | 3 +- dateparser/data/date_translation_data/luo.py | 1 + dateparser/data/date_translation_data/luy.py | 1 + dateparser/data/date_translation_data/lv.py | 9 + dateparser/data/date_translation_data/mas.py | 1 + dateparser/data/date_translation_data/mer.py | 1 + dateparser/data/date_translation_data/mfe.py | 1 + dateparser/data/date_translation_data/mg.py | 1 + dateparser/data/date_translation_data/mgh.py | 1 + dateparser/data/date_translation_data/mgo.py | 3 +- dateparser/data/date_translation_data/mk.py | 33 +- dateparser/data/date_translation_data/mn.py | 14 +- dateparser/data/date_translation_data/mr.py | 29 +- dateparser/data/date_translation_data/ms.py | 8 +- dateparser/data/date_translation_data/mt.py | 60 +- dateparser/data/date_translation_data/mua.py | 3 +- dateparser/data/date_translation_data/naq.py | 1 + dateparser/data/date_translation_data/nb.py | 1 + dateparser/data/date_translation_data/nd.py | 1 + dateparser/data/date_translation_data/ne.py | 17 +- dateparser/data/date_translation_data/nl.py | 1 + dateparser/data/date_translation_data/nmg.py | 1 + dateparser/data/date_translation_data/nn.py | 57 ++ dateparser/data/date_translation_data/nnh.py | 3 +- dateparser/data/date_translation_data/nus.py | 1 + dateparser/data/date_translation_data/nyn.py | 1 + dateparser/data/date_translation_data/om.py | 3 +- dateparser/data/date_translation_data/or.py | 92 ++- dateparser/data/date_translation_data/os.py | 3 +- .../data/date_translation_data/pa-Arab.py | 1 + .../data/date_translation_data/pa-Guru.py | 3 +- dateparser/data/date_translation_data/pa.py | 3 +- dateparser/data/date_translation_data/pl.py | 13 +- dateparser/data/date_translation_data/ps.py | 116 +++- dateparser/data/date_translation_data/pt.py | 54 +- dateparser/data/date_translation_data/qu.py | 39 ++ dateparser/data/date_translation_data/rm.py | 26 +- dateparser/data/date_translation_data/rn.py | 1 + dateparser/data/date_translation_data/ro.py | 8 +- dateparser/data/date_translation_data/rof.py | 1 + dateparser/data/date_translation_data/ru.py | 38 +- dateparser/data/date_translation_data/rw.py | 4 +- dateparser/data/date_translation_data/rwk.py | 1 + dateparser/data/date_translation_data/saq.py | 1 + dateparser/data/date_translation_data/sbp.py | 1 + dateparser/data/date_translation_data/se.py | 115 +++- dateparser/data/date_translation_data/seh.py | 3 +- dateparser/data/date_translation_data/ses.py | 3 +- dateparser/data/date_translation_data/sg.py | 1 + .../data/date_translation_data/shi-Latn.py | 1 + .../data/date_translation_data/shi-Tfng.py | 1 + dateparser/data/date_translation_data/shi.py | 1 + dateparser/data/date_translation_data/si.py | 12 +- dateparser/data/date_translation_data/sk.py | 9 +- dateparser/data/date_translation_data/sl.py | 13 +- dateparser/data/date_translation_data/smn.py | 3 +- dateparser/data/date_translation_data/sn.py | 3 +- dateparser/data/date_translation_data/so.py | 154 ++++- dateparser/data/date_translation_data/sq.py | 21 +- .../data/date_translation_data/sr-Cyrl.py | 153 ++++- .../data/date_translation_data/sr-Latn.py | 153 ++++- dateparser/data/date_translation_data/sr.py | 26 +- dateparser/data/date_translation_data/sv.py | 24 +- dateparser/data/date_translation_data/sw.py | 4 +- dateparser/data/date_translation_data/ta.py | 5 +- dateparser/data/date_translation_data/te.py | 22 +- dateparser/data/date_translation_data/teo.py | 3 +- dateparser/data/date_translation_data/th.py | 6 +- dateparser/data/date_translation_data/ti.py | 75 ++- dateparser/data/date_translation_data/to.py | 39 +- dateparser/data/date_translation_data/tr.py | 7 +- dateparser/data/date_translation_data/twq.py | 3 +- dateparser/data/date_translation_data/tzm.py | 1 + dateparser/data/date_translation_data/ug.py | 1 + dateparser/data/date_translation_data/uk.py | 55 +- dateparser/data/date_translation_data/ur.py | 32 +- .../data/date_translation_data/uz-Arab.py | 3 +- .../data/date_translation_data/uz-Cyrl.py | 1 + .../data/date_translation_data/uz-Latn.py | 7 +- dateparser/data/date_translation_data/uz.py | 7 +- dateparser/data/date_translation_data/vun.py | 1 + dateparser/data/date_translation_data/wae.py | 3 +- dateparser/data/date_translation_data/xog.py | 3 +- dateparser/data/date_translation_data/yav.py | 1 + dateparser/data/date_translation_data/yi.py | 1 + dateparser/data/date_translation_data/yo.py | 97 ++- dateparser/data/date_translation_data/zgh.py | 1 + .../data/date_translation_data/zh-Hant.py | 28 +- dateparser/data/date_translation_data/zu.py | 1 + .../date_translation_data/af.json | 33 +- .../date_translation_data/agq.json | 1 + .../date_translation_data/ak.json | 3 +- .../date_translation_data/am.json | 11 +- .../date_translation_data/ar.json | 6 +- .../date_translation_data/as.json | 96 ++- .../date_translation_data/asa.json | 1 + .../date_translation_data/ast.json | 3 +- .../date_translation_data/az-Cyrl.json | 3 +- .../date_translation_data/az-Latn.json | 6 +- .../date_translation_data/az.json | 6 +- .../date_translation_data/bas.json | 1 + .../date_translation_data/be.json | 13 +- .../date_translation_data/bem.json | 1 + .../date_translation_data/bez.json | 1 + .../date_translation_data/bg.json | 9 +- .../date_translation_data/bm.json | 1 + .../date_translation_data/bn.json | 26 +- .../date_translation_data/bo.json | 1 + .../date_translation_data/br.json | 21 +- .../date_translation_data/brx.json | 121 +++- .../date_translation_data/bs-Cyrl.json | 101 ++-- .../date_translation_data/bs-Latn.json | 9 +- .../date_translation_data/bs.json | 9 +- .../date_translation_data/ca.json | 15 +- .../date_translation_data/ce.json | 30 +- .../date_translation_data/cgg.json | 1 + .../date_translation_data/chr.json | 33 +- .../date_translation_data/ckb.json | 3 +- .../date_translation_data/cs.json | 6 +- .../date_translation_data/cy.json | 16 +- .../date_translation_data/da.json | 40 +- .../date_translation_data/dav.json | 1 + .../date_translation_data/de.json | 8 +- .../date_translation_data/dje.json | 3 +- .../date_translation_data/dsb.json | 47 +- .../date_translation_data/dua.json | 1 + .../date_translation_data/dyo.json | 3 +- .../date_translation_data/dz.json | 1 + .../date_translation_data/ebu.json | 1 + .../date_translation_data/ee.json | 3 +- .../date_translation_data/el.json | 24 +- .../date_translation_data/en.json | 565 +++++++++++++---- .../date_translation_data/eo.json | 3 +- .../date_translation_data/es.json | 192 ++++-- .../date_translation_data/et.json | 27 +- .../date_translation_data/eu.json | 21 +- .../date_translation_data/ewo.json | 3 +- .../date_translation_data/fa.json | 4 +- .../date_translation_data/ff.json | 13 +- .../date_translation_data/fi.json | 1 + .../date_translation_data/fil.json | 5 +- .../date_translation_data/fo.json | 10 + .../date_translation_data/fr.json | 12 +- .../date_translation_data/fur.json | 3 +- .../date_translation_data/ga.json | 24 +- .../date_translation_data/gd.json | 8 +- .../date_translation_data/gl.json | 37 +- .../date_translation_data/gsw.json | 1 + .../date_translation_data/gu.json | 1 - .../date_translation_data/guz.json | 3 +- .../date_translation_data/gv.json | 3 +- .../date_translation_data/ha.json | 85 ++- .../date_translation_data/haw.json | 3 +- .../date_translation_data/he.json | 8 +- .../date_translation_data/hi.json | 54 +- .../date_translation_data/hr.json | 3 +- .../date_translation_data/hsb.json | 35 +- .../date_translation_data/hu.json | 11 +- .../date_translation_data/hy.json | 12 +- .../date_translation_data/id.json | 28 +- .../date_translation_data/ig.json | 42 +- .../date_translation_data/ii.json | 1 + .../date_translation_data/is.json | 8 +- .../date_translation_data/it.json | 8 +- .../date_translation_data/ja.json | 9 +- .../date_translation_data/jgo.json | 3 +- .../date_translation_data/jmc.json | 1 + .../date_translation_data/ka.json | 3 +- .../date_translation_data/kab.json | 1 + .../date_translation_data/kam.json | 1 + .../date_translation_data/kde.json | 1 + .../date_translation_data/kea.json | 9 +- .../date_translation_data/khq.json | 3 +- .../date_translation_data/ki.json | 1 + .../date_translation_data/kl.json | 51 +- .../date_translation_data/kln.json | 1 + .../date_translation_data/km.json | 2 + .../date_translation_data/kn.json | 3 +- .../date_translation_data/ko.json | 6 +- .../date_translation_data/kok.json | 136 +++-- .../date_translation_data/ks.json | 47 +- .../date_translation_data/ksb.json | 1 + .../date_translation_data/ksf.json | 3 +- .../date_translation_data/ksh.json | 1 + .../date_translation_data/kw.json | 3 +- .../date_translation_data/ky.json | 2 +- .../date_translation_data/lag.json | 1 + .../date_translation_data/lb.json | 3 +- .../date_translation_data/lg.json | 1 + .../date_translation_data/lkt.json | 3 +- .../date_translation_data/ln.json | 1 + .../date_translation_data/lo.json | 4 +- .../date_translation_data/lrc.json | 1 + .../date_translation_data/lt.json | 3 +- .../date_translation_data/lu.json | 3 +- .../date_translation_data/luo.json | 1 + .../date_translation_data/luy.json | 1 + .../date_translation_data/lv.json | 9 + .../date_translation_data/mas.json | 1 + .../date_translation_data/mer.json | 1 + .../date_translation_data/mfe.json | 1 + .../date_translation_data/mg.json | 1 + .../date_translation_data/mgh.json | 1 + .../date_translation_data/mgo.json | 3 +- .../date_translation_data/mk.json | 32 +- .../date_translation_data/mn.json | 18 +- .../date_translation_data/mr.json | 31 +- .../date_translation_data/ms.json | 17 +- .../date_translation_data/mt.json | 68 ++- .../date_translation_data/mua.json | 3 +- .../date_translation_data/naq.json | 1 + .../date_translation_data/nb.json | 6 +- .../date_translation_data/nd.json | 1 + .../date_translation_data/ne.json | 17 +- .../date_translation_data/nl.json | 1 + .../date_translation_data/nmg.json | 1 + .../date_translation_data/nn.json | 100 +-- .../date_translation_data/nnh.json | 3 +- .../date_translation_data/nus.json | 1 + .../date_translation_data/nyn.json | 1 + .../date_translation_data/om.json | 3 +- .../date_translation_data/or.json | 114 +++- .../date_translation_data/os.json | 3 +- .../date_translation_data/pa-Arab.json | 1 + .../date_translation_data/pa-Guru.json | 3 +- .../date_translation_data/pa.json | 3 +- .../date_translation_data/pl.json | 18 +- .../date_translation_data/ps.json | 144 ++++- .../date_translation_data/pt.json | 41 +- .../date_translation_data/qu.json | 77 +-- .../date_translation_data/rm.json | 30 +- .../date_translation_data/rn.json | 1 + .../date_translation_data/ro.json | 11 +- .../date_translation_data/rof.json | 1 + .../date_translation_data/ru.json | 37 +- .../date_translation_data/rw.json | 5 +- .../date_translation_data/rwk.json | 1 + .../date_translation_data/saq.json | 1 + .../date_translation_data/sbp.json | 1 + .../date_translation_data/se.json | 123 +++- .../date_translation_data/seh.json | 3 +- .../date_translation_data/ses.json | 3 +- .../date_translation_data/sg.json | 1 + .../date_translation_data/shi-Latn.json | 1 + .../date_translation_data/shi-Tfng.json | 1 + .../date_translation_data/shi.json | 1 + .../date_translation_data/si.json | 3 - .../date_translation_data/sk.json | 9 +- .../date_translation_data/sl.json | 13 +- .../date_translation_data/smn.json | 3 +- .../date_translation_data/sn.json | 3 +- .../date_translation_data/so.json | 178 ++++-- .../date_translation_data/sq.json | 15 +- .../date_translation_data/sr-Cyrl.json | 142 ++++- .../date_translation_data/sr-Latn.json | 142 ++++- .../date_translation_data/sr.json | 22 +- .../date_translation_data/sv.json | 24 +- .../date_translation_data/sw.json | 4 +- .../date_translation_data/ta.json | 6 +- .../date_translation_data/te.json | 18 +- .../date_translation_data/teo.json | 3 +- .../date_translation_data/th.json | 3 +- .../date_translation_data/ti.json | 99 ++- .../date_translation_data/to.json | 40 +- .../date_translation_data/tr.json | 9 +- .../date_translation_data/twq.json | 3 +- .../date_translation_data/tzm.json | 1 + .../date_translation_data/ug.json | 1 + .../date_translation_data/uk.json | 32 +- .../date_translation_data/ur.json | 30 +- .../date_translation_data/uz-Arab.json | 3 +- .../date_translation_data/uz-Cyrl.json | 1 + .../date_translation_data/uz-Latn.json | 4 +- .../date_translation_data/uz.json | 4 +- .../date_translation_data/vun.json | 1 + .../date_translation_data/wae.json | 3 +- .../date_translation_data/xog.json | 3 +- .../date_translation_data/yav.json | 1 + .../date_translation_data/yi.json | 1 + .../date_translation_data/yo.json | 108 +++- .../date_translation_data/yue.json | 21 +- .../date_translation_data/zgh.json | 1 + .../date_translation_data/zh-Hant.json | 20 +- .../date_translation_data/zu.json | 4 +- .../date_translation_data/af.yaml | 10 + .../date_translation_data/am.yaml | 6 + .../date_translation_data/ar.yaml | 6 +- .../date_translation_data/as.yaml | 42 ++ .../date_translation_data/az-Latn.yaml | 4 + .../date_translation_data/az.yaml | 4 + .../date_translation_data/be.yaml | 7 +- .../date_translation_data/bg.yaml | 4 +- .../date_translation_data/bn.yaml | 7 +- .../date_translation_data/br.yaml | 7 + .../date_translation_data/brx.yaml | 60 ++ .../date_translation_data/bs-Cyrl.yaml | 36 ++ .../date_translation_data/bs-Latn.yaml | 3 + .../date_translation_data/bs.yaml | 3 + .../date_translation_data/ca.yaml | 7 + .../date_translation_data/ce.yaml | 21 + .../date_translation_data/chr.yaml | 16 + .../date_translation_data/cy.yaml | 2 + .../date_translation_data/da.yaml | 18 +- .../date_translation_data/de.yaml | 6 +- .../date_translation_data/dsb.yaml | 9 + .../date_translation_data/el.yaml | 14 + .../date_translation_data/en.yaml | 8 + .../date_translation_data/es.yaml | 61 +- .../date_translation_data/eu.yaml | 13 + .../date_translation_data/fa.yaml | 5 +- .../date_translation_data/ff.yaml | 7 + .../date_translation_data/fil.yaml | 5 + .../date_translation_data/fr.yaml | 9 +- .../date_translation_data/ga.yaml | 11 + .../date_translation_data/gd.yaml | 5 + .../date_translation_data/gl.yaml | 38 ++ .../date_translation_data/gu.yaml | 3 + .../date_translation_data/ha.yaml | 29 + .../date_translation_data/he.yaml | 7 +- .../date_translation_data/hi.yaml | 21 +- .../date_translation_data/hsb.yaml | 5 + .../date_translation_data/hy.yaml | 9 + .../date_translation_data/id.yaml | 5 +- .../date_translation_data/ig.yaml | 34 ++ .../date_translation_data/is.yaml | 7 + .../date_translation_data/it.yaml | 6 +- .../date_translation_data/ja.yaml | 8 +- .../date_translation_data/ka.yaml | 4 +- .../date_translation_data/kea.yaml | 11 + .../date_translation_data/kl.yaml | 29 + .../date_translation_data/kok.yaml | 78 +++ .../date_translation_data/ks.yaml | 34 ++ .../date_translation_data/ky.yaml | 3 + .../date_translation_data/lo.yaml | 3 + .../date_translation_data/mk.yaml | 15 + .../date_translation_data/mn.yaml | 13 + .../date_translation_data/mr.yaml | 4 + .../date_translation_data/ms.yaml | 7 + .../date_translation_data/mt.yaml | 14 + .../date_translation_data/nb.yaml | 4 +- .../date_translation_data/ne.yaml | 18 + .../date_translation_data/nn.yaml | 61 ++ .../date_translation_data/or.yaml | 45 ++ .../date_translation_data/pl.yaml | 5 +- .../date_translation_data/ps.yaml | 57 ++ .../date_translation_data/pt.yaml | 11 +- .../date_translation_data/qu.yaml | 65 ++ .../date_translation_data/rm.yaml | 9 + .../date_translation_data/ro.yaml | 9 +- .../date_translation_data/ru.yaml | 13 +- .../date_translation_data/rw.yaml | 2 + .../date_translation_data/se.yaml | 20 + .../date_translation_data/si.yaml | 6 + .../date_translation_data/so.yaml | 77 +++ .../date_translation_data/sq.yaml | 4 + .../date_translation_data/sr-Cyrl.yaml | 26 + .../date_translation_data/sr-Latn.yaml | 26 + .../date_translation_data/sr.yaml | 8 + .../date_translation_data/sv.yaml | 11 +- .../date_translation_data/sw.yaml | 4 + .../date_translation_data/ta.yaml | 3 + .../date_translation_data/te.yaml | 4 + .../date_translation_data/th.yaml | 4 +- .../date_translation_data/ti.yaml | 53 ++ .../date_translation_data/to.yaml | 11 + .../date_translation_data/uk.yaml | 19 +- .../date_translation_data/ur.yaml | 5 + .../date_translation_data/uz-Latn.yaml | 3 + .../date_translation_data/uz.yaml | 3 + .../date_translation_data/yo.yaml | 25 + .../date_translation_data/yue.yaml | 16 +- .../date_translation_data/zh-Hant.yaml | 25 +- .../date_translation_data/zu.yaml | 2 + dateparser_scripts/get_cldr_data.py | 28 +- dateparser_scripts/order_languages.py | 161 ++++- dateparser_scripts/utils.py | 34 +- dateparser_scripts/write_complete_data.py | 30 +- tests/test_clean_api.py | 14 + tests/test_languages.py | 2 + tests/test_search.py | 6 +- 484 files changed, 7940 insertions(+), 1846 deletions(-) create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/af.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/am.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/as.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/az-Latn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/az.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/br.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/brx.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/bs-Latn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/bs.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ce.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/chr.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/cy.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/dsb.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/el.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/eu.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ff.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/fil.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ga.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/gd.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/gl.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/gu.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ha.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/hsb.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/hy.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ig.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/is.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/kea.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/kl.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/kok.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ks.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ky.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/lo.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/mk.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/mn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/mr.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ms.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/mt.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ne.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/nn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/or.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ps.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/qu.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/rm.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/rw.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/se.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/si.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/so.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sq.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sr-Cyrl.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sr-Latn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sr.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sw.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ta.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/te.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ti.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/to.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/ur.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/uz-Latn.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/uz.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/yo.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/zu.yaml diff --git a/.gitignore b/.gitignore index 669c9f718..9cadfbae5 100644 --- a/.gitignore +++ b/.gitignore @@ -50,5 +50,8 @@ docs/_build .idea .vscode/ +# CLDR +/cldr-json/ + # Other raw_data diff --git a/dateparser/data/__init__.py b/dateparser/data/__init__.py index 0bd6b7d25..d09e0eb7a 100644 --- a/dateparser/data/__init__.py +++ b/dateparser/data/__init__.py @@ -1,2 +1,3 @@ from dateparser.data import date_translation_data -from .languages_info import language_order, language_locale_dict + +from .languages_info import language_locale_dict, language_order diff --git a/dateparser/data/date_translation_data/af.py b/dateparser/data/date_translation_data/af.py index b3bf8a8e6..85e5c0258 100644 --- a/dateparser/data/date_translation_data/af.py +++ b/dateparser/data/date_translation_data/af.py @@ -109,8 +109,8 @@ ], "second": [ "s", - "sek", - "sekonde" + "sekonde", + "sek" ], "relative-type": { "0 day ago": [ @@ -123,39 +123,49 @@ "hierdie minuut" ], "0 month ago": [ + "hierdie md", "vandeesmaand" ], "0 second ago": [ "nou" ], "0 week ago": [ + "hierdie w", + "hierdie week", "vandeesweek" ], "0 year ago": [ + "hierdie j", "hierdie jaar" ], "1 day ago": [ "gister" ], "1 month ago": [ - "verlede maand" + "verlede maand", + "verlede md" ], "1 week ago": [ + "verlede w", "verlede week" ], "1 year ago": [ + "verlede j", "verlede jaar" ], "in 1 day": [ "môre" ], "in 1 month": [ - "volgende maand" + "volgende maand", + "volgende md" ], "in 1 week": [ + "volgende w", "volgende week" ], "in 1 year": [ + "volgende j", "volgende jaar" ] }, @@ -165,6 +175,7 @@ "(\\d++[.,]?\\d*+) dag gelede" ], "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) u gelede", "(\\d++[.,]?\\d*+) uur gelede" ], "\\1 minute ago": [ @@ -178,9 +189,10 @@ "(\\d++[.,]?\\d*+) md gelede" ], "\\1 second ago": [ - "(\\d++[.,]?\\d*+) sek gelede", + "(\\d++[.,]?\\d*+) s gelede", "(\\d++[.,]?\\d*+) sekonde gelede", - "(\\d++[.,]?\\d*+) sekondes gelede" + "(\\d++[.,]?\\d*+) sekondes gelede", + "(\\d++[.,]?\\d*+) sek gelede" ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) w gelede", @@ -188,28 +200,32 @@ "(\\d++[.,]?\\d*+) weke gelede" ], "\\1 year ago": [ + "(\\d++[.,]?\\d*+) j gelede", "(\\d++[.,]?\\d*+) jaar gelede" ], "in \\1 day": [ "oor (\\d++[.,]?\\d*+) dae", - "oor (\\d++[.,]?\\d*+) dag", - "oor (\\d++[.,]?\\d*+) minuut" + "oor (\\d++[.,]?\\d*+) dag" ], "in \\1 hour": [ + "oor (\\d++[.,]?\\d*+) u", "oor (\\d++[.,]?\\d*+) uur" ], "in \\1 minute": [ "oor (\\d++[.,]?\\d*+) min", + "oor (\\d++[.,]?\\d*+) minute", "oor (\\d++[.,]?\\d*+) minuut" ], "in \\1 month": [ - "oor (\\d++[.,]?\\d*+) md", - "oor (\\d++[.,]?\\d*+) minuut" + "oor (\\d++[.,]?\\d*+) maand", + "oor (\\d++[.,]?\\d*+) maande", + "oor (\\d++[.,]?\\d*+) md" ], "in \\1 second": [ - "oor (\\d++[.,]?\\d*+) sek", + "oor (\\d++[.,]?\\d*+) s", "oor (\\d++[.,]?\\d*+) sekonde", - "oor (\\d++[.,]?\\d*+) sekondes" + "oor (\\d++[.,]?\\d*+) sekondes", + "oor (\\d++[.,]?\\d*+) sek" ], "in \\1 week": [ "oor (\\d++[.,]?\\d*+) w", @@ -217,6 +233,7 @@ "oor (\\d++[.,]?\\d*+) weke" ], "in \\1 year": [ + "oor (\\d++[.,]?\\d*+) j", "oor (\\d++[.,]?\\d*+) jaar" ] }, diff --git a/dateparser/data/date_translation_data/agq.py b/dateparser/data/date_translation_data/agq.py index 06861dc06..ad62e132c 100644 --- a/dateparser/data/date_translation_data/agq.py +++ b/dateparser/data/date_translation_data/agq.py @@ -96,6 +96,7 @@ "utsuʔ" ], "hour": [ + "hr", "tàm" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ak.py b/dateparser/data/date_translation_data/ak.py index 22cba0a41..3ca6fe2de 100644 --- a/dateparser/data/date_translation_data/ak.py +++ b/dateparser/data/date_translation_data/ak.py @@ -96,7 +96,8 @@ "da" ], "hour": [ - "dɔnhwer" + "dɔnhwer", + "hr" ], "minute": [ "sema" diff --git a/dateparser/data/date_translation_data/am.py b/dateparser/data/date_translation_data/am.py index 8dd44c142..0d4a3f8ec 100644 --- a/dateparser/data/date_translation_data/am.py +++ b/dateparser/data/date_translation_data/am.py @@ -2,10 +2,14 @@ "name": "am", "date_order": "DMY", "january": [ + "ጃን", + "ጃንዋሪ", "ጃንዩ", "ጃንዩወሪ" ], "february": [ + "ፌብ", + "ፌብሩዋሪ", "ፌብሩ", "ፌብሩወሪ" ], @@ -86,7 +90,8 @@ "ቀን" ], "hour": [ - "ሰዓት" + "ሰዓት", + "ሰዓቶች" ], "minute": [ "ደቂቃ" diff --git a/dateparser/data/date_translation_data/ar.py b/dateparser/data/date_translation_data/ar.py index f5209bd43..ddb1a1d66 100644 --- a/dateparser/data/date_translation_data/ar.py +++ b/dateparser/data/date_translation_data/ar.py @@ -87,6 +87,7 @@ ], "hour": [ "الساعات", + "ساعات", "ساعة", "ساعات" ], diff --git a/dateparser/data/date_translation_data/as.py b/dateparser/data/date_translation_data/as.py index f97def63b..7da14320b 100644 --- a/dateparser/data/date_translation_data/as.py +++ b/dateparser/data/date_translation_data/as.py @@ -1,6 +1,6 @@ info = { "name": "as", - "date_order": "YMD", + "date_order": "DMY", "january": [ "জানু", "জানুৱাৰী" @@ -16,6 +16,7 @@ "এপ্ৰিল" ], "may": [ + "মে'", "মে" ], "june": [ @@ -29,6 +30,7 @@ "আগষ্ট" ], "september": [ + "ছেপ্তে", "ছেপ্তেম্বৰ", "সেপ্ট" ], @@ -37,10 +39,12 @@ "অক্টোবৰ" ], "november": [ - "নভে", - "নৱেম্বৰ" + "নৱে", + "নৱেম্বৰ", + "নভে" ], "december": [ + "ডিচে", "ডিচেম্বৰ", "ডিসে" ], @@ -57,6 +61,8 @@ "বুধবাৰ" ], "thursday": [ + "বৃহ", + "বৃহস্পতিবাৰ", "বৃহষ্পতি", "বৃহষ্পতিবাৰ" ], @@ -69,13 +75,16 @@ "শনিবাৰ" ], "sunday": [ + "দেও", "দেওবাৰ", "ৰবি" ], "am": [ + "পূৰ্বাহ্ন", "পূৰ্বাহ্ণ" ], "pm": [ + "অপৰাহ্ন", "অপৰাহ্ণ" ], "year": [ @@ -104,48 +113,106 @@ "আজি" ], "0 hour ago": [ + "এইটো ঘণ্টাত", "this hour" ], "0 minute ago": [ + "এইটো মিনিটত", "this minute" ], "0 month ago": [ + "এই মা", + "এই মাহ", "this month" ], "0 second ago": [ + "এতিয়া", "now" ], "0 week ago": [ + "এই সপ্তাহ", "this week" ], "0 year ago": [ + "এই বছৰ", "this year" ], "1 day ago": [ "কালি" ], "1 month ago": [ + "যোৱা মা", + "যোৱা মাহ", "last month" ], "1 week ago": [ + "যোৱা সপ্তাহ", "last week" ], "1 year ago": [ + "যোৱা বছৰ", "last year" ], "in 1 day": [ "কাইলৈ" ], "in 1 month": [ + "অহা মাহ", "next month" ], "in 1 week": [ + "অহা সপ্তাহ", "next week" ], "in 1 year": [ + "অহা বছৰ", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) দিন পূৰ্বে" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) ঘণ্টা পূৰ্বে" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) মিনিট পূৰ্বে" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) মাহ পূৰ্বে" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) ছেকেণ্ড পূৰ্বে" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) সপ্তাহ পূৰ্বে" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) বছৰৰ পূৰ্বে" + ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) দিনত" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) ঘণ্টাত" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) মিনিটত" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) মাহত" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) ছেকেণ্ডত" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) সপ্তাহত" + ], + "in \\1 year": [ + "(\\d++[.,]?\\d*+) বছৰত" + ] + }, "locale_specific": {}, "skip": [ " ", diff --git a/dateparser/data/date_translation_data/asa.py b/dateparser/data/date_translation_data/asa.py index fdbbc3350..ebcaa1e2f 100644 --- a/dateparser/data/date_translation_data/asa.py +++ b/dateparser/data/date_translation_data/asa.py @@ -95,6 +95,7 @@ "thiku" ], "hour": [ + "hr", "thaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ast.py b/dateparser/data/date_translation_data/ast.py index a4dd66a42..222cef83d 100644 --- a/dateparser/data/date_translation_data/ast.py +++ b/dateparser/data/date_translation_data/ast.py @@ -114,7 +114,8 @@ ], "hour": [ "h", - "hora" + "hora", + "hores" ], "minute": [ "m", diff --git a/dateparser/data/date_translation_data/az-Cyrl.py b/dateparser/data/date_translation_data/az-Cyrl.py index 728d4c804..ce452d54b 100644 --- a/dateparser/data/date_translation_data/az-Cyrl.py +++ b/dateparser/data/date_translation_data/az-Cyrl.py @@ -95,7 +95,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/bas.py b/dateparser/data/date_translation_data/bas.py index d66975bbf..6bafffb58 100644 --- a/dateparser/data/date_translation_data/bas.py +++ b/dateparser/data/date_translation_data/bas.py @@ -96,6 +96,7 @@ "kɛl" ], "hour": [ + "hr", "ŋgɛŋ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/be.py b/dateparser/data/date_translation_data/be.py index e44a2083c..2706fccd6 100644 --- a/dateparser/data/date_translation_data/be.py +++ b/dateparser/data/date_translation_data/be.py @@ -143,6 +143,7 @@ "гадз", "гадзіна", "гадзіны", + "гадзіны", "гадзіну", "гадзін" ], @@ -174,12 +175,14 @@ "у гэту хвіліну" ], "0 month ago": [ + "у гэтым мес", "у гэтым месяцы" ], "0 second ago": [ "цяпер" ], "0 week ago": [ + "на гэтым тыд", "на гэтым тыдні" ], "0 year ago": [ @@ -190,24 +193,30 @@ "ўчора" ], "1 month ago": [ + "у мін мес", "у мінулым месяцы" ], "1 week ago": [ + "на мін тыд", "на мінулым тыдні" ], "1 year ago": [ + "у мін годзе", "у мінулым годзе" ], "in 1 day": [ "заўтра" ], "in 1 month": [ + "у наст мес", "у наступным месяцы" ], "in 1 week": [ + "на наст тыд", "на наступным тыдні" ], "in 1 year": [ + "у наст годзе", "у наступным годзе" ], "2 day ago": [ @@ -216,9 +225,9 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d++[.,]?\\d*+) д таму", "(\\d++[.,]?\\d*+) дзень таму", - "(\\d++[.,]?\\d*+) дня таму" + "(\\d++[.,]?\\d*+) дня таму", + "(\\d++[.,]?\\d*+) д таму" ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) гадз таму", @@ -251,9 +260,9 @@ "(\\d++[.,]?\\d*+) года таму" ], "in \\1 day": [ - "праз (\\d++[.,]?\\d*+) д", "праз (\\d++[.,]?\\d*+) дзень", - "праз (\\d++[.,]?\\d*+) дня" + "праз (\\d++[.,]?\\d*+) дня", + "праз (\\d++[.,]?\\d*+) д" ], "in \\1 hour": [ "праз (\\d++[.,]?\\d*+) гадз", diff --git a/dateparser/data/date_translation_data/bem.py b/dateparser/data/date_translation_data/bem.py index 6b8d2b6bd..8edb5aef6 100644 --- a/dateparser/data/date_translation_data/bem.py +++ b/dateparser/data/date_translation_data/bem.py @@ -88,6 +88,7 @@ "ubushiku" ], "hour": [ + "hr", "insa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/bez.py b/dateparser/data/date_translation_data/bez.py index 476edab59..be114631b 100644 --- a/dateparser/data/date_translation_data/bez.py +++ b/dateparser/data/date_translation_data/bez.py @@ -96,6 +96,7 @@ "sihu" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/bg.py b/dateparser/data/date_translation_data/bg.py index e52b1ec18..5fad8d1a0 100644 --- a/dateparser/data/date_translation_data/bg.py +++ b/dateparser/data/date_translation_data/bg.py @@ -93,15 +93,17 @@ ], "year": [ "г", + "год", "година", "год", "години" ], "month": [ - "м", + "мес", "месец", "мес", - "месеци" + "месеци", + "м" ], "week": [ "седм", @@ -119,6 +121,7 @@ "hour": [ "ч", "час", + "часове", "часа" ], "minute": [ @@ -127,7 +130,7 @@ "минути" ], "second": [ - "с", + "сек", "секунда", "сек", "секунди" @@ -170,9 +173,9 @@ ], "1 week ago": [ "мин седм", - "миналата седмица", "предходната седмица", - "преди седмица" + "преди седмица", + "миналата седмица" ], "1 year ago": [ "мин г", diff --git a/dateparser/data/date_translation_data/bm.py b/dateparser/data/date_translation_data/bm.py index 6cadd73c7..396377dbc 100644 --- a/dateparser/data/date_translation_data/bm.py +++ b/dateparser/data/date_translation_data/bm.py @@ -94,6 +94,7 @@ "don" ], "hour": [ + "hr", "lɛrɛ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/bn.py b/dateparser/data/date_translation_data/bn.py index e8fccfde6..f2c2c1054 100644 --- a/dateparser/data/date_translation_data/bn.py +++ b/dateparser/data/date_translation_data/bn.py @@ -15,6 +15,7 @@ "মার্চ" ], "april": [ + "এপ্রি", "এপ্রিল" ], "may": [ @@ -24,21 +25,27 @@ "জুন" ], "july": [ + "জুল", "জুলাই" ], "august": [ + "আগ", "আগস্ট" ], "september": [ + "সেপ", "সেপ্টেম্বর" ], "october": [ + "অক্টো", "অক্টোবর" ], "november": [ + "নভে", "নভেম্বর" ], "december": [ + "ডিসে", "ডিসেম্বর" ], "monday": [ @@ -54,9 +61,9 @@ "বুধবার" ], "thursday": [ - "বৃহষ্পতিবার", "বৃহস্পতি", - "বৃহস্পতিবার" + "বৃহস্পতিবার", + "বৃহষ্পতিবার" ], "friday": [ "শুক্র", @@ -91,6 +98,7 @@ "দিন" ], "hour": [ + "ঘণ্টা", "ঘন্টা" ], "minute": [ @@ -200,7 +208,19 @@ }, "locale_specific": { "bn-IN": { - "name": "bn-IN" + "name": "bn-IN", + "september": [ + "সেপ্টেঃ" + ], + "october": [ + "অক্টোঃ" + ], + "november": [ + "নভেঃ" + ], + "december": [ + "ডিসেঃ" + ] } }, "skip": [ diff --git a/dateparser/data/date_translation_data/bo.py b/dateparser/data/date_translation_data/bo.py index b805577b6..1b5d9b9a2 100644 --- a/dateparser/data/date_translation_data/bo.py +++ b/dateparser/data/date_translation_data/bo.py @@ -108,6 +108,7 @@ "ཉིན།" ], "hour": [ + "hr", "ཆུ་ཚོད་" ], "minute": [ diff --git a/dateparser/data/date_translation_data/br.py b/dateparser/data/date_translation_data/br.py index 1d3755a81..dcd406e25 100644 --- a/dateparser/data/date_translation_data/br.py +++ b/dateparser/data/date_translation_data/br.py @@ -1,6 +1,6 @@ info = { "name": "br", - "date_order": "YMD", + "date_order": "DMY", "january": [ "gen", "genver" @@ -42,9 +42,9 @@ "du" ], "december": [ - "ker", "kerzu", - "kzu" + "kzu", + "ker" ], "monday": [ "lun" @@ -78,13 +78,16 @@ "gm" ], "year": [ + "b", "bl", "bloaz" ], "month": [ + "m", "miz" ], "week": [ + "sizh", "sizhun" ], "day": [ @@ -93,7 +96,8 @@ ], "hour": [ "e", - "eur" + "eur", + "eurioù" ], "minute": [ "min", @@ -108,12 +112,15 @@ "hiziv" ], "0 hour ago": [ + "d'an eur-mañ", "this hour" ], "0 minute ago": [ + "ar munut-mañ", "this minute" ], "0 month ago": [ + "ar m-mañ", "ar miz-mañ" ], "0 second ago": [ @@ -121,6 +128,7 @@ "bremañ" ], "0 week ago": [ + "ar sizh-mañ", "ar sizhun-mañ" ], "0 year ago": [ @@ -130,9 +138,11 @@ "dec'h" ], "1 month ago": [ + "ar m diaraok", "ar miz diaraok" ], "1 week ago": [ + "ar sizh diaraok", "ar sizhun diaraok" ], "1 year ago": [ @@ -142,9 +152,11 @@ "warc'hoazh" ], "in 1 month": [ + "ar m a zeu", "ar miz a zeu" ], "in 1 week": [ + "ar sizh a zeu", "ar sizhun a zeu" ], "in 1 year": [ @@ -173,6 +185,7 @@ "(\\d++[.,]?\\d*+) s zo" ], "\\1 week ago": [ + "(\\d++[.,]?\\d*+) sizh zo", "(\\d++[.,]?\\d*+) sizhun zo" ], "\\1 year ago": [ @@ -200,6 +213,7 @@ "a-benn (\\d++[.,]?\\d*+) s" ], "in \\1 week": [ + "a-benn (\\d++[.,]?\\d*+) sizh", "a-benn (\\d++[.,]?\\d*+) sizhun" ], "in \\1 year": [ diff --git a/dateparser/data/date_translation_data/brx.py b/dateparser/data/date_translation_data/brx.py index 0630614b9..4020e6d23 100644 --- a/dateparser/data/date_translation_data/brx.py +++ b/dateparser/data/date_translation_data/brx.py @@ -1,16 +1,22 @@ info = { "name": "brx", - "date_order": "MDY", + "date_order": "DMY", "january": [ + "जान", "जानुवारी" ], "february": [ + "फेब", + "फेब्रूवारी", "फेब्रुवारी" ], "march": [ + "मार्च", "मार्स" ], "april": [ + "एप्रि", + "एप्रिल", "एफ्रिल" ], "may": [ @@ -20,21 +26,33 @@ "जुन" ], "july": [ + "जुल", + "जुलाई", "जुलाइ" ], "august": [ + "आग", + "आगष्ट", "आगस्थ" ], "september": [ + "सेप", + "सेप्थेम्बर", "सेबथेज्ब़र" ], "october": [ + "अक्ट'", + "अक्ट'बर", "अखथबर" ], "november": [ + "नवे", + "नवेम्बर", "नबेज्ब़र" ], "december": [ + "डिसे", + "डिसेम्बर", "दिसेज्ब़र" ], "monday": [ @@ -46,18 +64,25 @@ "मंगलबार" ], "wednesday": [ + "बुध", + "बुधबार", "बुद", "बुदबार" ], "thursday": [ + "बिस्थि", + "बिस्थिबार", "बिसथि", "बिसथिबार" ], "friday": [ "सुखुर", - "सुखुरबार" + "सुखुरबार", + "सुुखुरबार" ], "saturday": [ + "सनि", + "सनिबार", "सुनि", "सुनिबार" ], @@ -78,18 +103,23 @@ "दान" ], "week": [ + "सप्थाह", "सबथा/हबथा" ], "day": [ "सान" ], "hour": [ + "hr", + "घन्टा", "रिंगा" ], "minute": [ + "मिनित", "मिनिथ" ], "second": [ + "सेकेण्ड", "सेखेन्द" ], "relative-type": { @@ -97,48 +127,104 @@ "दिनै" ], "0 hour ago": [ + "बे घन्टा", "this hour" ], "0 minute ago": [ + "बे मिनिट", "this minute" ], "0 month ago": [ + "बे दान", "this month" ], "0 second ago": [ + "दा", "now" ], "0 week ago": [ + "बे सप्थाह", "this week" ], "0 year ago": [ + "बे बोसोर", "this year" ], "1 day ago": [ "मैया" ], "1 month ago": [ + "थांनाय दान", "last month" ], "1 week ago": [ + "थांनाय सप्थाह", "last week" ], "1 year ago": [ + "थांनाय बोसोर", "last year" ], "in 1 day": [ "गाबोन" ], "in 1 month": [ + "फैगौ दान", "next month" ], "in 1 week": [ + "फैगौ सप्थाह", "next week" ], "in 1 year": [ + "फैगौ बोसोर", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) सान सिगां" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) घन्टा सिगां" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) मिनिट सिगां" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) दान सिगां" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) सेकेण्ड सिगां" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) सप्थाह सिगां" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) बोसोर सिगां" + ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) सानाव" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) घन्टायाव" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) मिनिटआव" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) दानाव" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) सेकेण्डआव" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) सप्थाहयाव" + ], + "in \\1 year": [ + "(\\d++[.,]?\\d*+) बोसोरआव" + ] + }, "locale_specific": {}, "skip": [ " ", diff --git a/dateparser/data/date_translation_data/bs-Cyrl.py b/dateparser/data/date_translation_data/bs-Cyrl.py index 303e962f0..3d61d3321 100644 --- a/dateparser/data/date_translation_data/bs-Cyrl.py +++ b/dateparser/data/date_translation_data/bs-Cyrl.py @@ -29,6 +29,8 @@ "јули" ], "august": [ + "ауг", + "аугуст", "авг", "август" ], @@ -50,8 +52,9 @@ ], "monday": [ "пон", - "понедељак", - "понедјељак" + "понедјељак", + "понедјељак", + "понедељак" ], "tuesday": [ "уто", @@ -75,49 +78,61 @@ ], "sunday": [ "нед", - "недеља", - "недјеља" + "недјеља", + "недјеља", + "недеља" ], "am": [ "пре подне", + "прије подне", "пријеподне" ], "pm": [ "поподне", + "послије подне", "послијеподне" ], "year": [ + "год", "година", "г", "год", "годинa" ], "month": [ - "месец", + "мјес", + "мјесец", "мј", "мјесец", "мјесеци", - "мјесеца" + "мјесеца", + "месец" ], "week": [ - "недеља", + "седм", + "седмица", "сед", "седмица", - "седмице" + "седмице", + "недеља" ], "day": [ "дан" ], "hour": [ - "час", - "сат" + "сат", + "сати", + "сат", + "час" ], "minute": [ + "мин", "минут", "мин", "минута" ], "second": [ + "сек", "секунд", "с", "сек", @@ -128,108 +143,148 @@ "данас" ], "0 hour ago": [ - "this hour", - "овај сат" + "овог сата", + "овај сат", + "this hour" ], "0 minute ago": [ - "this minute", - "ова минута" + "овог минута", + "ова минута", + "this minute" ], "0 month ago": [ - "овог месеца", - "овај мјесец" + "ов мјес", + "овог мјес", + "овог мјесеца", + "овај мјесец", + "овог месеца" ], "0 second ago": [ - "now", - "сада" + "сада", + "сада", + "now" ], "0 week ago": [ - "ове недеље", - "ове седмице" + "ове седм", + "ове седмице", + "ове седмице", + "ове недеље" ], "0 year ago": [ + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ - "прошлог месеца", - "прошли мјесец" + "прош мјес", + "прош мјесеца", + "прошлог мјесеца", + "прошли мјесец", + "прошлог месеца" ], "1 week ago": [ - "прошле недеље", - "прошле седмице" + "прош седм", + "прошле седмице", + "прошле седмице", + "прошле недеље" ], "1 year ago": [ + "прош године", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ - "следећег месеца", - "сљедећи мјесец" + "сљ мјес", + "сљед мјесеца", + "сљедећег мјесеца", + "сљедећи мјесец", + "следећег месеца" ], "in 1 week": [ - "следеће недеље", - "сљедеће седмице" + "сљ седм", + "сљедеће седмице", + "сљедеће седмице", + "следеће недеље" ], "in 1 year": [ - "следеће године", - "сљедеће године" + "сљед године", + "сљедеће године", + "сљедеће године", + "следеће године" ] }, "relative-type-regex": { "\\1 day ago": [ - "пре (\\d++[.,]?\\d*+) дан", - "пре (\\d++[.,]?\\d*+) дана", "прије (\\d++[.,]?\\d*+) дан", - "прије (\\d++[.,]?\\d*+) дана" + "прије (\\d++[.,]?\\d*+) дана", + "прије (\\d++[.,]?\\d*+) дан", + "прије (\\d++[.,]?\\d*+) дана", + "пре (\\d++[.,]?\\d*+) дан", + "пре (\\d++[.,]?\\d*+) дана" ], "\\1 hour ago": [ - "пре (\\d++[.,]?\\d*+) сат", - "пре (\\d++[.,]?\\d*+) сати", "прије (\\d++[.,]?\\d*+) сат", - "прије (\\d++[.,]?\\d*+) сати" + "прије (\\d++[.,]?\\d*+) сати", + "прије (\\d++[.,]?\\d*+) сат", + "прије (\\d++[.,]?\\d*+) сати", + "пре (\\d++[.,]?\\d*+) сат", + "пре (\\d++[.,]?\\d*+) сати" ], "\\1 minute ago": [ - "пре (\\d++[.,]?\\d*+) минут", - "пре (\\d++[.,]?\\d*+) минута", + "прије (\\d++[.,]?\\d*+) мин", + "прије (\\d++[.,]?\\d*+) минут", + "прије (\\d++[.,]?\\d*+) минута", "прије (\\d++[.,]?\\d*+) мин", "прије (\\d++[.,]?\\d*+) минута", - "прије (\\d++[.,]?\\d*+) минуту" + "прије (\\d++[.,]?\\d*+) минуту", + "пре (\\d++[.,]?\\d*+) минут", + "пре (\\d++[.,]?\\d*+) минута" ], "\\1 month ago": [ - "пре (\\d++[.,]?\\d*+) месец", - "пре (\\d++[.,]?\\d*+) месеци", + "прије (\\d++[.,]?\\d*+) мјес", + "прије (\\d++[.,]?\\d*+) мјесец", + "прије (\\d++[.,]?\\d*+) мјесеци", "прије (\\d++[.,]?\\d*+) мј", "прије (\\d++[.,]?\\d*+) мјесец", "прије (\\d++[.,]?\\d*+) мјесеца", - "прије (\\d++[.,]?\\d*+) мјесеци" + "прије (\\d++[.,]?\\d*+) мјесеци", + "пре (\\d++[.,]?\\d*+) месец", + "пре (\\d++[.,]?\\d*+) месеци" ], "\\1 second ago": [ - "пре (\\d++[.,]?\\d*+) секунд", - "пре (\\d++[.,]?\\d*+) секунди", + "прије (\\d++[.,]?\\d*+) сек", + "прије (\\d++[.,]?\\d*+) секунд", + "прије (\\d++[.,]?\\d*+) секунди", "прије (\\d++[.,]?\\d*+) сек", "прије (\\d++[.,]?\\d*+) секунда", - "прије (\\d++[.,]?\\d*+) секунду" + "прије (\\d++[.,]?\\d*+) секунду", + "пре (\\d++[.,]?\\d*+) секунд", + "пре (\\d++[.,]?\\d*+) секунди" ], "\\1 week ago": [ - "пре (\\d++[.,]?\\d*+) недеља", - "пре (\\d++[.,]?\\d*+) недељу", + "прије (\\d++[.,]?\\d*+) седм", + "прије (\\d++[.,]?\\d*+) седмица", + "прије (\\d++[.,]?\\d*+) седмицу", "прије (\\d++[.,]?\\d*+) сед", "прије (\\d++[.,]?\\d*+) седмица", "прије (\\d++[.,]?\\d*+) седмице", - "прије (\\d++[.,]?\\d*+) седмицу" + "прије (\\d++[.,]?\\d*+) седмицу", + "пре (\\d++[.,]?\\d*+) недеља", + "пре (\\d++[.,]?\\d*+) недељу" ], "\\1 year ago": [ - "пре (\\d++[.,]?\\d*+) година", - "пре (\\d++[.,]?\\d*+) годину", + "прије (\\d++[.,]?\\d*+) година", + "прије (\\d++[.,]?\\d*+) годину", "прије (\\d++[.,]?\\d*+) г", "прије (\\d++[.,]?\\d*+) год", "прије (\\d++[.,]?\\d*+) година", - "прије (\\d++[.,]?\\d*+) годину" + "прије (\\d++[.,]?\\d*+) годину", + "пре (\\d++[.,]?\\d*+) година", + "пре (\\d++[.,]?\\d*+) годину" ], "in \\1 day": [ "за (\\d++[.,]?\\d*+) дан", @@ -247,14 +302,18 @@ "за (\\d++[.,]?\\d*+) минуту" ], "in \\1 month": [ - "за (\\d++[.,]?\\d*+) месец", - "за (\\d++[.,]?\\d*+) месеци", + "за (\\d++[.,]?\\d*+) мјес", + "за (\\d++[.,]?\\d*+) мјесец", + "за (\\d++[.,]?\\d*+) мјесеци", "за (\\d++[.,]?\\d*+) мј", "за (\\d++[.,]?\\d*+) мјесец", "за (\\d++[.,]?\\d*+) мјесеца", - "за (\\d++[.,]?\\d*+) мјесеци" + "за (\\d++[.,]?\\d*+) мјесеци", + "за (\\d++[.,]?\\d*+) месец", + "за (\\d++[.,]?\\d*+) месеци" ], "in \\1 second": [ + "за (\\d++[.,]?\\d*+) сек", "за (\\d++[.,]?\\d*+) секунд", "за (\\d++[.,]?\\d*+) секунди", "за (\\d++[.,]?\\d*+) сек", @@ -262,12 +321,15 @@ "за (\\d++[.,]?\\d*+) секунду" ], "in \\1 week": [ - "за (\\d++[.,]?\\d*+) недеља", - "за (\\d++[.,]?\\d*+) недељу", + "за (\\d++[.,]?\\d*+) седм", + "за (\\d++[.,]?\\d*+) седмица", + "за (\\d++[.,]?\\d*+) седмицу", "за (\\d++[.,]?\\d*+) сед", "за (\\d++[.,]?\\d*+) седмица", "за (\\d++[.,]?\\d*+) седмицу", - "за (\\d++[.,]?\\d*+) седмице" + "за (\\d++[.,]?\\d*+) седмице", + "за (\\d++[.,]?\\d*+) недеља", + "за (\\d++[.,]?\\d*+) недељу" ], "in \\1 year": [ "за (\\d++[.,]?\\d*+) година", diff --git a/dateparser/data/date_translation_data/bs-Latn.py b/dateparser/data/date_translation_data/bs-Latn.py index 856305447..8ffbf8705 100644 --- a/dateparser/data/date_translation_data/bs-Latn.py +++ b/dateparser/data/date_translation_data/bs-Latn.py @@ -29,6 +29,8 @@ "juli" ], "august": [ + "aug", + "august", "avg", "avgust" ], @@ -77,9 +79,11 @@ "nedjelja" ], "am": [ + "am", "prijepodne" ], "pm": [ + "pm", "popodne" ], "year": [ @@ -100,7 +104,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser/data/date_translation_data/bs.py b/dateparser/data/date_translation_data/bs.py index 420ecfa71..805b60d17 100644 --- a/dateparser/data/date_translation_data/bs.py +++ b/dateparser/data/date_translation_data/bs.py @@ -29,6 +29,8 @@ "juli" ], "august": [ + "aug", + "august", "avg", "avgust" ], @@ -77,9 +79,11 @@ "nedjelja" ], "am": [ + "am", "prijepodne" ], "pm": [ + "pm", "popodne" ], "year": [ @@ -100,7 +104,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser/data/date_translation_data/ca.py b/dateparser/data/date_translation_data/ca.py index ec42c9e18..8b60dcf78 100644 --- a/dateparser/data/date_translation_data/ca.py +++ b/dateparser/data/date_translation_data/ca.py @@ -116,7 +116,8 @@ ], "hour": [ "h", - "hora" + "hora", + "hores" ], "minute": [ "min", @@ -175,10 +176,10 @@ "in 1 week": [ "la setm que ve", "la setmana que ve", - "setm vinent", "la setmana vinent", "la pròxima setmana", - "la propera setmana" + "la propera setmana", + "setm vinent" ], "in 1 year": [ "l'any que ve" diff --git a/dateparser/data/date_translation_data/ce.py b/dateparser/data/date_translation_data/ce.py index 996f78a3d..d07bb0ee0 100644 --- a/dateparser/data/date_translation_data/ce.py +++ b/dateparser/data/date_translation_data/ce.py @@ -49,24 +49,38 @@ "декабрь" ], "monday": [ + "ор", + "оршот", "оршотан де" ], "tuesday": [ + "ши", + "шинара", "шинарин де" ], "wednesday": [ + "кха", + "кхаара", "кхаарин де" ], "thursday": [ + "еа", + "еара", "еарин де" ], "friday": [ + "пӏе", + "пӏераска", "пӏераскан де" ], "saturday": [ + "шуо", + "шуот", "шот де" ], "sunday": [ + "кӏи", + "кӏира", "кӏиранан де" ], "am": [ @@ -92,7 +106,8 @@ ], "hour": [ "сахь", - "сахьт" + "сахьт", + "сахьташ" ], "minute": [ "мин", @@ -107,15 +122,18 @@ "тахана" ], "0 hour ago": [ + "хӏокху сахьтехь", "this hour" ], "0 minute ago": [ + "хӏокху минотехь", "this minute" ], "0 month ago": [ "карарчу баттахь" ], "0 second ago": [ + "хӏинца", "now" ], "0 week ago": [ diff --git a/dateparser/data/date_translation_data/cgg.py b/dateparser/data/date_translation_data/cgg.py index 494a6e8d1..2dfd7ffe6 100644 --- a/dateparser/data/date_translation_data/cgg.py +++ b/dateparser/data/date_translation_data/cgg.py @@ -96,6 +96,7 @@ "eizooba" ], "hour": [ + "hr", "shaaha" ], "minute": [ diff --git a/dateparser/data/date_translation_data/chr.py b/dateparser/data/date_translation_data/chr.py index e9a23a0a3..587eee9ab 100644 --- a/dateparser/data/date_translation_data/chr.py +++ b/dateparser/data/date_translation_data/chr.py @@ -81,6 +81,7 @@ "ꮜꮎꮄ" ], "pm": [ + "ꮢꭿᏹꭲ", "ꮢꭿᏹꭲꮧꮲ" ], "year": [ @@ -99,6 +100,7 @@ "ꭲꭶ" ], "hour": [ + "ꭲᏻꮯꮆꮣ", "ꮡꮯ", "ꮡꮯꮆꮣ" ], @@ -107,6 +109,7 @@ "ꭲꮿꮤꮼꮝꮤꮕ" ], "second": [ + "ꭰꮞ", "ꭰꮞꮲ" ], "relative-type": { @@ -120,6 +123,7 @@ "ꭿꭰ ꭲꮿꮤꮼꮝꮤꮕ" ], "0 month ago": [ + "ꭿꭰ ꭷꮈ", "ꭿꭰ ꭷꮈꭲ" ], "0 second ago": [ @@ -135,6 +139,7 @@ "ꮢꭿ" ], "1 month ago": [ + "ꭷꮈ ꮵꭸꮢ", "ꭷꮈꭲ ꮵꭸꮢ" ], "1 week ago": [ @@ -147,6 +152,8 @@ "ꮜꮎꮄꭲ" ], "in 1 month": [ + "ꭿꭰ ꭷꮈ", + "ꮤꮅꮑ ꭷꮈ", "ꮤꮅꮑ ꭷꮈꭲ" ], "in 1 week": [ @@ -163,29 +170,40 @@ ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) ꭲᏻꮯꮆꮣ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮡꮯ ꮵꭸꮢ", "(\\d++[.,]?\\d*+) ꮡꮯꮆꮣ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꮡꮯ ꮵꭸꮢ" ], "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) ꭲꮿꮤ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ" ], "\\1 month ago": [ + "(\\d++[.,]?\\d*+) ꭷꮈ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꭷꮈꭲ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮧꭷꮈꭲ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭷꮈꭲ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꮧꭷꮈꭲ ꮵꭸꮢ" ], "\\1 second ago": [ + "(\\d++[.,]?\\d*+) ꭰꮞ ꮵꭸꮢ", "(\\d++[.,]?\\d*+) ꭰꮞꮲ ꮵꭸꮢ", "(\\d++[.,]?\\d*+) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], "\\1 week ago": [ + "(\\d++[.,]?\\d*+) ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮢꮎ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ" ], "\\1 year ago": [ "(\\d++[.,]?\\d*+) ꭲꮷꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", + "(\\d++[.,]?\\d*+) ꭴꮥ ꮵꭸꮢ", "(\\d++[.,]?\\d*+) ꭴꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭴꮥ ꮵꭸꮢ" ], @@ -208,6 +226,7 @@ "ꮎꮏ (\\d++[.,]?\\d*+) ꮧꭷꮈꭲ" ], "in \\1 second": [ + "ꮎꮏ (\\d++[.,]?\\d*+) ꭰꮞ", "ꮎꮏ (\\d++[.,]?\\d*+) ꭰꮞꮲ", "ꮎꮏ (\\d++[.,]?\\d*+) ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], diff --git a/dateparser/data/date_translation_data/ckb.py b/dateparser/data/date_translation_data/ckb.py index 0de4a7c70..f2818fdf4 100644 --- a/dateparser/data/date_translation_data/ckb.py +++ b/dateparser/data/date_translation_data/ckb.py @@ -77,7 +77,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index aaadcdf2b..8c5cd1f88 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -156,6 +156,7 @@ "hour": [ "h", "hodina", + "hodiny", "hodin", "hodiny", "hodinou", @@ -193,6 +194,7 @@ "tuto minutu" ], "0 month ago": [ + "tento měs", "tento měsíc" ], "0 second ago": [ @@ -213,6 +215,7 @@ "včera" ], "1 month ago": [ + "minulý měs", "minulý měsíc" ], "1 week ago": [ @@ -228,6 +231,7 @@ "zítřka" ], "in 1 month": [ + "příští měs", "příští měsíc" ], "in 1 week": [ diff --git a/dateparser/data/date_translation_data/cy.py b/dateparser/data/date_translation_data/cy.py index bb1cc1356..190f2fcec 100644 --- a/dateparser/data/date_translation_data/cy.py +++ b/dateparser/data/date_translation_data/cy.py @@ -78,9 +78,11 @@ "sul" ], "am": [ + "am", "yb" ], "pm": [ + "pm", "yh" ], "year": [ @@ -94,10 +96,12 @@ "wythnos" ], "day": [ + "diwrnod", "dydd" ], "hour": [ - "awr" + "awr", + "oriau" ], "minute": [ "mun", @@ -123,6 +127,7 @@ "nawr" ], "0 week ago": [ + "yr ws hon", "yr wythnos hon" ], "0 year ago": [ @@ -135,6 +140,7 @@ "mis diwethaf" ], "1 week ago": [ + "ws ddiwethaf", "wythnos ddiwethaf" ], "1 year ago": [ @@ -147,9 +153,11 @@ "mis nesaf" ], "in 1 week": [ + "ws nesaf", "wythnos nesaf" ], "in 1 year": [ + "bl nesaf", "blwyddyn nesaf" ] }, @@ -168,12 +176,15 @@ "(\\d++[.,]?\\d*+) mis yn ôl" ], "\\1 second ago": [ + "(\\d++[.,]?\\d*+) eil yn ôl", "(\\d++[.,]?\\d*+) eiliad yn ôl" ], "\\1 week ago": [ + "(\\d++[.,]?\\d*+) ws yn ôl", "(\\d++[.,]?\\d*+) wythnos yn ôl" ], "\\1 year ago": [ + "(\\d++[.,]?\\d*+) bl yn ôl", "(\\d++[.,]?\\d*+) o flynyddoedd yn ôl" ], "in \\1 day": [ @@ -190,9 +201,11 @@ "ymhen (\\d++[.,]?\\d*+) mis" ], "in \\1 second": [ + "ymhen (\\d++[.,]?\\d*+) eil", "ymhen (\\d++[.,]?\\d*+) eiliad" ], "in \\1 week": [ + "ymhen (\\d++[.,]?\\d*+) ws", "ymhen (\\d++[.,]?\\d*+) wythnos" ], "in \\1 year": [ diff --git a/dateparser/data/date_translation_data/da.py b/dateparser/data/date_translation_data/da.py index 382cf1f3b..13e0c68dc 100644 --- a/dateparser/data/date_translation_data/da.py +++ b/dateparser/data/date_translation_data/da.py @@ -53,16 +53,18 @@ "mandag" ], "tuesday": [ - "tir", - "tirsdag" + "tirs", + "tirsdag", + "tir" ], "wednesday": [ "ons", "onsdag" ], "thursday": [ - "tor", - "torsdag" + "tors", + "torsdag", + "tor" ], "friday": [ "fre", @@ -101,6 +103,7 @@ "hour": [ "t", "time", + "timer", "timer" ], "minute": [ @@ -119,9 +122,11 @@ "i dag" ], "0 hour ago": [ + "denne time", "i den kommende time" ], "0 minute ago": [ + "dette minut", "i det kommende minut" ], "0 month ago": [ @@ -167,40 +172,51 @@ "relative-type-regex": { "\\1 day ago": [ "for (\\d++[.,]?\\d*+) dag siden", - "for (\\d++[.,]?\\d*+) dage siden" + "for (\\d++[.,]?\\d*+) dage siden", + "(\\d++[.,]?\\d*+) dag siden", + "(\\d++[.,]?\\d*+) dage siden" ], "\\1 hour ago": [ "for (\\d++[.,]?\\d*+) time siden", "for (\\d++[.,]?\\d*+) timer siden", + "(\\d++[.,]?\\d*+) time siden", + "(\\d++[.,]?\\d*+) timer siden", "for (\\d++[.,]?\\d*+)\\s*h", "for (\\d++[.,]?\\d*+) timer" ], "\\1 minute ago": [ - "for (\\d++[.,]?\\d*+) min siden", "for (\\d++[.,]?\\d*+) minut siden", "for (\\d++[.,]?\\d*+) minutter siden", + "(\\d++[.,]?\\d*+) min siden", "for (\\d++[.,]?\\d*+)\\s*m", - "for (\\d++[.,]?\\d*+) minutter" + "for (\\d++[.,]?\\d*+) minutter", + "for (\\d++[.,]?\\d*+) min siden" ], "\\1 month ago": [ - "for (\\d++[.,]?\\d*+) md siden", - "for (\\d++[.,]?\\d*+) mdr siden", "for (\\d++[.,]?\\d*+) måned siden", - "for (\\d++[.,]?\\d*+) måneder siden" + "for (\\d++[.,]?\\d*+) måneder siden", + "(\\d++[.,]?\\d*+) md siden", + "(\\d++[.,]?\\d*+) mdr siden", + "for (\\d++[.,]?\\d*+) md siden", + "for (\\d++[.,]?\\d*+) mdr siden" ], "\\1 second ago": [ - "for (\\d++[.,]?\\d*+) sek siden", "for (\\d++[.,]?\\d*+) sekund siden", "for (\\d++[.,]?\\d*+) sekunder siden", + "(\\d++[.,]?\\d*+) sek siden", "for (\\d++[.,]?\\d*+)\\s*s", - "for (\\d++[.,]?\\d*+) sekunder" + "for (\\d++[.,]?\\d*+) sekunder", + "for (\\d++[.,]?\\d*+) sek siden" ], "\\1 week ago": [ "for (\\d++[.,]?\\d*+) uge siden", - "for (\\d++[.,]?\\d*+) uger siden" + "for (\\d++[.,]?\\d*+) uger siden", + "(\\d++[.,]?\\d*+) uge siden", + "(\\d++[.,]?\\d*+) uger siden" ], "\\1 year ago": [ - "for (\\d++[.,]?\\d*+) år siden" + "for (\\d++[.,]?\\d*+) år siden", + "(\\d++[.,]?\\d*+) år siden" ], "in \\1 day": [ "om (\\d++[.,]?\\d*+) dag", @@ -242,6 +258,7 @@ "skip": [ "cirka", "d.", + "den", "kl", "kl.", " ", diff --git a/dateparser/data/date_translation_data/dav.py b/dateparser/data/date_translation_data/dav.py index 17b9f90e6..0cc577ad4 100644 --- a/dateparser/data/date_translation_data/dav.py +++ b/dateparser/data/date_translation_data/dav.py @@ -96,6 +96,7 @@ "ituku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/de.py b/dateparser/data/date_translation_data/de.py index 4fdcb43ed..c1a576b94 100644 --- a/dateparser/data/date_translation_data/de.py +++ b/dateparser/data/date_translation_data/de.py @@ -37,6 +37,7 @@ ], "september": [ "sep", + "sept", "september", "Sept" ], @@ -88,9 +89,11 @@ "Son" ], "am": [ + "am", "vorm" ], "pm": [ + "pm", "nachm" ], "year": [ @@ -118,6 +121,7 @@ "hour": [ "std", "stunde", + "stunden", "Stunden" ], "minute": [ diff --git a/dateparser/data/date_translation_data/dje.py b/dateparser/data/date_translation_data/dje.py index d3e90c103..1ee9e9a6e 100644 --- a/dateparser/data/date_translation_data/dje.py +++ b/dateparser/data/date_translation_data/dje.py @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser/data/date_translation_data/dsb.py b/dateparser/data/date_translation_data/dsb.py index 0cabbb532..33de25c4a 100644 --- a/dateparser/data/date_translation_data/dsb.py +++ b/dateparser/data/date_translation_data/dsb.py @@ -89,9 +89,11 @@ "njeźela" ], "am": [ + "dop", "dopołdnja" ], "pm": [ + "wótp", "wótpołdnja" ], "year": [ @@ -113,7 +115,8 @@ "hour": [ "g", "góź", - "góźina" + "góźina", + "góźiny" ], "minute": [ "m", @@ -127,48 +130,74 @@ ], "relative-type": { "0 day ago": [ - "źinsa" + "źins", + "źinsa", + "źis" ], "0 hour ago": [ + "w toś tej góźinje", "this hour" ], "0 minute ago": [ + "w toś tej minuśe", "this minute" ], "0 month ago": [ - "ten mjasec" + "te mjasec", + "ten mjasec", + "tot mjasec" ], "0 second ago": [ - "now" + "něnto" ], "0 week ago": [ - "ten tyźeń" + "te tyźeń", + "ten tyźeń", + "tot tyźeń" ], "0 year ago": [ - "lětosa" + "lět", + "lětosa", + "lěts" ], "1 day ago": [ - "cora" + "cora", + "cr", + "cra" ], "1 month ago": [ + "zajź mjasec", + "zajźony mjasec", "slědny mjasec" ], "1 week ago": [ + "zajź tyźeń", + "zajźony tyźeń", "slědny tyźeń" ], "1 year ago": [ + "ło", + "łon", "łoni" ], "in 1 day": [ + "wit", + "witś", "witśe" ], "in 1 month": [ + "pśid mjasec", + "pśiduc mjasec", "pśiducy mjasec" ], "in 1 week": [ + "pśid tyźeń", + "pśiduc tyźeń", "pśiducy tyźeń" ], "in 1 year": [ + "zno", + "znow", "znowa" ] }, diff --git a/dateparser/data/date_translation_data/dua.py b/dateparser/data/date_translation_data/dua.py index 886f5a30a..3e79492f9 100644 --- a/dateparser/data/date_translation_data/dua.py +++ b/dateparser/data/date_translation_data/dua.py @@ -96,6 +96,7 @@ "búnyá" ], "hour": [ + "hr", "ŋgandɛ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/dyo.py b/dateparser/data/date_translation_data/dyo.py index 486d1077b..1e947e76b 100644 --- a/dateparser/data/date_translation_data/dyo.py +++ b/dateparser/data/date_translation_data/dyo.py @@ -95,7 +95,8 @@ "funak" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/dz.py b/dateparser/data/date_translation_data/dz.py index 9419439df..0d75f6002 100644 --- a/dateparser/data/date_translation_data/dz.py +++ b/dateparser/data/date_translation_data/dz.py @@ -108,6 +108,7 @@ "ཚེས་" ], "hour": [ + "hr", "ཆུ་ཚོད" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ebu.py b/dateparser/data/date_translation_data/ebu.py index efe459c33..199d014b4 100644 --- a/dateparser/data/date_translation_data/ebu.py +++ b/dateparser/data/date_translation_data/ebu.py @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "ithaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ee.py b/dateparser/data/date_translation_data/ee.py index 8c46eb098..bc2d95c06 100644 --- a/dateparser/data/date_translation_data/ee.py +++ b/dateparser/data/date_translation_data/ee.py @@ -96,7 +96,8 @@ "ŋkeke" ], "hour": [ - "gaƒoƒo" + "gaƒoƒo", + "gaƒoƒowo" ], "minute": [ "aɖabaƒoƒo" diff --git a/dateparser/data/date_translation_data/el.py b/dateparser/data/date_translation_data/el.py index 6fb5d76b9..69ac05b0e 100644 --- a/dateparser/data/date_translation_data/el.py +++ b/dateparser/data/date_translation_data/el.py @@ -114,12 +114,14 @@ "εβδομάδα" ], "day": [ + "ημ", "ημέρα" ], "hour": [ "ώ", - "ώρ", - "ώρα" + "ώρα", + "ώρες", + "ώρ" ], "minute": [ "λ", @@ -136,18 +138,24 @@ "σήμερα" ], "0 hour ago": [ + "τρέχουσα ώρα", "αυτήν την ώρα" ], "0 minute ago": [ + "τρέχον λεπτό", "αυτό το λεπτό" ], "0 month ago": [ + "τρέχ μήνας", "τρέχων μήνας" ], "0 second ago": [ "τώρα" ], "0 week ago": [ + "τρέχ εβδ", + "τρέχ εβδομάδα", + "τρέχουσα εβδομάδα", "αυτήν την εβδομάδα" ], "0 year ago": [ @@ -157,9 +165,12 @@ "χθες" ], "1 month ago": [ + "προηγ μήνας", "προηγούμενος μήνας" ], "1 week ago": [ + "προηγ εβδ", + "προηγ εβδομάδα", "προηγούμενη εβδομάδα" ], "1 year ago": [ @@ -169,9 +180,12 @@ "αύριο" ], "in 1 month": [ + "επόμ μήνας", "επόμενος μήνας" ], "in 1 week": [ + "επόμ εβδ", + "επόμ εβδομάδα", "επόμενη εβδομάδα" ], "in 1 year": [ @@ -181,14 +195,16 @@ "relative-type-regex": { "\\1 day ago": [ "(\\d++[.,]?\\d*+) ημ πριν", + "πριν από (\\d++[.,]?\\d*+) ημ", "πριν από (\\d++[.,]?\\d*+) ημέρα", "πριν από (\\d++[.,]?\\d*+) ημέρες" ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) ώ πριν", - "πριν από (\\d++[.,]?\\d*+) ώρ", + "πριν από (\\d++[.,]?\\d*+) ώ", "πριν από (\\d++[.,]?\\d*+) ώρα", - "πριν από (\\d++[.,]?\\d*+) ώρες" + "πριν από (\\d++[.,]?\\d*+) ώρες", + "πριν από (\\d++[.,]?\\d*+) ώρ" ], "\\1 minute ago": [ "(\\d++[.,]?\\d*+) λ πριν", @@ -226,9 +242,9 @@ ], "in \\1 hour": [ "σε (\\d++[.,]?\\d*+) ώ", - "σε (\\d++[.,]?\\d*+) ώρ", "σε (\\d++[.,]?\\d*+) ώρα", - "σε (\\d++[.,]?\\d*+) ώρες" + "σε (\\d++[.,]?\\d*+) ώρες", + "σε (\\d++[.,]?\\d*+) ώρ" ], "in \\1 minute": [ "σε (\\d++[.,]?\\d*+) λ", diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index ecb048c0e..13c72da42 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -114,6 +114,7 @@ ], "hour": [ "hour", + "hours", "hr", "h", "hours", @@ -206,73 +207,87 @@ "relative-type-regex": { "\\1 day ago": [ "(\\d++[.,]?\\d*+) day ago", - "(\\d++[.,]?\\d*+) days ago" + "(\\d++[.,]?\\d*+) days ago", + "(\\d++[.,]?\\d*+)d ago" ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) hour ago", "(\\d++[.,]?\\d*+) hours ago", - "(\\d++[.,]?\\d*+) hr ago" + "(\\d++[.,]?\\d*+) hr ago", + "(\\d++[.,]?\\d*+)h ago" ], "\\1 minute ago": [ "(\\d++[.,]?\\d*+) min ago", "(\\d++[.,]?\\d*+) minute ago", - "(\\d++[.,]?\\d*+) minutes ago" + "(\\d++[.,]?\\d*+) minutes ago", + "(\\d++[.,]?\\d*+)m ago" ], "\\1 month ago": [ "(\\d++[.,]?\\d*+) mo ago", "(\\d++[.,]?\\d*+) month ago", - "(\\d++[.,]?\\d*+) months ago" + "(\\d++[.,]?\\d*+) months ago", + "(\\d++[.,]?\\d*+)mo ago" ], "\\1 second ago": [ "(\\d++[.,]?\\d*+) sec ago", "(\\d++[.,]?\\d*+) second ago", - "(\\d++[.,]?\\d*+) seconds ago" + "(\\d++[.,]?\\d*+) seconds ago", + "(\\d++[.,]?\\d*+)s ago" ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) week ago", "(\\d++[.,]?\\d*+) weeks ago", - "(\\d++[.,]?\\d*+) wk ago" + "(\\d++[.,]?\\d*+) wk ago", + "(\\d++[.,]?\\d*+)w ago" ], "\\1 year ago": [ "(\\d++[.,]?\\d*+) year ago", "(\\d++[.,]?\\d*+) years ago", - "(\\d++[.,]?\\d*+) yr ago" + "(\\d++[.,]?\\d*+) yr ago", + "(\\d++[.,]?\\d*+)y ago" ], "in \\1 day": [ "in (\\d++[.,]?\\d*+) day", - "in (\\d++[.,]?\\d*+) days" + "in (\\d++[.,]?\\d*+) days", + "in (\\d++[.,]?\\d*+)d" ], "in \\1 hour": [ "in (\\d++[.,]?\\d*+) hour", "in (\\d++[.,]?\\d*+) hours", - "in (\\d++[.,]?\\d*+) hr" + "in (\\d++[.,]?\\d*+) hr", + "in (\\d++[.,]?\\d*+)h" ], "in \\1 minute": [ "in (\\d++[.,]?\\d*+) min", "in (\\d++[.,]?\\d*+) minute", - "in (\\d++[.,]?\\d*+) minutes" + "in (\\d++[.,]?\\d*+) minutes", + "in (\\d++[.,]?\\d*+)m" ], "in \\1 month": [ "in (\\d++[.,]?\\d*+) mo", "in (\\d++[.,]?\\d*+) month", - "in (\\d++[.,]?\\d*+) months" + "in (\\d++[.,]?\\d*+) months", + "in (\\d++[.,]?\\d*+)mo" ], "in \\1 second": [ "in (\\d++[.,]?\\d*+) sec", "in (\\d++[.,]?\\d*+) second", - "in (\\d++[.,]?\\d*+) seconds" + "in (\\d++[.,]?\\d*+) seconds", + "in (\\d++[.,]?\\d*+)s" ], "in \\1 week": [ "in (\\d++[.,]?\\d*+) week", "in (\\d++[.,]?\\d*+) weeks", + "in (\\d++[.,]?\\d*+) wk", + "in (\\d++[.,]?\\d*+)w", "in (\\d++[.,]?\\d*+) weeks time", - "in (\\d++[.,]?\\d*+) weeks' time", - "in (\\d++[.,]?\\d*+) wk" + "in (\\d++[.,]?\\d*+) weeks' time" ], "in \\1 year": [ "in (\\d++[.,]?\\d*+) year", "in (\\d++[.,]?\\d*+) years", - "in (\\d++[.,]?\\d*+) yr" + "in (\\d++[.,]?\\d*+) yr", + "in (\\d++[.,]?\\d*+)y" ], "in \\1 decade": [ "in (\\d++[.,]?\\d*+) decades?" @@ -284,60 +299,129 @@ "locale_specific": { "en-001": { "name": "en-001", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-150": { "name": "en-150", + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-AE": { + "name": "en-AE", "date_order": "DMY" }, "en-AG": { "name": "en-AG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AI": { "name": "en-AI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AS": { "name": "en-AS" }, "en-AT": { "name": "en-AT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AU": { "name": "en-AU", "date_order": "DMY", - "hour": [ - "h" - ] + "september": [ + "sept" + ], + "relative-type-regex": { + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) hrs ago" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) mins ago" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) secs ago" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) wks ago" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) yrs ago" + ], + "in \\1 hour": [ + "in (\\d++[.,]?\\d*+) hrs" + ], + "in \\1 minute": [ + "in (\\d++[.,]?\\d*+) mins" + ], + "in \\1 second": [ + "in (\\d++[.,]?\\d*+) secs" + ], + "in \\1 week": [ + "in (\\d++[.,]?\\d*+) wks" + ], + "in \\1 year": [ + "in (\\d++[.,]?\\d*+) yrs" + ] + } }, "en-BB": { "name": "en-BB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BE": { "name": "en-BE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BI": { "name": "en-BI" }, "en-BM": { "name": "en-BM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BS": { "name": "en-BS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BW": { "name": "en-BW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BZ": { "name": "en-BZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CA": { "name": "en-CA", @@ -383,263 +467,459 @@ }, "en-CC": { "name": "en-CC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CH": { "name": "en-CH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CK": { "name": "en-CK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CM": { "name": "en-CM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CX": { "name": "en-CX", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CY": { "name": "en-CY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DE": { "name": "en-DE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DG": { "name": "en-DG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DK": { "name": "en-DK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DM": { "name": "en-DM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ER": { "name": "en-ER", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FI": { "name": "en-FI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FJ": { "name": "en-FJ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FK": { "name": "en-FK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FM": { "name": "en-FM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GB": { "name": "en-GB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GD": { "name": "en-GD", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GG": { "name": "en-GG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GH": { "name": "en-GH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GI": { "name": "en-GI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GM": { "name": "en-GM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GU": { "name": "en-GU" }, "en-GY": { "name": "en-GY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-HK": { "name": "en-HK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-ID": { + "name": "en-ID", + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IE": { "name": "en-IE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IL": { "name": "en-IL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IM": { "name": "en-IM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IN": { "name": "en-IN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IO": { "name": "en-IO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-JE": { "name": "en-JE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-JM": { "name": "en-JM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KE": { "name": "en-KE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KI": { "name": "en-KI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KN": { "name": "en-KN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KY": { "name": "en-KY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LC": { "name": "en-LC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LR": { "name": "en-LR", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LS": { "name": "en-LS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MG": { "name": "en-MG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MH": { "name": "en-MH" }, "en-MO": { "name": "en-MO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MP": { "name": "en-MP" }, "en-MS": { "name": "en-MS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MT": { "name": "en-MT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MU": { "name": "en-MU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-MV": { + "name": "en-MV", + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MW": { "name": "en-MW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MY": { "name": "en-MY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NA": { "name": "en-NA", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NF": { "name": "en-NF", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NG": { "name": "en-NG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NL": { "name": "en-NL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NR": { "name": "en-NR", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NU": { "name": "en-NU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NZ": { "name": "en-NZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PG": { "name": "en-PG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PH": { - "name": "en-PH", - "date_order": "DMY" + "name": "en-PH" }, "en-PK": { "name": "en-PK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PN": { "name": "en-PN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PR": { "name": "en-PR" }, "en-PW": { "name": "en-PW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-RW": { "name": "en-RW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SB": { "name": "en-SB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SC": { "name": "en-SC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SD": { "name": "en-SD", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SE": { "name": "en-SE", - "date_order": "YMD" + "date_order": "YMD", + "september": [ + "sept" + ] }, "en-SG": { "name": "en-SG", "date_order": "DMY", + "september": [ + "sept" + ], "month": [ "mth" ], @@ -665,92 +945,153 @@ }, "en-SH": { "name": "en-SH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SI": { "name": "en-SI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SL": { "name": "en-SL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SS": { "name": "en-SS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SX": { "name": "en-SX", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SZ": { "name": "en-SZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TC": { "name": "en-TC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TK": { "name": "en-TK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TO": { "name": "en-TO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TT": { "name": "en-TT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TV": { "name": "en-TV", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TZ": { "name": "en-TZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-UG": { "name": "en-UG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-UM": { "name": "en-UM" }, - "en-US": { - "name": "en-US" - }, "en-VC": { "name": "en-VC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-VG": { "name": "en-VG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-VI": { "name": "en-VI" }, "en-VU": { "name": "en-VU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-WS": { "name": "en-WS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ZA": { "name": "en-ZA", - "date_order": "YMD" + "date_order": "YMD", + "september": [ + "sept" + ] }, "en-ZM": { "name": "en-ZM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ZW": { "name": "en-ZW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-US": { + "name": "en-US", + "date_order": "MDY" } }, "skip": [ diff --git a/dateparser/data/date_translation_data/eo.py b/dateparser/data/date_translation_data/eo.py index 8e172aeb2..252d94593 100644 --- a/dateparser/data/date_translation_data/eo.py +++ b/dateparser/data/date_translation_data/eo.py @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/es.py b/dateparser/data/date_translation_data/es.py index d1882c5db..4dcc42d4c 100644 --- a/dateparser/data/date_translation_data/es.py +++ b/dateparser/data/date_translation_data/es.py @@ -115,6 +115,7 @@ "hour": [ "h", "hora", + "horas", "horas" ], "minute": [ @@ -144,6 +145,7 @@ "ahora" ], "0 week ago": [ + "esta sem", "esta semana" ], "0 year ago": [ @@ -156,7 +158,8 @@ "el mes pasado" ], "1 week ago": [ - "la semana pasada" + "la semana pasada", + "sem ant" ], "1 year ago": [ "el año pasado" @@ -168,7 +171,8 @@ "el próximo mes" ], "in 1 week": [ - "la próxima semana" + "la próxima semana", + "próx sem" ], "in 1 year": [ "el próximo año" @@ -179,6 +183,7 @@ }, "relative-type-regex": { "\\1 day ago": [ + "hace (\\d++[.,]?\\d*+) d", "hace (\\d++[.,]?\\d*+) día", "hace (\\d++[.,]?\\d*+) días" ], @@ -213,6 +218,7 @@ "hace (\\d++[.,]?\\d*+) años" ], "in \\1 day": [ + "dentro de (\\d++[.,]?\\d*+) d", "dentro de (\\d++[.,]?\\d*+) día", "dentro de (\\d++[.,]?\\d*+) días" ], @@ -250,18 +256,28 @@ "locale_specific": { "es-419": { "name": "es-419", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-AR": { "name": "es-AR", - "september": [ - "sep" + "hour": [ + "hs" ], "second": [ "seg" ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "relative-type-regex": { "\\1 second ago": [ "hace (\\d++[.,]?\\d*+) seg" @@ -269,52 +285,95 @@ "in \\1 second": [ "dentro de (\\d++[.,]?\\d*+) seg" ] - } + }, + "september": [ + "sep" + ] }, "es-BO": { "name": "es-BO", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-BR": { "name": "es-BR", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-BZ": { "name": "es-BZ", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-CL": { "name": "es-CL", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-CO": { "name": "es-CO", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-CR": { "name": "es-CR", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-CU": { "name": "es-CU", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-DO": { "name": "es-DO", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -324,6 +383,11 @@ }, "es-EC": { "name": "es-EC", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -333,12 +397,22 @@ }, "es-GT": { "name": "es-GT", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-HN": { "name": "es-HN", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -352,6 +426,9 @@ "sep" ], "relative-type": { + "1 week ago": [ + "sem pas" + ], "in 1 month": [ "el mes próximo" ], @@ -371,9 +448,6 @@ "en (\\d++[.,]?\\d*+) h", "en (\\d++[.,]?\\d*+) n" ], - "in \\1 minute": [ - "en (\\d++[.,]?\\d*+) min" - ], "in \\1 month": [ "en (\\d++[.,]?\\d*+) m", "en (\\d++[.,]?\\d*+) mes", @@ -387,11 +461,19 @@ ], "in \\1 year": [ "en (\\d++[.,]?\\d*+) a" + ], + "in \\1 minute": [ + "en (\\d++[.,]?\\d*+) min" ] } }, "es-NI": { "name": "es-NI", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -399,6 +481,11 @@ "es-PA": { "name": "es-PA", "date_order": "MDY", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -408,7 +495,12 @@ "september": [ "set", "setiembre" - ] + ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-PH": { "name": "es-PH" @@ -416,6 +508,11 @@ "es-PR": { "name": "es-PR", "date_order": "MDY", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] @@ -425,6 +522,11 @@ "second": [ "seg" ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "relative-type-regex": { "\\1 second ago": [ "hace (\\d++[.,]?\\d*+) seg" @@ -436,12 +538,25 @@ }, "es-SV": { "name": "es-SV", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "september": [ "sep" ] }, "es-US": { "name": "es-US", + "relative-type": { + "1 week ago": [ + "sem pasada" + ], + "in 1 week": [ + "próxima sem" + ] + }, "september": [ "sep" ] @@ -451,10 +566,20 @@ "september": [ "set", "setiembre" - ] + ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-VE": { - "name": "es-VE" + "name": "es-VE", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } } }, "skip": [ diff --git a/dateparser/data/date_translation_data/et.py b/dateparser/data/date_translation_data/et.py index c5d8942bd..4c77e3e1c 100644 --- a/dateparser/data/date_translation_data/et.py +++ b/dateparser/data/date_translation_data/et.py @@ -97,7 +97,8 @@ ], "hour": [ "t", - "tund" + "tund", + "tunnid" ], "minute": [ "min", @@ -119,39 +120,57 @@ "praegusel minutil" ], "0 month ago": [ - "käesolev kuu" + "käesolev kuu", + "see k", + "see kuu" ], "0 second ago": [ "nüüd" ], "0 week ago": [ - "käesolev nädal" + "käesolev nädal", + "see n", + "see näd" ], "0 year ago": [ - "käesolev aasta" + "käesolev a", + "käesolev aasta", + "see a" ], "1 day ago": [ "eile" ], "1 month ago": [ + "eelm k", + "eelm kuu", "eelmine kuu" ], "1 week ago": [ + "eelm n", + "eelm näd", "eelmine nädal" ], "1 year ago": [ + "eelm a", + "eelmine a", "eelmine aasta" ], "in 1 day": [ "homme" ], "in 1 month": [ + "järgm k", + "järgm kuu", "järgmine kuu" ], "in 1 week": [ + "järgm n", + "järgm näd", "järgmine nädal" ], "in 1 year": [ + "järgm a", + "järgmine a", "järgmine aasta" ] }, diff --git a/dateparser/data/date_translation_data/eu.py b/dateparser/data/date_translation_data/eu.py index 73e00899d..c40a94484 100644 --- a/dateparser/data/date_translation_data/eu.py +++ b/dateparser/data/date_translation_data/eu.py @@ -100,7 +100,8 @@ ], "hour": [ "h", - "ordua" + "ordua", + "orduak" ], "minute": [ "min", @@ -121,12 +122,14 @@ "minutu honetan" ], "0 month ago": [ + "hilabete honetan", "hilabete hau" ], "0 second ago": [ "orain" ], "0 week ago": [ + "aste honetan", "aste hau" ], "0 year ago": [ @@ -136,25 +139,31 @@ "atzo" ], "1 month ago": [ + "aurreko hilabetean", "aurreko hilabetea" ], "1 week ago": [ + "aurreko astean", "aurreko astea" ], "1 year ago": [ - "aurreko urtea" + "aurreko urtea", + "iaz" ], "in 1 day": [ "bihar" ], "in 1 month": [ + "hurrengo hilabetean", "hurrengo hilabetea" ], "in 1 week": [ + "hurrengo astean", "hurrengo astea" ], "in 1 year": [ - "hurrengo urtea" + "hurrengo urtea", + "hurrengo urtean" ] }, "relative-type-regex": { diff --git a/dateparser/data/date_translation_data/ewo.py b/dateparser/data/date_translation_data/ewo.py index 62c3afc0c..39c599a6e 100644 --- a/dateparser/data/date_translation_data/ewo.py +++ b/dateparser/data/date_translation_data/ewo.py @@ -96,7 +96,8 @@ "amǒs" ], "hour": [ - "awola" + "awola", + "hr" ], "minute": [ "enútɛn" diff --git a/dateparser/data/date_translation_data/fa.py b/dateparser/data/date_translation_data/fa.py index 5ca114d17..bc4a50c98 100644 --- a/dateparser/data/date_translation_data/fa.py +++ b/dateparser/data/date_translation_data/fa.py @@ -136,8 +136,8 @@ "دیروز" ], "1 month ago": [ - "ماه پیش", - "ماه گذشته" + "ماه گذشته", + "ماه پیش" ], "1 week ago": [ "هفتهٔ گذشته" @@ -181,7 +181,8 @@ "(\\d++[.,]?\\d*+) سال پیش" ], "in \\1 day": [ - "(\\d++[.,]?\\d*+) روز بعد" + "(\\d++[.,]?\\d*+) روز بعد", + "(\\d++[.,]?\\d*+) روز دیگر" ], "in \\1 hour": [ "(\\d++[.,]?\\d*+) ساعت بعد" diff --git a/dateparser/data/date_translation_data/ff.py b/dateparser/data/date_translation_data/ff.py index 3e684a39e..02712b9d7 100644 --- a/dateparser/data/date_translation_data/ff.py +++ b/dateparser/data/date_translation_data/ff.py @@ -96,6 +96,7 @@ "ñalnde" ], "hour": [ + "hr", "waktu" ], "minute": [ diff --git a/dateparser/data/date_translation_data/fi.py b/dateparser/data/date_translation_data/fi.py index e57e36c95..b068e2267 100644 --- a/dateparser/data/date_translation_data/fi.py +++ b/dateparser/data/date_translation_data/fi.py @@ -158,6 +158,7 @@ ], "hour": [ "t", + "tunnit", "tunti", "tuntia", "tunnin" diff --git a/dateparser/data/date_translation_data/fil.py b/dateparser/data/date_translation_data/fil.py index b0ef86440..465e829c6 100644 --- a/dateparser/data/date_translation_data/fil.py +++ b/dateparser/data/date_translation_data/fil.py @@ -96,6 +96,7 @@ "araw" ], "hour": [ + "mga oras", "oras" ], "minute": [ @@ -172,8 +173,8 @@ ], "\\1 second ago": [ "(\\d++[.,]?\\d*+) seg ang nakalipas", - "(\\d++[.,]?\\d*+) seg nakalipas", - "(\\d++[.,]?\\d*+) segundo ang nakalipas" + "(\\d++[.,]?\\d*+) segundo ang nakalipas", + "(\\d++[.,]?\\d*+) seg nakalipas" ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) linggo ang nakalipas" diff --git a/dateparser/data/date_translation_data/fo.py b/dateparser/data/date_translation_data/fo.py index b8265b08a..c3a4ed4e3 100644 --- a/dateparser/data/date_translation_data/fo.py +++ b/dateparser/data/date_translation_data/fo.py @@ -101,6 +101,7 @@ ], "hour": [ "t", + "tímar", "tími" ], "minute": [ @@ -124,12 +125,15 @@ "hendan minuttin" ], "0 month ago": [ + "henda mnð", "henda mánaðin" ], "0 second ago": [ "nú" ], "0 week ago": [ + "hesu v", + "hesu vi", "hesu viku" ], "0 year ago": [ @@ -139,9 +143,12 @@ "í gjár" ], "1 month ago": [ + "seinasta mnð", "seinasta mánað" ], "1 week ago": [ + "seinastu v", + "seinastu vi", "seinastu viku" ], "1 year ago": [ @@ -151,9 +158,12 @@ "í morgin" ], "in 1 month": [ + "næsta mnð", "næsta mánað" ], "in 1 week": [ + "næstu v", + "næstu vi", "næstu viku" ], "in 1 year": [ diff --git a/dateparser/data/date_translation_data/fr.py b/dateparser/data/date_translation_data/fr.py index c6aa082a4..9a8b315b0 100644 --- a/dateparser/data/date_translation_data/fr.py +++ b/dateparser/data/date_translation_data/fr.py @@ -116,6 +116,7 @@ "hour": [ "h", "heure", + "heures", "heures" ], "minute": [ diff --git a/dateparser/data/date_translation_data/fur.py b/dateparser/data/date_translation_data/fur.py index d77dd223e..7119b24e3 100644 --- a/dateparser/data/date_translation_data/fur.py +++ b/dateparser/data/date_translation_data/fur.py @@ -94,7 +94,8 @@ "dì" ], "hour": [ - "ore" + "ore", + "oris" ], "minute": [ "minût" diff --git a/dateparser/data/date_translation_data/ga.py b/dateparser/data/date_translation_data/ga.py index afd650c56..54936ca51 100644 --- a/dateparser/data/date_translation_data/ga.py +++ b/dateparser/data/date_translation_data/ga.py @@ -76,9 +76,11 @@ "dé domhnaigh" ], "am": [ + "rn", "am" ], "pm": [ + "in", "pm" ], "year": [ @@ -130,6 +132,8 @@ "an tseachtain seo" ], "0 year ago": [ + "i mbl", + "i mbliana", "an bhl seo", "an bhliain seo" ], @@ -204,7 +208,8 @@ ], "in \\1 month": [ "i gceann (\\d++[.,]?\\d*+) mhí", - "i gceann (\\d++[.,]?\\d*+) mí" + "i gceann (\\d++[.,]?\\d*+) mí", + "i gceann (\\d++[.,]?\\d*+) míosa" ], "in \\1 second": [ "i gceann (\\d++[.,]?\\d*+) soic", @@ -212,15 +217,21 @@ ], "in \\1 week": [ "i gceann (\\d++[.,]?\\d*+) scht", - "i gceann (\\d++[.,]?\\d*+) seachtain" + "i gceann (\\d++[.,]?\\d*+) seachtain", + "i gceann (\\d++[.,]?\\d*+) seachtaine" ], "in \\1 year": [ - "i gceann (\\d++[.,]?\\d*+) bhliain", "i gceann (\\d++[.,]?\\d*+) bl", - "i gceann (\\d++[.,]?\\d*+) bliain" + "i gceann (\\d++[.,]?\\d*+) bliain", + "i gceann (\\d++[.,]?\\d*+) bliana", + "i gceann (\\d++[.,]?\\d*+) bhliain" ] }, - "locale_specific": {}, + "locale_specific": { + "ga-GB": { + "name": "ga-GB" + } + }, "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/gd.py b/dateparser/data/date_translation_data/gd.py index be242fe82..d005f8317 100644 --- a/dateparser/data/date_translation_data/gd.py +++ b/dateparser/data/date_translation_data/gd.py @@ -132,9 +132,15 @@ "an-diugh" ], "0 hour ago": [ + "am broinn uair", + "am broinn uair a thìde", + "san uair", "this hour" ], "0 minute ago": [ + "am broinn mion", + "am broinn mionaid", + "sa mhion", "this minute" ], "0 month ago": [ diff --git a/dateparser/data/date_translation_data/gl.py b/dateparser/data/date_translation_data/gl.py index 588edc111..fbb00f999 100644 --- a/dateparser/data/date_translation_data/gl.py +++ b/dateparser/data/date_translation_data/gl.py @@ -81,24 +81,25 @@ "pm" ], "year": [ - "a", - "ano" + "ano", + "a" ], "month": [ - "m", - "mes" + "mes", + "m" ], "week": [ "sem", "semana" ], "day": [ - "d", - "día" + "día", + "d" ], "hour": [ "h", - "hora" + "hora", + "horas" ], "minute": [ "min", @@ -113,14 +114,16 @@ "hoxe" ], "0 hour ago": [ + "esta hora", "nesta hora" ], "0 minute ago": [ + "este minuto", "neste minuto" ], "0 month ago": [ - "este m", - "este mes" + "este mes", + "este m" ], "0 second ago": [ "agora" @@ -136,38 +139,46 @@ "onte" ], "1 month ago": [ - "m pasado", - "o mes pasado" + "o mes pas", + "o mes pasado", + "m pasado" ], "1 week ago": [ + "a sem pas", + "a sem pasada", "a semana pasada", "sem pasada" ], "1 year ago": [ - "ano pasado", - "o ano pasado" + "o ano pas", + "o ano pasado", + "ano pasado" ], "in 1 day": [ "mañá" ], "in 1 month": [ - "m seguinte", - "o próximo mes" + "o próx mes", + "o próximo mes", + "m seguinte" ], "in 1 week": [ + "a próx sem", + "a próxima sem", "a próxima semana", "sem seguinte" ], "in 1 year": [ + "o próx ano", "o próximo ano", "seguinte ano" ] }, "relative-type-regex": { "\\1 day ago": [ - "hai (\\d++[.,]?\\d*+) d", "hai (\\d++[.,]?\\d*+) día", - "hai (\\d++[.,]?\\d*+) días" + "hai (\\d++[.,]?\\d*+) días", + "hai (\\d++[.,]?\\d*+) d" ], "\\1 hour ago": [ "hai (\\d++[.,]?\\d*+) h", @@ -180,9 +191,9 @@ "hai (\\d++[.,]?\\d*+) minutos" ], "\\1 month ago": [ - "hai (\\d++[.,]?\\d*+) m", "hai (\\d++[.,]?\\d*+) mes", - "hai (\\d++[.,]?\\d*+) meses" + "hai (\\d++[.,]?\\d*+) meses", + "hai (\\d++[.,]?\\d*+) m" ], "\\1 second ago": [ "hai (\\d++[.,]?\\d*+) s", @@ -195,14 +206,14 @@ "hai (\\d++[.,]?\\d*+) semanas" ], "\\1 year ago": [ - "hai (\\d++[.,]?\\d*+) a", "hai (\\d++[.,]?\\d*+) ano", - "hai (\\d++[.,]?\\d*+) anos" + "hai (\\d++[.,]?\\d*+) anos", + "hai (\\d++[.,]?\\d*+) a" ], "in \\1 day": [ - "en (\\d++[.,]?\\d*+) d", "en (\\d++[.,]?\\d*+) día", - "en (\\d++[.,]?\\d*+) días" + "en (\\d++[.,]?\\d*+) días", + "en (\\d++[.,]?\\d*+) d" ], "in \\1 hour": [ "en (\\d++[.,]?\\d*+) h", @@ -215,9 +226,9 @@ "en (\\d++[.,]?\\d*+) minutos" ], "in \\1 month": [ - "en (\\d++[.,]?\\d*+) m", "en (\\d++[.,]?\\d*+) mes", - "en (\\d++[.,]?\\d*+) meses" + "en (\\d++[.,]?\\d*+) meses", + "en (\\d++[.,]?\\d*+) m" ], "in \\1 second": [ "en (\\d++[.,]?\\d*+) s", @@ -230,9 +241,9 @@ "en (\\d++[.,]?\\d*+) semanas" ], "in \\1 year": [ - "en (\\d++[.,]?\\d*+) a", "en (\\d++[.,]?\\d*+) ano", - "en (\\d++[.,]?\\d*+) anos" + "en (\\d++[.,]?\\d*+) anos", + "en (\\d++[.,]?\\d*+) a" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/gsw.py b/dateparser/data/date_translation_data/gsw.py index b0e6fa9dd..f1fbcfcf0 100644 --- a/dateparser/data/date_translation_data/gsw.py +++ b/dateparser/data/date_translation_data/gsw.py @@ -99,6 +99,7 @@ "tag" ], "hour": [ + "hr", "schtund" ], "minute": [ diff --git a/dateparser/data/date_translation_data/gu.py b/dateparser/data/date_translation_data/gu.py index 86d362f7d..52cc3bbce 100644 --- a/dateparser/data/date_translation_data/gu.py +++ b/dateparser/data/date_translation_data/gu.py @@ -172,8 +172,8 @@ "(\\d++[.,]?\\d*+) અઠવાડિયા પહેલાં" ], "\\1 year ago": [ - "(\\d++[.,]?\\d*+) વર્ષ પહેલા", - "(\\d++[.,]?\\d*+) વર્ષ પહેલાં" + "(\\d++[.,]?\\d*+) વર્ષ પહેલાં", + "(\\d++[.,]?\\d*+) વર્ષ પહેલા" ], "in \\1 day": [ "(\\d++[.,]?\\d*+) દિવસમાં" diff --git a/dateparser/data/date_translation_data/guz.py b/dateparser/data/date_translation_data/guz.py index 68c32cd29..7cff5b47b 100644 --- a/dateparser/data/date_translation_data/guz.py +++ b/dateparser/data/date_translation_data/guz.py @@ -97,7 +97,8 @@ "rituko" ], "hour": [ - "ensa" + "ensa", + "hr" ], "minute": [ "edakika" diff --git a/dateparser/data/date_translation_data/gv.py b/dateparser/data/date_translation_data/gv.py index 88c3f5e54..341749fdb 100644 --- a/dateparser/data/date_translation_data/gv.py +++ b/dateparser/data/date_translation_data/gv.py @@ -93,7 +93,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/ha.py b/dateparser/data/date_translation_data/ha.py index 8b40bb625..0e5e50c26 100644 --- a/dateparser/data/date_translation_data/ha.py +++ b/dateparser/data/date_translation_data/ha.py @@ -78,9 +78,13 @@ "lahadi" ], "am": [ + "safiya", + "sf", "am" ], "pm": [ + "yamma", + "ym", "pm" ], "year": [ @@ -96,7 +100,8 @@ "kwana" ], "hour": [ - "awa" + "awa", + "sa'o'i" ], "minute": [ "minti" @@ -109,48 +114,112 @@ "yau" ], "0 hour ago": [ + "wannan awa", "this hour" ], "0 minute ago": [ + "wannan mintin", "this minute" ], "0 month ago": [ + "wannan watan", "this month" ], "0 second ago": [ + "yanzu", "now" ], "0 week ago": [ + "wannan satin", "this week" ], "0 year ago": [ + "bana", "this year" ], "1 day ago": [ "jiya" ], "1 month ago": [ + "watan da ya gabata", "last month" ], "1 week ago": [ + "satin da ya gabata", "last week" ], "1 year ago": [ + "bara", "last year" ], "in 1 day": [ "gobe" ], "in 1 month": [ + "wata na gaba", "next month" ], "in 1 week": [ + "sati na gaba", "next week" ], "in 1 year": [ + "badi", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "kwanaki da suka gabata (\\d++[.,]?\\d*+)", + "rana da ya gabata (\\d++[.,]?\\d*+)" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) awa da ya gabata" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) minti da ya gabata" + ], + "\\1 month ago": [ + "watan da ya gabata (\\d++[.,]?\\d*+)", + "watanni da suka gabata (\\d++[.,]?\\d*+)}" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) dakika da ya gabata" + ], + "\\1 week ago": [ + "mako da suka gabata (\\d++[.,]?\\d*+)", + "mako da ya gabata (\\d++[.,]?\\d*+)", + "makonni da suka gabata (\\d++[.,]?\\d*+)" + ], + "\\1 year ago": [ + "shekara da suka gabata (\\d++[.,]?\\d*+)" + ], + "in \\1 day": [ + "a cikin kwanaki (\\d++[.,]?\\d*+)", + "a cikin rana (\\d++[.,]?\\d*+)" + ], + "in \\1 hour": [ + "cikin (\\d++[.,]?\\d*+) awa" + ], + "in \\1 minute": [ + "cikin (\\d++[.,]?\\d*+) minti" + ], + "in \\1 month": [ + "a cikin watan (\\d++[.,]?\\d*+)", + "a cikin watanni (\\d++[.,]?\\d*+)" + ], + "in \\1 second": [ + "cikin (\\d++[.,]?\\d*+) dakika" + ], + "in \\1 week": [ + "a cikin mako (\\d++[.,]?\\d*+)", + "a cikin makonni (\\d++[.,]?\\d*+)" + ], + "in \\1 year": [ + "a shekarar (\\d++[.,]?\\d*+)", + "a shekaru (\\d++[.,]?\\d*+)" + ] + }, "locale_specific": { "ha-GH": { "name": "ha-GH" diff --git a/dateparser/data/date_translation_data/haw.py b/dateparser/data/date_translation_data/haw.py index 6865f314c..1ec35ef54 100644 --- a/dateparser/data/date_translation_data/haw.py +++ b/dateparser/data/date_translation_data/haw.py @@ -95,7 +95,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/he.py b/dateparser/data/date_translation_data/he.py index d933fcc91..0168175d8 100644 --- a/dateparser/data/date_translation_data/he.py +++ b/dateparser/data/date_translation_data/he.py @@ -126,9 +126,11 @@ "יום א" ], "am": [ + "am", "לפנה״צ" ], "pm": [ + "pm", "אחה״צ" ], "year": [ @@ -155,6 +157,7 @@ ], "hour": [ "שעה", + "שעות", "שע׳", "שעות" ], @@ -177,7 +180,8 @@ "בשעה זו" ], "0 minute ago": [ - "בדקה זו" + "בדקה זו", + "דקה זו" ], "0 month ago": [ "החודש" @@ -219,8 +223,8 @@ "relative-type-regex": { "\\1 day ago": [ "לפני (\\d++[.,]?\\d*+) ימים", - "לפני (\\d++[.,]?\\d*+) ימ׳", - "לפני יום (\\d++[.,]?\\d*+)" + "לפני יום (\\d++[.,]?\\d*+)", + "לפני (\\d++[.,]?\\d*+) ימ׳" ], "\\1 hour ago": [ "לפני (\\d++[.,]?\\d*+) שעות", @@ -247,8 +251,8 @@ ], "in \\1 day": [ "בעוד (\\d++[.,]?\\d*+) ימים", - "בעוד (\\d++[.,]?\\d*+) ימ׳", - "בעוד יום (\\d++[.,]?\\d*+)" + "בעוד יום (\\d++[.,]?\\d*+)", + "בעוד (\\d++[.,]?\\d*+) ימ׳" ], "in \\1 hour": [ "בעוד (\\d++[.,]?\\d*+) שעות", diff --git a/dateparser/data/date_translation_data/hi.py b/dateparser/data/date_translation_data/hi.py index 4a87df507..976d40665 100644 --- a/dateparser/data/date_translation_data/hi.py +++ b/dateparser/data/date_translation_data/hi.py @@ -78,9 +78,11 @@ "रविवार" ], "am": [ + "am", "पूर्वाह्न" ], "pm": [ + "pm", "अपराह्न" ], "year": [ @@ -102,17 +104,20 @@ "दिवस" ], "hour": [ - "घं", "घंटा", - "घंटे" + "घंटे", + "घं॰", + "घंटे", + "घं" ], "minute": [ - "मि", - "मिनट" + "मिनट", + "मि॰", + "मि" ], "second": [ - "से", - "सेकंड" + "सेकंड", + "से॰" ], "relative-type": { "0 day ago": [ @@ -134,10 +139,12 @@ "इस सप्ताह" ], "0 year ago": [ - "इस वर्ष" + "इस वर्ष", + "इस साल" ], "1 day ago": [ - "कल" + "कल", + "बीता कल" ], "1 month ago": [ "पिछला माह" @@ -146,9 +153,11 @@ "पिछला सप्ताह" ], "1 year ago": [ - "पिछला वर्ष" + "पिछला वर्ष", + "पिछले साल" ], "in 1 day": [ + "आने वाला कल", "कल" ], "in 1 month": [ @@ -158,7 +167,8 @@ "अगला सप्ताह" ], "in 1 year": [ - "अगला वर्ष" + "अगला वर्ष", + "अगले साल" ], "2 day ago": [ "परसों" @@ -175,19 +185,22 @@ "(\\d++[.,]?\\d*+) दिन पहले" ], "\\1 hour ago": [ - "(\\d++[.,]?\\d*+) घं पहले", - "(\\d++[.,]?\\d*+) घंटे पहले" + "(\\d++[.,]?\\d*+) घंटे पहले", + "(\\d++[.,]?\\d*+) घं॰ पहले", + "(\\d++[.,]?\\d*+) घं पहले" ], "\\1 minute ago": [ - "(\\d++[.,]?\\d*+) मि पहले", - "(\\d++[.,]?\\d*+) मिनट पहले" + "(\\d++[.,]?\\d*+) मिनट पहले", + "(\\d++[.,]?\\d*+) मि॰ पहले", + "(\\d++[.,]?\\d*+) मि पहले" ], "\\1 month ago": [ "(\\d++[.,]?\\d*+) माह पहले" ], "\\1 second ago": [ - "(\\d++[.,]?\\d*+) से पहले", - "(\\d++[.,]?\\d*+) सेकंड पहले" + "(\\d++[.,]?\\d*+) सेकंड पहले", + "(\\d++[.,]?\\d*+) से॰ पहले", + "(\\d++[.,]?\\d*+) से पहले" ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) सप्ताह पहले" @@ -199,19 +212,22 @@ "(\\d++[.,]?\\d*+) दिन में" ], "in \\1 hour": [ - "(\\d++[.,]?\\d*+) घं में", - "(\\d++[.,]?\\d*+) घंटे में" + "(\\d++[.,]?\\d*+) घंटे में", + "(\\d++[.,]?\\d*+) घं॰ में", + "(\\d++[.,]?\\d*+) घं में" ], "in \\1 minute": [ - "(\\d++[.,]?\\d*+) मि में", - "(\\d++[.,]?\\d*+) मिनट में" + "(\\d++[.,]?\\d*+) मिनट में", + "(\\d++[.,]?\\d*+) मि॰ में", + "(\\d++[.,]?\\d*+) मि में" ], "in \\1 month": [ "(\\d++[.,]?\\d*+) माह में" ], "in \\1 second": [ - "(\\d++[.,]?\\d*+) से में", - "(\\d++[.,]?\\d*+) सेकंड में" + "(\\d++[.,]?\\d*+) सेकंड में", + "(\\d++[.,]?\\d*+) से॰ में", + "(\\d++[.,]?\\d*+) से में" ], "in \\1 week": [ "(\\d++[.,]?\\d*+) सप्ताह में" diff --git a/dateparser/data/date_translation_data/hr.py b/dateparser/data/date_translation_data/hr.py index 60a6f38e8..75304991c 100644 --- a/dateparser/data/date_translation_data/hr.py +++ b/dateparser/data/date_translation_data/hr.py @@ -141,7 +141,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser/data/date_translation_data/hsb.py b/dateparser/data/date_translation_data/hsb.py index 1ea5a7161..0dcf14a50 100644 --- a/dateparser/data/date_translation_data/hsb.py +++ b/dateparser/data/date_translation_data/hsb.py @@ -90,9 +90,11 @@ "njedźela" ], "am": [ + "dop", "dopołdnja" ], "pm": [ + "pop", "popołdnju" ], "year": [ @@ -114,7 +116,8 @@ "hour": [ "h", "hodź", - "hodźina" + "hodźina", + "hodźiny" ], "minute": [ "m", @@ -128,48 +131,74 @@ ], "relative-type": { "0 day ago": [ + "dźe", + "dźens", "dźensa" ], "0 hour ago": [ + "w tutej hodźinje", "this hour" ], "0 minute ago": [ + "w tutej mjeńšinje", "this minute" ], "0 month ago": [ + "tu měsac", + "tut měsac", "tutón měsac" ], "0 second ago": [ - "now" + "nětko" ], "0 week ago": [ + "tu tydźeń", + "tut tydźeń", "tutón tydźeń" ], "0 year ago": [ + "lět", + "lěts", "lětsa" ], "1 day ago": [ + "wč", + "wčer", "wčera" ], "1 month ago": [ + "zaš měsac", + "zašł měsac", "zašły měsac" ], "1 week ago": [ + "zaš tydźeń", + "zašł tydźeń", "zašły tydźeń" ], "1 year ago": [ + "lo", + "lon", "loni" ], "in 1 day": [ + "jut", + "jutř", "jutře" ], "in 1 month": [ + "přich měsac", + "přichodn měsac", "přichodny měsac" ], "in 1 week": [ + "přich tydźeń", + "přichodn tydźeń", "přichodny tydźeń" ], "in 1 year": [ + "klě", + "klět", "klětu" ] }, diff --git a/dateparser/data/date_translation_data/hu.py b/dateparser/data/date_translation_data/hu.py index 3906bab29..ee7535c1e 100644 --- a/dateparser/data/date_translation_data/hu.py +++ b/dateparser/data/date_translation_data/hu.py @@ -124,6 +124,7 @@ "nappal" ], "hour": [ + "ó", "óra", "ó", "órák", @@ -133,6 +134,7 @@ "órától" ], "minute": [ + "p", "perc", "p", "percek", @@ -142,6 +144,7 @@ "perctől" ], "second": [ + "mp", "másodperc", "mp", "másodpercek", @@ -206,21 +209,27 @@ "(\\d++[.,]?\\d*+) nappal ezelőtt" ], "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) órája", "(\\d++[.,]?\\d*+) órával ezelőtt" ], "\\1 minute ago": [ - "(\\d++[.,]?\\d*+) perccel ezelőtt" + "(\\d++[.,]?\\d*+) perccel ezelőtt", + "(\\d++[.,]?\\d*+) perce" ], "\\1 month ago": [ + "(\\d++[.,]?\\d*+) hónapja", "(\\d++[.,]?\\d*+) hónappal ezelőtt" ], "\\1 second ago": [ + "(\\d++[.,]?\\d*+) mperce", "(\\d++[.,]?\\d*+) másodperccel ezelőtt" ], "\\1 week ago": [ + "(\\d++[.,]?\\d*+) hete", "(\\d++[.,]?\\d*+) héttel ezelőtt" ], "\\1 year ago": [ + "(\\d++[.,]?\\d*+) éve", "(\\d++[.,]?\\d*+) évvel ezelőtt" ], "in \\1 day": [ diff --git a/dateparser/data/date_translation_data/hy.py b/dateparser/data/date_translation_data/hy.py index 9ac4a9129..d0c0353f6 100644 --- a/dateparser/data/date_translation_data/hy.py +++ b/dateparser/data/date_translation_data/hy.py @@ -114,7 +114,8 @@ ], "hour": [ "ժ", - "ժամ" + "ժամ", + "ժամեր" ], "minute": [ "ր", @@ -138,6 +139,7 @@ "այս ամիս" ], "0 second ago": [ + "հիմա", "այժմ" ], "0 week ago": [ @@ -150,8 +152,8 @@ "երեկ" ], "1 month ago": [ - "անցյալ ամիս", - "նախորդ ամիս" + "նախորդ ամիս", + "անցյալ ամիս" ], "1 week ago": [ "նախորդ շաբաթ" diff --git a/dateparser/data/date_translation_data/id.py b/dateparser/data/date_translation_data/id.py index 73bd5b7b2..87152dad0 100644 --- a/dateparser/data/date_translation_data/id.py +++ b/dateparser/data/date_translation_data/id.py @@ -29,9 +29,10 @@ "juli" ], "august": [ - "agt", + "agu", "agustus", - "Agu" + "Agu", + "agt" ], "september": [ "sep", @@ -99,7 +100,8 @@ ], "day": [ "h", - "hari" + "hari", + "hr" ], "hour": [ "j", @@ -123,9 +125,11 @@ "jam ini" ], "0 minute ago": [ - "menit ini" + "menit ini", + "mnt ini" ], "0 month ago": [ + "bln ini", "bulan ini" ], "0 second ago": [ @@ -133,34 +137,43 @@ "baru saja" ], "0 week ago": [ + "mgg ini", "minggu ini" ], "0 year ago": [ - "tahun ini" + "tahun ini", + "thn ini" ], "1 day ago": [ "kemarin" ], "1 month ago": [ + "bln lalu", "bulan lalu" ], "1 week ago": [ + "mgg lalu", "minggu lalu" ], "1 year ago": [ - "tahun lalu" + "tahun lalu", + "thn lalu" ], "in 1 day": [ "besok" ], "in 1 month": [ + "bln berikutnya", + "bulan depan", "bulan berikutnya" ], "in 1 week": [ + "mgg depan", "minggu depan" ], "in 1 year": [ - "tahun depan" + "tahun depan", + "thn depan" ], "1 year": [ "setahun" @@ -215,7 +228,8 @@ "dalam (\\d++[.,]?\\d*+) hari" ], "in \\1 hour": [ - "dalam (\\d++[.,]?\\d*+) jam" + "dalam (\\d++[.,]?\\d*+) jam", + "dlm (\\d++[.,]?\\d*+) jam" ], "in \\1 minute": [ "dalam (\\d++[.,]?\\d*+) menit", diff --git a/dateparser/data/date_translation_data/ig.py b/dateparser/data/date_translation_data/ig.py index e88bac8a4..ec6c67070 100644 --- a/dateparser/data/date_translation_data/ig.py +++ b/dateparser/data/date_translation_data/ig.py @@ -15,6 +15,7 @@ ], "april": [ "epr", + "epreel", "eprel" ], "may": [ @@ -73,13 +74,17 @@ "satọdee" ], "sunday": [ + "sọn", + "sọndee", "mbọsị ụka", "ụka" ], "am": [ - "am" + "am", + "n'ụtụtụ" ], "pm": [ + "n'abali", "pm" ], "year": [ @@ -95,58 +100,74 @@ "ụbọchị" ], "hour": [ - "elekere" + "elekere", + "hr" ], "minute": [ "nkeji" ], "second": [ + "tịm kọm", "nkejinta" ], "relative-type": { "0 day ago": [ + "taa", "taata" ], "0 hour ago": [ + "elekere a", "this hour" ], "0 minute ago": [ + "nkejị a", "this minute" ], "0 month ago": [ + "ọnwa a", "this month" ], "0 second ago": [ + "ụgbụa", "now" ], "0 week ago": [ + "izu a", "this week" ], "0 year ago": [ + "afọ a", "this year" ], "1 day ago": [ + "ụnyaahụ", "nnyaafụ" ], "1 month ago": [ + "ọnwa gara aga", "last month" ], "1 week ago": [ + "izu gara aga", "last week" ], "1 year ago": [ + "afọ gara aga", "last year" ], "in 1 day": [ "echi" ], "in 1 month": [ + "ọnwa ọzọ", "next month" ], "in 1 week": [ + "izu na-esote", "next week" ], "in 1 year": [ + "afọ ọzọ", "next year" ] }, diff --git a/dateparser/data/date_translation_data/ii.py b/dateparser/data/date_translation_data/ii.py index 9db7a906d..463c59f65 100644 --- a/dateparser/data/date_translation_data/ii.py +++ b/dateparser/data/date_translation_data/ii.py @@ -84,6 +84,7 @@ "ꑍ" ], "hour": [ + "hr", "ꄮꈉ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/is.py b/dateparser/data/date_translation_data/is.py index ac499759d..d4a9b076b 100644 --- a/dateparser/data/date_translation_data/is.py +++ b/dateparser/data/date_translation_data/is.py @@ -94,12 +94,13 @@ "vika" ], "day": [ - "d", - "dagur" + "dagur", + "d" ], "hour": [ "klst", - "klukkustund" + "klukkustund", + "klukkustundir" ], "minute": [ "mín", @@ -114,9 +115,11 @@ "í dag" ], "0 hour ago": [ + "þessa stundina", "this hour" ], "0 minute ago": [ + "á þessari mínútu", "this minute" ], "0 month ago": [ diff --git a/dateparser/data/date_translation_data/it.py b/dateparser/data/date_translation_data/it.py index ef56aaeeb..0362b3678 100644 --- a/dateparser/data/date_translation_data/it.py +++ b/dateparser/data/date_translation_data/it.py @@ -104,19 +104,20 @@ "hour": [ "h", "ora", + "ore", "ore" ], "minute": [ - "m", "min", "minuto", - "minuti" + "minuti", + "m" ], "second": [ "s", - "sec", "secondo", - "secondi" + "secondi", + "sec" ], "relative-type": { "0 day ago": [ @@ -135,6 +136,7 @@ "ora" ], "0 week ago": [ + "questa sett", "questa settimana" ], "0 year ago": [ @@ -147,6 +149,7 @@ "mese scorso" ], "1 week ago": [ + "sett scorsa", "settimana scorsa" ], "1 year ago": [ @@ -159,6 +162,7 @@ "mese prossimo" ], "in 1 week": [ + "sett prossima", "settimana prossima" ], "in 1 year": [ diff --git a/dateparser/data/date_translation_data/ja.py b/dateparser/data/date_translation_data/ja.py index 38a2d3667..40717f854 100644 --- a/dateparser/data/date_translation_data/ja.py +++ b/dateparser/data/date_translation_data/ja.py @@ -109,6 +109,7 @@ ], "hour": [ "時", + "時間", "時間" ], "minute": [ @@ -159,12 +160,15 @@ "明日" ], "in 1 month": [ + "来月", "翌月" ], "in 1 week": [ + "来週", "翌週" ], "in 1 year": [ + "来年", "翌年" ], "2 day ago": [ diff --git a/dateparser/data/date_translation_data/jgo.py b/dateparser/data/date_translation_data/jgo.py index b19873d96..7a33ad4c3 100644 --- a/dateparser/data/date_translation_data/jgo.py +++ b/dateparser/data/date_translation_data/jgo.py @@ -77,7 +77,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/jmc.py b/dateparser/data/date_translation_data/jmc.py index 7c06f3175..8df005c1c 100644 --- a/dateparser/data/date_translation_data/jmc.py +++ b/dateparser/data/date_translation_data/jmc.py @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kab.py b/dateparser/data/date_translation_data/kab.py index fa74984a8..320fcbb8f 100644 --- a/dateparser/data/date_translation_data/kab.py +++ b/dateparser/data/date_translation_data/kab.py @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tamert" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kam.py b/dateparser/data/date_translation_data/kam.py index 5479d6b3d..d7df94de9 100644 --- a/dateparser/data/date_translation_data/kam.py +++ b/dateparser/data/date_translation_data/kam.py @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kde.py b/dateparser/data/date_translation_data/kde.py index 9cffae61d..7edb4a4eb 100644 --- a/dateparser/data/date_translation_data/kde.py +++ b/dateparser/data/date_translation_data/kde.py @@ -96,6 +96,7 @@ "lihiku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kea.py b/dateparser/data/date_translation_data/kea.py index 2bcb4bee9..8e2ad5d4d 100644 --- a/dateparser/data/date_translation_data/kea.py +++ b/dateparser/data/date_translation_data/kea.py @@ -71,8 +71,8 @@ ], "saturday": [ "sab", - "sabadu", - "sábadu" + "sábadu", + "sabadu" ], "sunday": [ "dum", @@ -116,15 +116,18 @@ "oji" ], "0 hour ago": [ + "es ora li", "this hour" ], "0 minute ago": [ + "es minutu li", "this minute" ], "0 month ago": [ "es mes li" ], "0 second ago": [ + "agora", "now" ], "0 week ago": [ @@ -146,6 +149,7 @@ "anu pasadu" ], "in 1 day": [ + "manhan", "manha" ], "in 1 month": [ diff --git a/dateparser/data/date_translation_data/khq.py b/dateparser/data/date_translation_data/khq.py index d707ae00b..b9a90fd55 100644 --- a/dateparser/data/date_translation_data/khq.py +++ b/dateparser/data/date_translation_data/khq.py @@ -94,7 +94,8 @@ "jaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser/data/date_translation_data/ki.py b/dateparser/data/date_translation_data/ki.py index 45224f847..29c8c3e93 100644 --- a/dateparser/data/date_translation_data/ki.py +++ b/dateparser/data/date_translation_data/ki.py @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "ithaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kl.py b/dateparser/data/date_translation_data/kl.py index 8dab1db59..91836c91c 100644 --- a/dateparser/data/date_translation_data/kl.py +++ b/dateparser/data/date_translation_data/kl.py @@ -3,50 +3,76 @@ "date_order": "YMD", "january": [ "jan", + "januaari", + "januaarip", "januari" ], "february": [ + "febr", + "februaari", + "februaarip", "feb", "februari" ], "march": [ "mar", + "marsi", + "marsip", "martsi" ], "april": [ "apr", + "apriili", + "apriilip", "aprili" ], "may": [ + "maaji", + "maajip", "maj", "maji" ], "june": [ "jun", + "juuni", + "juunip", "juni" ], "july": [ "jul", + "juuli", + "juulip", "juli" ], "august": [ + "aggusti", + "aggustip", "aug", "augustusi" ], "september": [ + "sept", + "septembari", + "septembarip", "sep", "septemberi" ], "october": [ "okt", + "oktobari", + "oktobarip", "oktoberi" ], "november": [ "nov", + "novembari", + "novembarip", "novemberi" ], "december": [ "dec", + "decembari", + "decembarip", "decemberi" ], "monday": [ @@ -74,6 +100,8 @@ "arfininngorneq" ], "sunday": [ + "sap", + "sapaat", "sab", "sabaat" ], @@ -96,7 +124,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/kln.py b/dateparser/data/date_translation_data/kln.py index 0eec0d7a4..4e1b2d7a3 100644 --- a/dateparser/data/date_translation_data/kln.py +++ b/dateparser/data/date_translation_data/kln.py @@ -98,6 +98,7 @@ "betut" ], "hour": [ + "hr", "sait" ], "minute": [ diff --git a/dateparser/data/date_translation_data/km.py b/dateparser/data/date_translation_data/km.py index ec4b526b3..279e71bab 100644 --- a/dateparser/data/date_translation_data/km.py +++ b/dateparser/data/date_translation_data/km.py @@ -38,6 +38,7 @@ "ធ្នូ" ], "monday": [ + "ចន្ទ", "ច័ន្ទ" ], "tuesday": [ @@ -47,6 +48,7 @@ "ពុធ" ], "thursday": [ + "ព្រហ", "ព្រហស្បតិ៍" ], "friday": [ diff --git a/dateparser/data/date_translation_data/kn.py b/dateparser/data/date_translation_data/kn.py index 83a4c0b6a..3259a790c 100644 --- a/dateparser/data/date_translation_data/kn.py +++ b/dateparser/data/date_translation_data/kn.py @@ -92,7 +92,8 @@ "ದಿನ" ], "hour": [ - "ಗಂಟೆ" + "ಗಂಟೆ", + "ಗಂಟೆಗಳು" ], "minute": [ "ನಿಮಿಷ" diff --git a/dateparser/data/date_translation_data/ko.py b/dateparser/data/date_translation_data/ko.py index c817bac83..beb6dfc0c 100644 --- a/dateparser/data/date_translation_data/ko.py +++ b/dateparser/data/date_translation_data/ko.py @@ -86,7 +86,8 @@ "일" ], "hour": [ - "시" + "시", + "시간" ], "minute": [ "분" @@ -191,6 +192,9 @@ ] }, "locale_specific": { + "ko-CN": { + "name": "ko-CN" + }, "ko-KP": { "name": "ko-KP" } diff --git a/dateparser/data/date_translation_data/kok.py b/dateparser/data/date_translation_data/kok.py index 6422aaaea..4a631c234 100644 --- a/dateparser/data/date_translation_data/kok.py +++ b/dateparser/data/date_translation_data/kok.py @@ -1,16 +1,20 @@ info = { "name": "kok", - "date_order": "YMD", + "date_order": "DMY", "january": [ + "जाने", "जानेवारी" ], "february": [ + "फेब्रु", "फेब्रुवारी" ], "march": [ "मार्च" ], "april": [ + "एप्री", + "एप्रील", "एप्रिल" ], "may": [ @@ -20,125 +24,214 @@ "जून" ], "july": [ + "जुल", + "जुलय", "जुलै" ], "august": [ + "ऑग", + "ऑगस्ट", "ओगस्ट" ], "september": [ + "सप्टें", + "सप्टेंबर", "सेप्टेंबर" ], "october": [ + "ऑक्टो", + "ऑक्टोबर", "ओक्टोबर" ], "november": [ + "नो", "नोव्हेंबर" ], "december": [ + "डिसे", "डिसेंबर" ], "monday": [ + "सोमार", "सोम", "सोमवार" ], "tuesday": [ - "मंगळ", - "मंगळार" + "मंगळार", + "मंगळ" ], "wednesday": [ - "बुध", - "बुधवार" + "बुधवार", + "बुध" ], "thursday": [ + "बिरेस्तार", "गुरु", "गुरुवार" ], "friday": [ + "शुक्रार", "शुक्र", "शुक्रवार" ], "saturday": [ + "शेनवार", "शनि", "शनिवार" ], "sunday": [ + "आयतार", "आदित्यवार", "रवि" ], "am": [ + "am", + "सकाळ", "मपू" ], "pm": [ + "pm", + "सांज", "मनं" ], "year": [ + "वर्स", "year" ], "month": [ + "म्हयनो", "month" ], "week": [ + "सप्तक", "week" ], "day": [ + "दीस", "day" ], "hour": [ + "वर", + "वरां", "hour" ], "minute": [ + "मिनीट", "minute" ], "second": [ + "सेकंद", "second" ], "relative-type": { "0 day ago": [ + "आयज", "today" ], "0 hour ago": [ + "हें वर", "this hour" ], "0 minute ago": [ + "हें मिनीट", "this minute" ], "0 month ago": [ + "हो म्हयनो", "this month" ], "0 second ago": [ + "आतां", "now" ], "0 week ago": [ + "हो सप्तक", "this week" ], "0 year ago": [ + "हें वर्स", "this year" ], "1 day ago": [ + "काल", "yesterday" ], "1 month ago": [ + "फाटलो म्हयनो", "last month" ], "1 week ago": [ + "निमाणो सप्तक", "last week" ], "1 year ago": [ + "फाटलें वर्स", "last year" ], "in 1 day": [ + "फाल्यां", "tomorrow" ], "in 1 month": [ + "फुडलो म्हयनो", "next month" ], "in 1 week": [ + "फुडलो सप्तक", "next week" ], "in 1 year": [ + "फुडलें वर्स", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) दीस आदीं" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) वरा आदीं" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) मिन्टां आदीं" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) म्हयन्यां आदीं" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) से आदीं", + "(\\d++[.,]?\\d*+) सेकंद आदीं" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) सप्त आदीं", + "(\\d++[.,]?\\d*+) सप्तकां आदीं" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) वर्स आदीं", + "(\\d++[.,]?\\d*+) वर्सां आदीं" + ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) दिसानीं" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) वरांनीं" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) मिन्टां" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) म्हयन्यानीं" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) सेकंदानीं" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) सप्तकांनीं" + ], + "in \\1 year": [ + "(\\d++[.,]?\\d*+) वर्सांनीं" + ] + }, "locale_specific": {}, "skip": [ " ", diff --git a/dateparser/data/date_translation_data/ks.py b/dateparser/data/date_translation_data/ks.py index 9f9955a50..bba7908a5 100644 --- a/dateparser/data/date_translation_data/ks.py +++ b/dateparser/data/date_translation_data/ks.py @@ -14,13 +14,15 @@ "اپریل" ], "may": [ + "مئی", "میٔ" ], "june": [ "جوٗن" ], "july": [ - "جوٗلایی" + "جوٗلایی", + "جُلَے" ], "august": [ "اگست" @@ -35,19 +37,24 @@ "نومبر" ], "december": [ - "دسمبر" + "دسمبر", + "دَسَمبَر" ], "monday": [ + "ژٔندرٕروار", + "ژٔندٕروار", "ژٔنٛدرٕروار", "ژٔنٛدٕروار" ], "tuesday": [ + "بۆموار", "بوٚموار" ], "wednesday": [ "بودوار" ], "thursday": [ + "برؠسوار", "برٛٮ۪سوار" ], "friday": [ @@ -61,15 +68,18 @@ "اَتھوار" ], "am": [ - "am" + "am", + "اے ایم" ], "pm": [ - "pm" + "pm", + "پی ایم" ], "year": [ "ؤری" ], "month": [ + "رؠتھ", "رٮ۪تھ" ], "week": [ @@ -79,12 +89,15 @@ "دۄہ" ], "hour": [ + "hr", + "گٲنٹہٕ", "گٲنٛٹہٕ" ], "minute": [ "مِنَٹ" ], "second": [ + "سؠکَنڈ", "سٮ۪کَنڑ" ], "relative-type": { @@ -98,39 +111,48 @@ "this minute" ], "0 month ago": [ + "یٕہ ریتھۍ", "this month" ], "0 second ago": [ "now" ], "0 week ago": [ + "یٕہ ہفتہ", "this week" ], "0 year ago": [ + "یٕہ ؤری", "this year" ], "1 day ago": [ "راتھ" ], "1 month ago": [ + "پٔتِم ریتھۍ", "last month" ], "1 week ago": [ + "پٔتِم ہفتہ", "last week" ], "1 year ago": [ + "پٔتِم ؤری", "last year" ], "in 1 day": [ "پگاہ" ], "in 1 month": [ + "نو ریتھۍ", "next month" ], "in 1 week": [ + "نو ہفتہ", "next week" ], "in 1 year": [ + "نو ؤری", "next year" ] }, diff --git a/dateparser/data/date_translation_data/ksb.py b/dateparser/data/date_translation_data/ksb.py index 7858d0d87..e12826389 100644 --- a/dateparser/data/date_translation_data/ksb.py +++ b/dateparser/data/date_translation_data/ksb.py @@ -95,6 +95,7 @@ "siku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ksf.py b/dateparser/data/date_translation_data/ksf.py index 341309dbf..a57622a0b 100644 --- a/dateparser/data/date_translation_data/ksf.py +++ b/dateparser/data/date_translation_data/ksf.py @@ -96,7 +96,8 @@ "ŋwós" ], "hour": [ - "cámɛɛn" + "cámɛɛn", + "hr" ], "minute": [ "mǝnít" diff --git a/dateparser/data/date_translation_data/ksh.py b/dateparser/data/date_translation_data/ksh.py index d915b2723..e540fc195 100644 --- a/dateparser/data/date_translation_data/ksh.py +++ b/dateparser/data/date_translation_data/ksh.py @@ -105,6 +105,7 @@ "hour": [ "s", "schtund", + "schtunde", "std" ], "minute": [ diff --git a/dateparser/data/date_translation_data/kw.py b/dateparser/data/date_translation_data/kw.py index 6bc8a1453..995a898e9 100644 --- a/dateparser/data/date_translation_data/kw.py +++ b/dateparser/data/date_translation_data/kw.py @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/ky.py b/dateparser/data/date_translation_data/ky.py index 42d6c3efb..ff397deb8 100644 --- a/dateparser/data/date_translation_data/ky.py +++ b/dateparser/data/date_translation_data/ky.py @@ -147,6 +147,7 @@ "былтыр" ], "in 1 day": [ + "эртең", "эртеӊ" ], "in 1 month": [ diff --git a/dateparser/data/date_translation_data/lag.py b/dateparser/data/date_translation_data/lag.py index b27c0e556..de84e07ac 100644 --- a/dateparser/data/date_translation_data/lag.py +++ b/dateparser/data/date_translation_data/lag.py @@ -96,6 +96,7 @@ "sikʉ" ], "hour": [ + "hr", "sáa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/lb.py b/dateparser/data/date_translation_data/lb.py index b5ac7a61a..48fca68dc 100644 --- a/dateparser/data/date_translation_data/lb.py +++ b/dateparser/data/date_translation_data/lb.py @@ -100,7 +100,8 @@ ], "hour": [ "st", - "stonn" + "stonn", + "stonnen" ], "minute": [ "min", diff --git a/dateparser/data/date_translation_data/lg.py b/dateparser/data/date_translation_data/lg.py index 9c62fc81a..9b570e4a3 100644 --- a/dateparser/data/date_translation_data/lg.py +++ b/dateparser/data/date_translation_data/lg.py @@ -96,6 +96,7 @@ "lunaku" ], "hour": [ + "hr", "saawa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/lkt.py b/dateparser/data/date_translation_data/lkt.py index dbedd2715..8ade421dd 100644 --- a/dateparser/data/date_translation_data/lkt.py +++ b/dateparser/data/date_translation_data/lkt.py @@ -1,6 +1,6 @@ info = { "name": "lkt", - "date_order": "YMD", + "date_order": "MDY", "january": [ "wiótheȟika wí" ], @@ -77,6 +77,7 @@ "aŋpétu" ], "hour": [ + "hr", "owápȟe" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ln.py b/dateparser/data/date_translation_data/ln.py index 4e4de0a4c..ee1ad0349 100644 --- a/dateparser/data/date_translation_data/ln.py +++ b/dateparser/data/date_translation_data/ln.py @@ -96,6 +96,7 @@ "mokɔlɔ" ], "hour": [ + "hr", "ngonga" ], "minute": [ diff --git a/dateparser/data/date_translation_data/lo.py b/dateparser/data/date_translation_data/lo.py index 83160ff74..af9e7f316 100644 --- a/dateparser/data/date_translation_data/lo.py +++ b/dateparser/data/date_translation_data/lo.py @@ -191,8 +191,9 @@ "ໃນອີກ (\\d++[.,]?\\d*+) ຊົ່ວໂມງ" ], "in \\1 minute": [ - "(\\d++[.,]?\\d*+) ໃນອີກ 0 ນາທີ", - "ໃນ (\\d++[.,]?\\d*+) ນທ" + "ໃນ (\\d++[.,]?\\d*+) ນທ", + "ໃນອີກ (\\d++[.,]?\\d*+) ນາທີ", + "(\\d++[.,]?\\d*+) ໃນອີກ 0 ນາທີ" ], "in \\1 month": [ "ໃນອີກ (\\d++[.,]?\\d*+) ດ", diff --git a/dateparser/data/date_translation_data/lrc.py b/dateparser/data/date_translation_data/lrc.py index ee432f5ee..05b341e79 100644 --- a/dateparser/data/date_translation_data/lrc.py +++ b/dateparser/data/date_translation_data/lrc.py @@ -77,6 +77,7 @@ "روٙز" ], "hour": [ + "hr", "ساأت" ], "minute": [ diff --git a/dateparser/data/date_translation_data/lt.py b/dateparser/data/date_translation_data/lt.py index 464cf6cea..ad3ef1b21 100644 --- a/dateparser/data/date_translation_data/lt.py +++ b/dateparser/data/date_translation_data/lt.py @@ -114,7 +114,8 @@ "hour": [ "h", "val", - "valanda" + "valanda", + "valandos" ], "minute": [ "min", diff --git a/dateparser/data/date_translation_data/lu.py b/dateparser/data/date_translation_data/lu.py index 62d10bba7..06d9a0d9b 100644 --- a/dateparser/data/date_translation_data/lu.py +++ b/dateparser/data/date_translation_data/lu.py @@ -96,7 +96,8 @@ "dituku" ], "hour": [ - "diba" + "diba", + "hr" ], "minute": [ "kasunsu" diff --git a/dateparser/data/date_translation_data/luo.py b/dateparser/data/date_translation_data/luo.py index 19798d9f7..a01a251e5 100644 --- a/dateparser/data/date_translation_data/luo.py +++ b/dateparser/data/date_translation_data/luo.py @@ -96,6 +96,7 @@ "chieng'" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/luy.py b/dateparser/data/date_translation_data/luy.py index 5fc38b56e..1fbc67e44 100644 --- a/dateparser/data/date_translation_data/luy.py +++ b/dateparser/data/date_translation_data/luy.py @@ -95,6 +95,7 @@ "ridiku" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/lv.py b/dateparser/data/date_translation_data/lv.py index 8ed540f2a..ca0a20436 100644 --- a/dateparser/data/date_translation_data/lv.py +++ b/dateparser/data/date_translation_data/lv.py @@ -127,39 +127,48 @@ "šajā minūtē" ], "0 month ago": [ + "šajā mēn", "šajā mēnesī" ], "0 second ago": [ "tagad" ], "0 week ago": [ + "šajā ned", "šajā nedēļā" ], "0 year ago": [ + "šajā g", "šajā gadā" ], "1 day ago": [ "vakar" ], "1 month ago": [ + "pag mēn", "pagājušajā mēnesī" ], "1 week ago": [ + "pag ned", "pagājušajā nedēļā" ], "1 year ago": [ + "pag gadā", "pagājušajā gadā" ], "in 1 day": [ "rīt" ], "in 1 month": [ + "nāk mēn", "nākamajā mēnesī" ], "in 1 week": [ + "nāk ned", "nākamajā nedēļā" ], "in 1 year": [ + "nāk gadā", "nākamajā gadā" ] }, diff --git a/dateparser/data/date_translation_data/mas.py b/dateparser/data/date_translation_data/mas.py index 6efd2de13..6a2df5966 100644 --- a/dateparser/data/date_translation_data/mas.py +++ b/dateparser/data/date_translation_data/mas.py @@ -96,6 +96,7 @@ "ɛnkɔlɔ́ŋ" ], "hour": [ + "hr", "ɛ́sáâ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/mer.py b/dateparser/data/date_translation_data/mer.py index 0901e1a47..617f649ab 100644 --- a/dateparser/data/date_translation_data/mer.py +++ b/dateparser/data/date_translation_data/mer.py @@ -95,6 +95,7 @@ "ntukũ" ], "hour": [ + "hr", "ĩthaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/mfe.py b/dateparser/data/date_translation_data/mfe.py index fc418155a..d84bf357a 100644 --- a/dateparser/data/date_translation_data/mfe.py +++ b/dateparser/data/date_translation_data/mfe.py @@ -93,6 +93,7 @@ "zour" ], "hour": [ + "hr", "ler" ], "minute": [ diff --git a/dateparser/data/date_translation_data/mg.py b/dateparser/data/date_translation_data/mg.py index 754beb34b..72b9ce371 100644 --- a/dateparser/data/date_translation_data/mg.py +++ b/dateparser/data/date_translation_data/mg.py @@ -95,6 +95,7 @@ "andro" ], "hour": [ + "hr", "ora" ], "minute": [ diff --git a/dateparser/data/date_translation_data/mgh.py b/dateparser/data/date_translation_data/mgh.py index e0dba84eb..573fc3b7a 100644 --- a/dateparser/data/date_translation_data/mgh.py +++ b/dateparser/data/date_translation_data/mgh.py @@ -96,6 +96,7 @@ "nihuku" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/mgo.py b/dateparser/data/date_translation_data/mgo.py index 0ff37bb27..2b9839939 100644 --- a/dateparser/data/date_translation_data/mgo.py +++ b/dateparser/data/date_translation_data/mgo.py @@ -78,7 +78,8 @@ "anəg" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/mk.py b/dateparser/data/date_translation_data/mk.py index 875619585..9ed46c548 100644 --- a/dateparser/data/date_translation_data/mk.py +++ b/dateparser/data/date_translation_data/mk.py @@ -33,16 +33,18 @@ "август" ], "september": [ - "септ", - "септември" + "сеп", + "септември", + "септ" ], "october": [ "окт", "октомври" ], "november": [ - "ноем", - "ноември" + "ное", + "ноември", + "ноем" ], "december": [ "дек", @@ -53,9 +55,9 @@ "понеделник" ], "tuesday": [ - "вт", "вто", - "вторник" + "вторник", + "вт" ], "wednesday": [ "сре", @@ -94,14 +96,16 @@ "месец" ], "week": [ - "недела", - "сед" + "сед", + "седмица" ], "day": [ "ден" ], "hour": [ - "час" + "ч", + "час", + "часа" ], "minute": [ "мин", @@ -131,6 +135,7 @@ "оваа седмица" ], "0 year ago": [ + "оваа год", "оваа година" ], "1 day ago": [ @@ -143,6 +148,8 @@ "минатата седмица" ], "1 year ago": [ + "лани", + "минатата год", "минатата година" ], "in 1 day": [ @@ -155,6 +162,8 @@ "следната седмица" ], "in 1 year": [ + "догодина", + "следната год", "следната година" ] }, @@ -168,6 +177,7 @@ "пред (\\d++[.,]?\\d*+) часа" ], "\\1 minute ago": [ + "пред (\\d++[.,]?\\d*+) мин", "пред (\\d++[.,]?\\d*+) минута", "пред (\\d++[.,]?\\d*+) минути" ], @@ -176,6 +186,7 @@ "пред (\\d++[.,]?\\d*+) месеци" ], "\\1 second ago": [ + "пред (\\d++[.,]?\\d*+) сек", "пред (\\d++[.,]?\\d*+) секунда", "пред (\\d++[.,]?\\d*+) секунди" ], @@ -184,6 +195,7 @@ "пред (\\d++[.,]?\\d*+) седмици" ], "\\1 year ago": [ + "пред (\\d++[.,]?\\d*+) год", "пред (\\d++[.,]?\\d*+) година", "пред (\\d++[.,]?\\d*+) години" ], @@ -196,6 +208,7 @@ "за (\\d++[.,]?\\d*+) часа" ], "in \\1 minute": [ + "за (\\d++[.,]?\\d*+) мин", "за (\\d++[.,]?\\d*+) минута", "за (\\d++[.,]?\\d*+) минути" ], @@ -204,6 +217,7 @@ "за (\\d++[.,]?\\d*+) месеци" ], "in \\1 second": [ + "за (\\d++[.,]?\\d*+) сек", "за (\\d++[.,]?\\d*+) секунда", "за (\\d++[.,]?\\d*+) секунди" ], @@ -212,6 +226,7 @@ "за (\\d++[.,]?\\d*+) седмици" ], "in \\1 year": [ + "за (\\d++[.,]?\\d*+) год", "за (\\d++[.,]?\\d*+) година", "за (\\d++[.,]?\\d*+) години" ] diff --git a/dateparser/data/date_translation_data/mn.py b/dateparser/data/date_translation_data/mn.py index f8729bac6..484977e9b 100644 --- a/dateparser/data/date_translation_data/mn.py +++ b/dateparser/data/date_translation_data/mn.py @@ -23,10 +23,12 @@ ], "june": [ "6-р сар", + "зургаадугаар сар", "зургадугаар сар" ], "july": [ "7-р сар", + "долоодугаар сар", "долдугаар сар" ], "august": [ @@ -90,8 +92,9 @@ "сар" ], "week": [ - "7х", - "долоо хоног" + "7 хоног", + "долоо хоног", + "7х" ], "day": [ "өдөр" @@ -125,6 +128,7 @@ "одоо" ], "0 week ago": [ + "энэ 7 хоног", "энэ долоо хоног" ], "0 year ago": [ @@ -137,6 +141,7 @@ "өнгөрсөн сар" ], "1 week ago": [ + "өнгөрсөн 7 хоног", "өнгөрсөн долоо хоног" ], "1 year ago": [ @@ -149,6 +154,7 @@ "ирэх сар" ], "in 1 week": [ + "ирэх 7 хоног", "ирэх долоо хоног" ], "in 1 year": [ @@ -175,6 +181,8 @@ "(\\d++[.,]?\\d*+) секундын өмнө" ], "\\1 week ago": [ + "(\\d++[.,]?\\d*+) 7 хоногийн өмнө", + "(\\d++[.,]?\\d*+) долоо хоногийн өмнө", "(\\d++[.,]?\\d*+) 7х-ийн өмнө" ], "\\1 year ago": [ @@ -200,6 +208,8 @@ "(\\d++[.,]?\\d*+) секундын дараа" ], "in \\1 week": [ + "(\\d++[.,]?\\d*+) 7 хоногийн дараа", + "(\\d++[.,]?\\d*+) долоо хоногийн дараа", "(\\d++[.,]?\\d*+) 7х-ийн дараа" ], "in \\1 year": [ diff --git a/dateparser/data/date_translation_data/mr.py b/dateparser/data/date_translation_data/mr.py index ef2fc785a..d1960ed0b 100644 --- a/dateparser/data/date_translation_data/mr.py +++ b/dateparser/data/date_translation_data/mr.py @@ -74,24 +74,30 @@ "रविवार" ], "am": [ + "am", "मपू" ], "pm": [ + "pm", "मउ" ], "year": [ "वर्ष" ], "month": [ + "म", "महिना" ], "week": [ + "आठ", "आठवडा" ], "day": [ + "दि", "दिवस" ], "hour": [ + "ता", "तास" ], "minute": [ @@ -182,11 +188,15 @@ ], "in \\1 day": [ "(\\d++[.,]?\\d*+) दिवसांमध्ये", - "(\\d++[.,]?\\d*+) दिवसामध्ये" + "(\\d++[.,]?\\d*+) दिवसामध्ये", + "येत्या (\\d++[.,]?\\d*+) दिवसांमध्ये", + "येत्या (\\d++[.,]?\\d*+) दिवसामध्ये" ], "in \\1 hour": [ "(\\d++[.,]?\\d*+) तासांमध्ये", - "(\\d++[.,]?\\d*+) तासामध्ये" + "(\\d++[.,]?\\d*+) तासामध्ये", + "येत्या (\\d++[.,]?\\d*+) तासांमध्ये", + "येत्या (\\d++[.,]?\\d*+) तासामध्ये" ], "in \\1 minute": [ "(\\d++[.,]?\\d*+) मिनि मध्ये", @@ -195,20 +205,27 @@ ], "in \\1 month": [ "(\\d++[.,]?\\d*+) महिन्यांमध्ये", - "(\\d++[.,]?\\d*+) महिन्यामध्ये" + "(\\d++[.,]?\\d*+) महिन्यामध्ये", + "येत्या (\\d++[.,]?\\d*+) महिन्यांमध्ये", + "येत्या (\\d++[.,]?\\d*+) महिन्यामध्ये" ], "in \\1 second": [ "(\\d++[.,]?\\d*+) से मध्ये", "(\\d++[.,]?\\d*+) सेकंदांमध्ये", - "(\\d++[.,]?\\d*+) सेकंदामध्ये" + "(\\d++[.,]?\\d*+) सेकंदामध्ये", + "येत्या (\\d++[.,]?\\d*+) से मध्ये" ], "in \\1 week": [ "(\\d++[.,]?\\d*+) आठवड्यांमध्ये", - "(\\d++[.,]?\\d*+) आठवड्यामध्ये" + "(\\d++[.,]?\\d*+) आठवड्यामध्ये", + "येत्या (\\d++[.,]?\\d*+) आठवड्यांमध्ये", + "येत्या (\\d++[.,]?\\d*+) आठवड्यामध्ये" ], "in \\1 year": [ "(\\d++[.,]?\\d*+) वर्षांमध्ये", - "(\\d++[.,]?\\d*+) वर्षामध्ये" + "(\\d++[.,]?\\d*+) वर्षामध्ये", + "येत्या (\\d++[.,]?\\d*+) वर्षांमध्ये", + "येत्या (\\d++[.,]?\\d*+) वर्षामध्ये" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/ms.py b/dateparser/data/date_translation_data/ms.py index fb8670850..eb2d66b9b 100644 --- a/dateparser/data/date_translation_data/ms.py +++ b/dateparser/data/date_translation_data/ms.py @@ -123,6 +123,7 @@ "sekarang" ], "0 week ago": [ + "mgu ini", "minggu ini", "mng ini" ], @@ -139,6 +140,7 @@ "bulan lalu" ], "1 week ago": [ + "mgu lepas", "minggu lalu", "mng lepas" ], @@ -154,6 +156,7 @@ "bulan depan" ], "in 1 week": [ + "mgu depan", "minggu depan", "mng depan" ], @@ -213,7 +216,7 @@ "dlm (\\d++[.,]?\\d*+) mgu" ], "in \\1 year": [ - "dalam (\\d++[.,]?\\d*+) saat", + "dalam (\\d++[.,]?\\d*+) tahun", "dalam (\\d++[.,]?\\d*+) thn" ] }, @@ -221,6 +224,9 @@ "ms-BN": { "name": "ms-BN" }, + "ms-ID": { + "name": "ms-ID" + }, "ms-SG": { "name": "ms-SG" } diff --git a/dateparser/data/date_translation_data/mt.py b/dateparser/data/date_translation_data/mt.py index bc6c487d4..ab7cbfe93 100644 --- a/dateparser/data/date_translation_data/mt.py +++ b/dateparser/data/date_translation_data/mt.py @@ -84,24 +84,31 @@ "pm" ], "year": [ - "sena" + "sena", + "sn" ], "month": [ "xahar" ], "week": [ - "ġimgħa" + "ġimgħa", + "ġm" ], "day": [ "jum" ], "hour": [ + "hr", "siegħa" ], "minute": [ + "m", + "min", "minuta" ], "second": [ + "s", + "sek", "sekonda" ], "relative-type": { @@ -109,15 +116,18 @@ "illum" ], "0 hour ago": [ + "din is-siegħa", "this hour" ], "0 minute ago": [ + "din il-minuta", "this minute" ], "0 month ago": [ "dan ix-xahar" ], "0 second ago": [ + "issa", "now" ], "0 week ago": [ @@ -127,6 +137,7 @@ "din is-sena" ], "1 day ago": [ + "lbieraħ", "ilbieraħ" ], "1 month ago": [ @@ -136,6 +147,7 @@ "il-ġimgħa li għaddiet" ], "1 year ago": [ + "is-sena l-oħra", "is-sena li għaddiet" ], "in 1 day": [ @@ -152,9 +164,53 @@ ] }, "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) ġurnata ilu" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) siegħa ilu" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) min ilu", + "(\\d++[.,]?\\d*+) minuta ilu" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) xahar ilu" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) sek ilu", + "(\\d++[.,]?\\d*+) sekonda ilu" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) ġimgħa ilu" + ], "\\1 year ago": [ "(\\d++[.,]?\\d*+) sena ilu", "(\\d++[.,]?\\d*+) snin ilu" + ], + "in \\1 day": [ + "fi żmien (\\d++[.,]?\\d*+) ġurnata oħra" + ], + "in \\1 hour": [ + "fi żmien (\\d++[.,]?\\d*+) siegħa" + ], + "in \\1 minute": [ + "sa (\\d++[.,]?\\d*+) min oħra", + "sa (\\d++[.,]?\\d*+) minuta oħra" + ], + "in \\1 month": [ + "fi (\\d++[.,]?\\d*+) xahar oħra", + "sa (\\d++[.,]?\\d*+) xahar oħra" + ], + "in \\1 second": [ + "sa (\\d++[.,]?\\d*+) sek oħra", + "sa (\\d++[.,]?\\d*+) sekonda oħra" + ], + "in \\1 week": [ + "sa (\\d++[.,]?\\d*+) ġimgħa oħra" + ], + "in \\1 year": [ + "fi żmien (\\d++[.,]?\\d*+) sena oħra" ] }, "locale_specific": {}, diff --git a/dateparser/data/date_translation_data/mua.py b/dateparser/data/date_translation_data/mua.py index dd81cc556..ff42f2744 100644 --- a/dateparser/data/date_translation_data/mua.py +++ b/dateparser/data/date_translation_data/mua.py @@ -96,7 +96,8 @@ "zah'nane/ comme" ], "hour": [ - "cok comme" + "cok comme", + "hr" ], "minute": [ "cok comme ma laŋne" diff --git a/dateparser/data/date_translation_data/naq.py b/dateparser/data/date_translation_data/naq.py index c69358061..b83e7b5ca 100644 --- a/dateparser/data/date_translation_data/naq.py +++ b/dateparser/data/date_translation_data/naq.py @@ -96,6 +96,7 @@ "tsees" ], "hour": [ + "hr", "iiri" ], "minute": [ diff --git a/dateparser/data/date_translation_data/nb.py b/dateparser/data/date_translation_data/nb.py index 1a78faa5b..944c7a61a 100644 --- a/dateparser/data/date_translation_data/nb.py +++ b/dateparser/data/date_translation_data/nb.py @@ -104,6 +104,7 @@ "hour": [ "t", "time", + "timer", "timer" ], "minute": [ diff --git a/dateparser/data/date_translation_data/nd.py b/dateparser/data/date_translation_data/nd.py index c01d8dc7b..33e7f345d 100644 --- a/dateparser/data/date_translation_data/nd.py +++ b/dateparser/data/date_translation_data/nd.py @@ -96,6 +96,7 @@ "ilanga" ], "hour": [ + "hr", "ihola" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ne.py b/dateparser/data/date_translation_data/ne.py index 296ef07a5..0570f229a 100644 --- a/dateparser/data/date_translation_data/ne.py +++ b/dateparser/data/date_translation_data/ne.py @@ -14,8 +14,8 @@ "अप्रिल" ], "may": [ - "मई", - "मे" + "मे", + "मई" ], "june": [ "जुन" @@ -73,8 +73,8 @@ "अपराह्न" ], "year": [ - "बर्ष", - "वर्ष" + "वर्ष", + "बर्ष" ], "month": [ "महिना" @@ -99,6 +99,7 @@ "आज" ], "0 hour ago": [ + "यस घडीमा", "यो घडीमा" ], "0 minute ago": [ @@ -108,6 +109,7 @@ "यो महिना" ], "0 second ago": [ + "अहिले", "अब" ], "0 week ago": [ @@ -132,12 +134,15 @@ "भोलि" ], "in 1 month": [ - "अर्को महिना" + "अर्को महिना", + "आगामी महिना" ], "in 1 week": [ + "आगामी हप्ता", "आउने हप्ता" ], "in 1 year": [ + "आगामी वर्ष", "अर्को वर्ष" ] }, @@ -155,6 +160,7 @@ "(\\d++[.,]?\\d*+) महिना पहिले" ], "\\1 second ago": [ + "(\\d++[.,]?\\d*+) सेकेन्ड पहिले", "(\\d++[.,]?\\d*+) सेकेण्ड पहिले" ], "\\1 week ago": [ @@ -176,6 +182,7 @@ "(\\d++[.,]?\\d*+) महिनामा" ], "in \\1 second": [ + "(\\d++[.,]?\\d*+) सेकेन्डमा", "(\\d++[.,]?\\d*+) सेकेण्डमा" ], "in \\1 week": [ diff --git a/dateparser/data/date_translation_data/nl.py b/dateparser/data/date_translation_data/nl.py index 376a5274e..8325bb98f 100644 --- a/dateparser/data/date_translation_data/nl.py +++ b/dateparser/data/date_translation_data/nl.py @@ -101,6 +101,7 @@ "dagen" ], "hour": [ + "u", "uur" ], "minute": [ diff --git a/dateparser/data/date_translation_data/nmg.py b/dateparser/data/date_translation_data/nmg.py index d1fd4de9b..8a35df35d 100644 --- a/dateparser/data/date_translation_data/nmg.py +++ b/dateparser/data/date_translation_data/nmg.py @@ -96,6 +96,7 @@ "duö" ], "hour": [ + "hr", "wulā" ], "minute": [ diff --git a/dateparser/data/date_translation_data/nn.py b/dateparser/data/date_translation_data/nn.py index 593e8c9e8..b27419735 100644 --- a/dateparser/data/date_translation_data/nn.py +++ b/dateparser/data/date_translation_data/nn.py @@ -95,21 +95,30 @@ "år" ], "month": [ + "md", "månad" ], "week": [ + "v", "veke" ], "day": [ + "d", "dag" ], "hour": [ + "t", + "timar", "time" ], "minute": [ + "m", + "min", "minutt" ], "second": [ + "s", + "sek", "sekund" ], "relative-type": { @@ -117,95 +126,143 @@ "i dag" ], "0 hour ago": [ + "denne timen", "this hour" ], "0 minute ago": [ + "dette minuttet", "this minute" ], "0 month ago": [ + "denne md", + "denne månaden", "this month" ], "0 second ago": [ + "no", "now" ], "0 week ago": [ + "denne veka", "this week" ], "0 year ago": [ + "i år", "this year" ], "1 day ago": [ "i går" ], "1 month ago": [ + "førre md", + "førre månad", "last month" ], "1 week ago": [ + "førre veke", "last week" ], "1 year ago": [ + "i fjor", "last year" ], "in 1 day": [ "i morgon" ], "in 1 month": [ + "neste md", + "neste månad", "next month" ], "in 1 week": [ + "neste veke", "next week" ], "in 1 year": [ + "neste år", "next year" ] }, "relative-type-regex": { "\\1 day ago": [ + "for (\\d++[.,]?\\d*+) d sidan", + "for (\\d++[.,]?\\d*+) døgn sidan", + "–(\\d++[.,]?\\d*+) d", "for (\\d++[.,]?\\d*+) døgn siden" ], "\\1 hour ago": [ + "for (\\d++[.,]?\\d*+) t sidan", + "for (\\d++[.,]?\\d*+) timar sidan", + "for (\\d++[.,]?\\d*+) time sidan", + "–(\\d++[.,]?\\d*+) t", "for (\\d++[.,]?\\d*+) time siden", "for (\\d++[.,]?\\d*+) timer siden" ], "\\1 minute ago": [ + "for (\\d++[.,]?\\d*+) min sidan", + "for (\\d++[.,]?\\d*+) minutt sidan", + "–(\\d++[.,]?\\d*+) min", "for (\\d++[.,]?\\d*+) minutt siden", "for (\\d++[.,]?\\d*+) minutter siden" ], "\\1 month ago": [ + "for (\\d++[.,]?\\d*+) md sidan", + "for (\\d++[.,]?\\d*+) månad sidan", + "for (\\d++[.,]?\\d*+) månadar sidan", + "–(\\d++[.,]?\\d*+) md", "for (\\d++[.,]?\\d*+) måned siden", "for (\\d++[.,]?\\d*+) måneder siden" ], "\\1 second ago": [ + "for (\\d++[.,]?\\d*+) sek sidan", + "for (\\d++[.,]?\\d*+) sekund sidan", + "–(\\d++[.,]?\\d*+) s", "for (\\d++[.,]?\\d*+) sekund siden", "for (\\d++[.,]?\\d*+) sekunder siden" ], "\\1 week ago": [ + "for (\\d++[.,]?\\d*+) v sidan", + "for (\\d++[.,]?\\d*+) veke sidan", + "for (\\d++[.,]?\\d*+) veker sidan", + "–(\\d++[.,]?\\d*+) v", "for (\\d++[.,]?\\d*+) uke siden", "for (\\d++[.,]?\\d*+) uker siden" ], "\\1 year ago": [ + "for (\\d++[.,]?\\d*+) år sidan", "for (\\d++[.,]?\\d*+) år siden" ], "in \\1 day": [ + "om (\\d++[.,]?\\d*+) d", "om (\\d++[.,]?\\d*+) døgn" ], "in \\1 hour": [ + "om (\\d++[.,]?\\d*+) t", + "om (\\d++[.,]?\\d*+) timar", "om (\\d++[.,]?\\d*+) time", "om (\\d++[.,]?\\d*+) timer" ], "in \\1 minute": [ + "om (\\d++[.,]?\\d*+) min", "om (\\d++[.,]?\\d*+) minutt", "om (\\d++[.,]?\\d*+) minutter" ], "in \\1 month": [ + "om (\\d++[.,]?\\d*+) md", + "om (\\d++[.,]?\\d*+) månad", + "om (\\d++[.,]?\\d*+) månadar", "om (\\d++[.,]?\\d*+) måned", "om (\\d++[.,]?\\d*+) måneder" ], "in \\1 second": [ + "om (\\d++[.,]?\\d*+) sek", "om (\\d++[.,]?\\d*+) sekund", "om (\\d++[.,]?\\d*+) sekunder" ], "in \\1 week": [ + "om (\\d++[.,]?\\d*+) v", + "om (\\d++[.,]?\\d*+) veke", + "om (\\d++[.,]?\\d*+) veker", "om (\\d++[.,]?\\d*+) uke", "om (\\d++[.,]?\\d*+) uker" ], diff --git a/dateparser/data/date_translation_data/nnh.py b/dateparser/data/date_translation_data/nnh.py index 5f2284e67..eabe9cbbd 100644 --- a/dateparser/data/date_translation_data/nnh.py +++ b/dateparser/data/date_translation_data/nnh.py @@ -77,7 +77,8 @@ "lyɛ̌'" ], "hour": [ - "fʉ̀' nèm" + "fʉ̀' nèm", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/nus.py b/dateparser/data/date_translation_data/nus.py index 8910752c5..4187fc37a 100644 --- a/dateparser/data/date_translation_data/nus.py +++ b/dateparser/data/date_translation_data/nus.py @@ -93,6 +93,7 @@ "cäŋ" ], "hour": [ + "hr", "thaak" ], "minute": [ diff --git a/dateparser/data/date_translation_data/nyn.py b/dateparser/data/date_translation_data/nyn.py index dbd3301ce..8b4208b94 100644 --- a/dateparser/data/date_translation_data/nyn.py +++ b/dateparser/data/date_translation_data/nyn.py @@ -96,6 +96,7 @@ "eizooba" ], "hour": [ + "hr", "shaaha" ], "minute": [ diff --git a/dateparser/data/date_translation_data/om.py b/dateparser/data/date_translation_data/om.py index c4af00c3f..ffcd120b9 100644 --- a/dateparser/data/date_translation_data/om.py +++ b/dateparser/data/date_translation_data/om.py @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/or.py b/dateparser/data/date_translation_data/or.py index 0c190e96c..0c20320e5 100644 --- a/dateparser/data/date_translation_data/or.py +++ b/dateparser/data/date_translation_data/or.py @@ -1,6 +1,6 @@ info = { "name": "or", - "date_order": "DMY", + "date_order": "MDY", "january": [ "ଜାନୁଆରୀ" ], @@ -66,79 +66,165 @@ "ରବିବାର" ], "am": [ - "am" + "am", + "ପୂର୍ବାହ୍ନ" ], "pm": [ - "pm" + "pm", + "ଅପରାହ୍ନ" ], "year": [ + "ବ", + "ବର୍ଷ", "year" ], "month": [ + "ମା", + "ମାସ", "month" ], "week": [ + "ସ", + "ସପ୍ତାହ", "week" ], "day": [ + "ଦିନ", "day" ], "hour": [ + "ଘ", + "ଘଣ୍ଟା", "hour" ], "minute": [ + "ମି", + "ମିନିଟ୍", "minute" ], "second": [ + "ସେ", + "ସେକେଣ୍ଡ୍", "second" ], "relative-type": { "0 day ago": [ + "ଆଜି", "today" ], "0 hour ago": [ + "ଏହି ଘଣ୍ଟା", "this hour" ], "0 minute ago": [ + "ଏହି ମିନିଟ୍", "this minute" ], "0 month ago": [ + "ଏହି ମାସ", "this month" ], "0 second ago": [ + "ବର୍ତ୍ତମାନ", "now" ], "0 week ago": [ + "ଏହି ସପ୍ତାହ", "this week" ], "0 year ago": [ + "ଏହି ବର୍ଷ", "this year" ], "1 day ago": [ + "ଗତକାଲି", "yesterday" ], "1 month ago": [ + "ଗତ ମାସ", "last month" ], "1 week ago": [ + "ଗତ ସପ୍ତାହ", "last week" ], "1 year ago": [ + "ଗତ ବର୍ଷ", "last year" ], "in 1 day": [ + "ଆସନ୍ତାକାଲି", "tomorrow" ], "in 1 month": [ + "ଆଗାମୀ ମାସ", "next month" ], "in 1 week": [ + "ଆଗାମୀ ସପ୍ତାହ", "next week" ], "in 1 year": [ + "ଆଗାମୀ ବର୍ଷ", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) ଦିନ ପୂର୍ବେ" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) ଘ ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ଘଣ୍ଟା ପୂର୍ବେ" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) ମି ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ମିନିଟ୍ ପୂର୍ବେ" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) ମା ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ମାସ ପୂର୍ବେ" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) ସେ ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ସେକେଣ୍ଡ ପୂର୍ବେ" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) ସପ୍ତା ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ସପ୍ତାହ ପୂର୍ବେ" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) ବ ପୂର୍ବେ", + "(\\d++[.,]?\\d*+) ବର୍ଷ ପୂର୍ବେ" + ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) ଦିନରେ" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) ଘ ରେ", + "(\\d++[.,]?\\d*+) ଘଣ୍ଟାରେ" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) ମି ରେ", + "(\\d++[.,]?\\d*+) ମିନିଟ୍‌‌ରେ" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) ମା ରେ", + "(\\d++[.,]?\\d*+) ମାସରେ" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) ସେ ରେ", + "(\\d++[.,]?\\d*+) ସେକେଣ୍ଡରେ" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) ସପ୍ତା ରେ", + "(\\d++[.,]?\\d*+) ସପ୍ତାହରେ" + ], + "in \\1 year": [ + "(\\d++[.,]?\\d*+) ବ ରେ", + "(\\d++[.,]?\\d*+) ବର୍ଷରେ" + ] + }, "locale_specific": {}, "skip": [ " ", diff --git a/dateparser/data/date_translation_data/os.py b/dateparser/data/date_translation_data/os.py index 07cad7333..6164d1d16 100644 --- a/dateparser/data/date_translation_data/os.py +++ b/dateparser/data/date_translation_data/os.py @@ -111,7 +111,8 @@ "бон" ], "hour": [ - "сахат" + "сахат", + "сахаты" ], "minute": [ "минут" diff --git a/dateparser/data/date_translation_data/pa-Arab.py b/dateparser/data/date_translation_data/pa-Arab.py index 542582910..34238284a 100644 --- a/dateparser/data/date_translation_data/pa-Arab.py +++ b/dateparser/data/date_translation_data/pa-Arab.py @@ -77,6 +77,7 @@ "دئن" ], "hour": [ + "hr", "گھنٹا" ], "minute": [ diff --git a/dateparser/data/date_translation_data/pa-Guru.py b/dateparser/data/date_translation_data/pa-Guru.py index 91fe08f7c..a8fcd1924 100644 --- a/dateparser/data/date_translation_data/pa-Guru.py +++ b/dateparser/data/date_translation_data/pa-Guru.py @@ -94,7 +94,8 @@ ], "hour": [ "ਘੰ", - "ਘੰਟਾ" + "ਘੰਟਾ", + "ਘੰਟੇ" ], "minute": [ "ਮਿੰਟ" diff --git a/dateparser/data/date_translation_data/pa.py b/dateparser/data/date_translation_data/pa.py index 2914543ee..e9319f8a8 100644 --- a/dateparser/data/date_translation_data/pa.py +++ b/dateparser/data/date_translation_data/pa.py @@ -94,7 +94,8 @@ ], "hour": [ "ਘੰ", - "ਘੰਟਾ" + "ਘੰਟਾ", + "ਘੰਟੇ" ], "minute": [ "ਮਿੰਟ" diff --git a/dateparser/data/date_translation_data/pl.py b/dateparser/data/date_translation_data/pl.py index 5158a9738..4ce6bcb5d 100644 --- a/dateparser/data/date_translation_data/pl.py +++ b/dateparser/data/date_translation_data/pl.py @@ -212,6 +212,8 @@ "tygodnie" ], "day": [ + "d", + "dz", "dzień", "dzien", "dnia", @@ -222,6 +224,7 @@ "g", "godz", "godzina", + "godziny", "godzinę", "godzine", "godzin", @@ -246,7 +249,8 @@ ], "relative-type": { "0 day ago": [ - "dzisiaj" + "dzisiaj", + "dziś" ], "0 hour ago": [ "ta godzina" @@ -255,24 +259,29 @@ "ta minuta" ], "0 month ago": [ + "w tym mies", "w tym miesiącu" ], "0 second ago": [ "teraz" ], "0 week ago": [ + "w tym tyg", "w tym tygodniu" ], "0 year ago": [ "w tym roku" ], "1 day ago": [ + "wcz", "wczoraj" ], "1 month ago": [ + "w zeszłym mies", "w zeszłym miesiącu" ], "1 week ago": [ + "w zeszłym tyg", "w zeszłym tygodniu" ], "1 year ago": [ @@ -282,9 +291,11 @@ "jutro" ], "in 1 month": [ + "w przyszłym mies", "w przyszłym miesiącu" ], "in 1 week": [ + "w przyszłym tyg", "w przyszłym tygodniu" ], "in 1 year": [ diff --git a/dateparser/data/date_translation_data/ps.py b/dateparser/data/date_translation_data/ps.py index 01fc7c6d5..a692caaa7 100644 --- a/dateparser/data/date_translation_data/ps.py +++ b/dateparser/data/date_translation_data/ps.py @@ -5,7 +5,8 @@ "جنوري" ], "february": [ - "فبروري" + "فبروري", + "فېبروري" ], "march": [ "مارچ" @@ -26,7 +27,8 @@ "اګست" ], "september": [ - "سپتمبر" + "سپتمبر", + "سېپتمبر" ], "october": [ "اکتوبر" @@ -38,101 +40,209 @@ "دسمبر" ], "monday": [ + "دونۍ", "دوشنبه" ], "tuesday": [ + "درېنۍ", "سه‌شنبه" ], "wednesday": [ + "څلرنۍ", "چهارشنبه" ], "thursday": [ + "پينځنۍ", "پنجشنبه" ], "friday": [ "جمعه" ], "saturday": [ + "اونۍ", "شنبه" ], "sunday": [ + "يونۍ", "یکشنبه" ], "am": [ + "am", "غم" ], "pm": [ + "pm", "غو" ], "year": [ + "کال", "year" ], "month": [ + "مياشت", "month" ], "week": [ + "اونۍ", "week" ], "day": [ + "ورځ", "day" ], "hour": [ + "ساعت", + "ساعتونه", "hour" ], "minute": [ + "دقيقه", "minute" ], "second": [ + "ثانيه", "second" ], "relative-type": { "0 day ago": [ + "نن", "today" ], "0 hour ago": [ + "دا ساعت", "this hour" ], "0 minute ago": [ + "دا دقيقه", "this minute" ], "0 month ago": [ + "دا مياشت", "this month" ], "0 second ago": [ + "اوس", "now" ], "0 week ago": [ + "دا اونۍ", "this week" ], "0 year ago": [ + "سږ کال", + "سږکال", "this year" ], "1 day ago": [ + "پرون", "yesterday" ], "1 month ago": [ + "تېره مياشت", "last month" ], "1 week ago": [ + "تيره اونۍ", + "تېره اونۍ", "last week" ], "1 year ago": [ + "تير کال", + "تېر کال", + "پروسږکال", "last year" ], "in 1 day": [ + "سبا", "tomorrow" ], "in 1 month": [ + "راتلونکې مياشت", "next month" ], "in 1 week": [ + "راتلونکې اونۍ", "next week" ], "in 1 year": [ + "راتلونکی کال", + "روتلونکی کال", "next year" ] }, - "locale_specific": {}, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) ورځ مخکې", + "(\\d++[.,]?\\d*+) ورځې مخکې" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) ساعت مخکې", + "(\\d++[.,]?\\d*+) ساعتونه مخکې" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) دقيقه مخکې", + "(\\d++[.,]?\\d*+) دقيقې مخکې" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) مياشت مخکې", + "(\\d++[.,]?\\d*+) مياشتې مخکې" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) ثانيه مخکې", + "(\\d++[.,]?\\d*+) ثانيه کې", + "(\\d++[.,]?\\d*+) ثانيې مخکې" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) اونۍ مخکې" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) کال مخکې", + "(\\d++[.,]?\\d*+) کاله مخکې" + ], + "in \\1 day": [ + "په (\\d++[.,]?\\d*+) ورځ کې", + "په (\\d++[.,]?\\d*+) ورځو کې" + ], + "in \\1 hour": [ + "په (\\d++[.,]?\\d*+) ساعت کې", + "په (\\d++[.,]?\\d*+) ساعتو کې" + ], + "in \\1 minute": [ + "په (\\d++[.,]?\\d*+) دقيقه کې", + "په (\\d++[.,]?\\d*+) دقيقو کې" + ], + "in \\1 month": [ + "په (\\d++[.,]?\\d*+) مياشت کې", + "په (\\d++[.,]?\\d*+) مياشتو کې" + ], + "in \\1 second": [ + "په (\\d++[.,]?\\d*+) ثانيه کې", + "په (\\d++[.,]?\\d*+) ثانيو کې" + ], + "in \\1 week": [ + "په (\\d++[.,]?\\d*+) اونيو کې", + "په (\\d++[.,]?\\d*+) اونۍ کې" + ], + "in \\1 year": [ + "په (\\d++[.,]?\\d*+) کال کې", + "په (\\d++[.,]?\\d*+) کالونو کې" + ] + }, + "locale_specific": { + "ps-PK": { + "name": "ps-PK", + "relative-type-regex": { + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) کال مخکے", + "(\\d++[.,]?\\d*+) کاله مخکے" + ], + "in \\1 year": [ + "په (\\d++[.,]?\\d*+) کال کے", + "په (\\d++[.,]?\\d*+) کالونو کے" + ] + } + } + }, "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/pt.py b/dateparser/data/date_translation_data/pt.py index 366b5bca4..43ca9b3b3 100644 --- a/dateparser/data/date_translation_data/pt.py +++ b/dateparser/data/date_translation_data/pt.py @@ -110,19 +110,20 @@ "hour": [ "h", "hora", + "horas", "horas" ], "minute": [ - "m", "min", "minuto", - "minutos" + "minutos", + "m" ], "second": [ - "s", "seg", "segundo", - "segundos" + "segundos", + "s" ], "relative-type": { "0 day ago": [ @@ -186,9 +187,9 @@ ], "\\1 minute ago": [ "há (\\d++[.,]?\\d*+) min", - "há (\\d++[.,]?\\d*+) mins", "há (\\d++[.,]?\\d*+) minuto", - "há (\\d++[.,]?\\d*+) minutos" + "há (\\d++[.,]?\\d*+) minutos", + "há (\\d++[.,]?\\d*+) mins" ], "\\1 month ago": [ "há (\\d++[.,]?\\d*+) meses", @@ -219,9 +220,9 @@ ], "in \\1 minute": [ "em (\\d++[.,]?\\d*+) min", - "em (\\d++[.,]?\\d*+) mins", "em (\\d++[.,]?\\d*+) minuto", - "em (\\d++[.,]?\\d*+) minutos" + "em (\\d++[.,]?\\d*+) minutos", + "em (\\d++[.,]?\\d*+) mins" ], "in \\1 month": [ "em (\\d++[.,]?\\d*+) meses", @@ -229,9 +230,9 @@ ], "in \\1 second": [ "em (\\d++[.,]?\\d*+) seg", - "em (\\d++[.,]?\\d*+) segs", "em (\\d++[.,]?\\d*+) segundo", - "em (\\d++[.,]?\\d*+) segundos" + "em (\\d++[.,]?\\d*+) segundos", + "em (\\d++[.,]?\\d*+) segs" ], "in \\1 week": [ "em (\\d++[.,]?\\d*+) sem", @@ -269,6 +270,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -332,6 +336,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -395,6 +402,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -458,6 +468,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -521,6 +534,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -584,6 +600,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -647,6 +666,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -710,6 +732,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -773,6 +798,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -836,6 +864,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" @@ -899,6 +930,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há (\\d++[.,]?\\d*+) s" diff --git a/dateparser/data/date_translation_data/qu.py b/dateparser/data/date_translation_data/qu.py index d741cc899..b281a44d5 100644 --- a/dateparser/data/date_translation_data/qu.py +++ b/dateparser/data/date_translation_data/qu.py @@ -2,50 +2,74 @@ "name": "qu", "date_order": "DMY", "january": [ + "ene", + "enero", "qul", "qulla puquy" ], "february": [ + "feb", + "febrero", "hat", "hatun puquy" ], "march": [ + "mar", + "marzo", "pau", "pauqar waray" ], "april": [ + "abr", + "abril", "ayr", "ayriwa" ], "may": [ + "may", + "mayo", "aym", "aymuray" ], "june": [ + "jun", + "junio", "int", "inti raymi" ], "july": [ + "jul", + "julio", "ant", "anta sitwa" ], "august": [ + "ago", + "agosto", "qha", "qhapaq sitwa" ], "september": [ + "set", + "setiembre", "uma", "uma raymi" ], "october": [ + "oct", + "octubre", "kan", "kantaray" ], "november": [ + "nov", + "noviembre", "aya", "ayamarq'a" ], "december": [ + "dic", + "diciembre", "kap", "kapaq raymi" ], @@ -96,6 +120,7 @@ "day" ], "hour": [ + "hora", "hour" ], "minute": [ @@ -106,48 +131,62 @@ ], "relative-type": { "0 day ago": [ + "kunan punchaw", "today" ], "0 hour ago": [ + "kay hora", "this hour" ], "0 minute ago": [ + "kay minuto", "this minute" ], "0 month ago": [ + "kunan killa", "this month" ], "0 second ago": [ "now" ], "0 week ago": [ + "kunan semana", "this week" ], "0 year ago": [ + "kunan wata", "this year" ], "1 day ago": [ + "qayna punchaw", "yesterday" ], "1 month ago": [ + "qayna killa", "last month" ], "1 week ago": [ + "qayna semana", "last week" ], "1 year ago": [ + "qayna wata", "last year" ], "in 1 day": [ + "paqarin", "tomorrow" ], "in 1 month": [ + "hamuq killa", "next month" ], "in 1 week": [ + "hamuq semana", "next week" ], "in 1 year": [ + "hamuq wata", "next year" ] }, diff --git a/dateparser/data/date_translation_data/rm.py b/dateparser/data/date_translation_data/rm.py index 3fb858f90..e874974b3 100644 --- a/dateparser/data/date_translation_data/rm.py +++ b/dateparser/data/date_translation_data/rm.py @@ -2,47 +2,59 @@ "name": "rm", "date_order": "DMY", "january": [ + "da schaner", "schan", "schaner" ], "february": [ + "da favrer", "favr", "favrer" ], "march": [ + "da mars", "mars" ], "april": [ "avr", - "avrigl" + "avrigl", + "d'avrigl" ], "may": [ + "da matg", "matg" ], "june": [ + "da zercladur", "zercl", "zercladur" ], "july": [ + "da fanadur", "fan", "fanadur" ], "august": [ - "avust" + "avust", + "d'avust" ], "september": [ + "da settember", "sett", "settember" ], "october": [ + "d'october", "oct", "october" ], "november": [ + "da november", "nov", "november" ], "december": [ + "da december", "dec", "december" ], @@ -90,15 +102,20 @@ "emna" ], "day": [ + "d", + "di", "tag" ], "hour": [ - "ura" + "ura", + "uras" ], "minute": [ + "min", "minuta" ], "second": [ + "s", "secunda" ], "relative-type": { @@ -121,6 +138,7 @@ "this week" ], "0 year ago": [ + "quest onn", "this year" ], "1 day ago": [ @@ -133,6 +151,7 @@ "last week" ], "1 year ago": [ + "l'onn passà", "last year" ], "in 1 day": [ @@ -145,6 +164,7 @@ "next week" ], "in 1 year": [ + "l'onn proxim", "next year" ] }, diff --git a/dateparser/data/date_translation_data/rn.py b/dateparser/data/date_translation_data/rn.py index 5a557babe..c2951c7a2 100644 --- a/dateparser/data/date_translation_data/rn.py +++ b/dateparser/data/date_translation_data/rn.py @@ -96,6 +96,7 @@ "umusi" ], "hour": [ + "hr", "isaha" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ro.py b/dateparser/data/date_translation_data/ro.py index 181f53dc8..e07355b4a 100644 --- a/dateparser/data/date_translation_data/ro.py +++ b/dateparser/data/date_translation_data/ro.py @@ -106,6 +106,7 @@ ], "hour": [ "h", + "ore", "oră", "ore" ], @@ -138,6 +139,7 @@ "acum" ], "0 week ago": [ + "săpt aceasta", "săptămâna aceasta" ], "0 year ago": [ @@ -150,6 +152,7 @@ "luna trecută" ], "1 week ago": [ + "săpt trecută", "săptămâna trecută" ], "1 year ago": [ @@ -162,6 +165,7 @@ "luna viitoare" ], "in 1 week": [ + "săpt viitoare", "săptămâna viitoare" ], "in 1 year": [ @@ -235,8 +239,8 @@ ], "in \\1 year": [ "peste (\\d++[.,]?\\d*+) an", - "peste (\\d++[.,]?\\d*+) ani", - "peste (\\d++[.,]?\\d*+) de ani" + "peste (\\d++[.,]?\\d*+) de ani", + "peste (\\d++[.,]?\\d*+) ani" ] }, "locale_specific": { diff --git a/dateparser/data/date_translation_data/rof.py b/dateparser/data/date_translation_data/rof.py index 958c869ac..1967b29e3 100644 --- a/dateparser/data/date_translation_data/rof.py +++ b/dateparser/data/date_translation_data/rof.py @@ -84,6 +84,7 @@ "mfiri" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ru.py b/dateparser/data/date_translation_data/ru.py index c22f24351..ea6a819c8 100644 --- a/dateparser/data/date_translation_data/ru.py +++ b/dateparser/data/date_translation_data/ru.py @@ -103,9 +103,11 @@ "вск" ], "am": [ + "am", "дп" ], "pm": [ + "pm", "пп" ], "year": [ @@ -139,6 +141,7 @@ "hour": [ "ч", "час", + "часы", "часа", "часов" ], @@ -162,45 +165,64 @@ "сегодня" ], "0 hour ago": [ + "в этот час", "в этом часе" ], "0 minute ago": [ "в эту минуту" ], "0 month ago": [ + "в эт мес", + "в этом мес", "в этом месяце" ], "0 second ago": [ "сейчас" ], "0 week ago": [ + "на эт нед", + "на этой нед", "на этой неделе" ], "0 year ago": [ + "в эт г", + "в этом г", "в этом году" ], "1 day ago": [ "вчера" ], "1 month ago": [ + "в пр мес", + "в прошлом мес", "в прошлом месяце" ], "1 week ago": [ + "на пр нед", + "на прошлой нед", "на прошлой неделе" ], "1 year ago": [ + "в пр г", + "в прошлом г", "в прошлом году" ], "in 1 day": [ "завтра" ], "in 1 month": [ + "в след мес", + "в следующем мес", "в следующем месяце" ], "in 1 week": [ + "на след нед", + "на следующей нед", "на следующей неделе" ], "in 1 year": [ + "в сл г", + "в след г", "в следующем году" ], "2 day ago": [ @@ -215,10 +237,10 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d++[.,]?\\d*+) д назад", "(\\d++[.,]?\\d*+) день назад", "(\\d++[.,]?\\d*+) дн назад", - "(\\d++[.,]?\\d*+) дня назад" + "(\\d++[.,]?\\d*+) дня назад", + "(\\d++[.,]?\\d*+) д назад" ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) ч назад", @@ -251,10 +273,10 @@ "(\\d++[.,]?\\d*+) года назад" ], "in \\1 day": [ - "через (\\d++[.,]?\\d*+) д", "через (\\d++[.,]?\\d*+) день", "через (\\d++[.,]?\\d*+) дн", - "через (\\d++[.,]?\\d*+) дня" + "через (\\d++[.,]?\\d*+) дня", + "через (\\d++[.,]?\\d*+) д" ], "in \\1 hour": [ "через (\\d++[.,]?\\d*+) ч", @@ -301,13 +323,7 @@ "name": "ru-MD" }, "ru-UA": { - "name": "ru-UA", - "am": [ - "am" - ], - "pm": [ - "pm" - ] + "name": "ru-UA" } }, "skip": [ diff --git a/dateparser/data/date_translation_data/rw.py b/dateparser/data/date_translation_data/rw.py index 4a34e9e32..0f5b0c95a 100644 --- a/dateparser/data/date_translation_data/rw.py +++ b/dateparser/data/date_translation_data/rw.py @@ -19,6 +19,7 @@ ], "may": [ "gic", + "gicurasi", "gicuransi" ], "june": [ @@ -96,7 +97,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/rwk.py b/dateparser/data/date_translation_data/rwk.py index ef8384c93..1151f5581 100644 --- a/dateparser/data/date_translation_data/rwk.py +++ b/dateparser/data/date_translation_data/rwk.py @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/saq.py b/dateparser/data/date_translation_data/saq.py index b6105f34b..a2fdd4fc9 100644 --- a/dateparser/data/date_translation_data/saq.py +++ b/dateparser/data/date_translation_data/saq.py @@ -96,6 +96,7 @@ "mpari" ], "hour": [ + "hr", "saai" ], "minute": [ diff --git a/dateparser/data/date_translation_data/sbp.py b/dateparser/data/date_translation_data/sbp.py index 5e1f3d90c..7b0bd53d0 100644 --- a/dateparser/data/date_translation_data/sbp.py +++ b/dateparser/data/date_translation_data/sbp.py @@ -96,6 +96,7 @@ "lusiku" ], "hour": [ + "hr", "ilisala" ], "minute": [ diff --git a/dateparser/data/date_translation_data/se.py b/dateparser/data/date_translation_data/se.py index eb96932ef..0de1da24c 100644 --- a/dateparser/data/date_translation_data/se.py +++ b/dateparser/data/date_translation_data/se.py @@ -100,7 +100,8 @@ "beaivi" ], "hour": [ - "diibmu" + "diibmu", + "diibmur" ], "minute": [ "minuhtta" @@ -214,47 +215,159 @@ "locale_specific": { "se-FI": { "name": "se-FI", + "date_order": "DMY", + "april": [ + "cuoŋ" + ], "monday": [ + "má", + "mánnodat", "vuossárgga" ], "tuesday": [ + "di", + "disdat", "maŋŋebárgga" ], "wednesday": [ + "ga", "gaskavahku" ], "thursday": [ + "du", + "duorastat", "duorastaga" ], "friday": [ + "be", "bearjadaga" ], "saturday": [ + "lá", + "lávvordat", "lávvardaga" ], + "sunday": [ + "so" + ], "year": [ "j", "jahki" ], + "month": [ + "m" + ], "week": [ + "v(k)", "vahkku" ], + "day": [ + "b" + ], + "hour": [ + "dmu" + ], + "minute": [ + "min" + ], + "second": [ + "sek" + ], "relative-type": { + "0 hour ago": [ + "dán diimmu" + ], + "0 minute ago": [ + "dán minuhta" + ], + "0 month ago": [ + "dán mánu" + ], + "0 second ago": [ + "dál" + ], + "0 week ago": [ + "dán vahku" + ], "0 year ago": [ "dán jagi" ], + "1 month ago": [ + "mannan mánu" + ], + "1 week ago": [ + "mannan vahku" + ], "1 year ago": [ + "diibmá", "mannan jagi" ], + "in 1 month": [ + "boahtte mánu" + ], + "in 1 week": [ + "boahtte vahku" + ], "in 1 year": [ "boahtte jagi" ] }, "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) beaivve dás ovdal" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) diibmu áigi", + "(\\d++[.,]?\\d*+) diimmu áigi", + "(\\d++[.,]?\\d*+) dmu áigi" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) min áigi", + "(\\d++[.,]?\\d*+) minuhta áigi", + "(\\d++[.,]?\\d*+) minuhtta áigi" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) mánnu dás ovdal", + "(\\d++[.,]?\\d*+) mánu dás ovdal" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) sek áigi", + "(\\d++[.,]?\\d*+) sekunda áigi", + "(\\d++[.,]?\\d*+) sekundda áigi" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) vahkku dás ovdal", + "(\\d++[.,]?\\d*+) vahku dás ovdal" + ], "\\1 year ago": [ + "(\\d++[.,]?\\d*+) j dás ovdal", + "(\\d++[.,]?\\d*+) jagi dás ovdal", "(\\d++[.,]?\\d*+) jagi árat" ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) beaivve siste" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) diimmu siste", + "(\\d++[.,]?\\d*+) dmu siste" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) min siste", + "(\\d++[.,]?\\d*+) minuhta siste" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) mánu geahčen", + "(\\d++[.,]?\\d*+) mánu siste" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) sek siste", + "(\\d++[.,]?\\d*+) sekundda siste" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) vahku geahčen" + ], "in \\1 year": [ + "(\\d++[.,]?\\d*+) j siste", "(\\d++[.,]?\\d*+) jagi siste" ] } diff --git a/dateparser/data/date_translation_data/seh.py b/dateparser/data/date_translation_data/seh.py index 608c8d163..fc573e737 100644 --- a/dateparser/data/date_translation_data/seh.py +++ b/dateparser/data/date_translation_data/seh.py @@ -96,7 +96,8 @@ "ntsiku" ], "hour": [ - "hora" + "hora", + "hr" ], "minute": [ "minuto" diff --git a/dateparser/data/date_translation_data/ses.py b/dateparser/data/date_translation_data/ses.py index 4ced09b8b..e99bb38f9 100644 --- a/dateparser/data/date_translation_data/ses.py +++ b/dateparser/data/date_translation_data/ses.py @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser/data/date_translation_data/sg.py b/dateparser/data/date_translation_data/sg.py index 65b0ff2ad..fdfb4f07d 100644 --- a/dateparser/data/date_translation_data/sg.py +++ b/dateparser/data/date_translation_data/sg.py @@ -96,6 +96,7 @@ "lâ" ], "hour": [ + "hr", "ngbonga" ], "minute": [ diff --git a/dateparser/data/date_translation_data/shi-Latn.py b/dateparser/data/date_translation_data/shi-Latn.py index 0943af4f1..82faaefb7 100644 --- a/dateparser/data/date_translation_data/shi-Latn.py +++ b/dateparser/data/date_translation_data/shi-Latn.py @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tasragt" ], "minute": [ diff --git a/dateparser/data/date_translation_data/shi-Tfng.py b/dateparser/data/date_translation_data/shi-Tfng.py index d8601fa30..a033c6cbd 100644 --- a/dateparser/data/date_translation_data/shi-Tfng.py +++ b/dateparser/data/date_translation_data/shi-Tfng.py @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/shi.py b/dateparser/data/date_translation_data/shi.py index 4c498356f..ce1f623e9 100644 --- a/dateparser/data/date_translation_data/shi.py +++ b/dateparser/data/date_translation_data/shi.py @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/si.py b/dateparser/data/date_translation_data/si.py index f13a69a64..5351a1b2b 100644 --- a/dateparser/data/date_translation_data/si.py +++ b/dateparser/data/date_translation_data/si.py @@ -92,18 +92,18 @@ "දිනය" ], "hour": [ - "පැ", - "පැය" + "පැය", + "පැ" ], "minute": [ - "මි", "මිනි", - "මිනිත්තුව" + "මිනිත්තුව", + "මි" ], "second": [ - "ත", "තත්", - "තත්පරය" + "තත්පරය", + "ත" ], "relative-type": { "0 day ago": [ diff --git a/dateparser/data/date_translation_data/sk.py b/dateparser/data/date_translation_data/sk.py index 4d83899a3..8fa24eae3 100644 --- a/dateparser/data/date_translation_data/sk.py +++ b/dateparser/data/date_translation_data/sk.py @@ -113,7 +113,8 @@ ], "hour": [ "h", - "hodina" + "hodina", + "hodiny" ], "minute": [ "min", @@ -134,12 +135,14 @@ "v tejto minúte" ], "0 month ago": [ + "tento mes", "tento mesiac" ], "0 second ago": [ "teraz" ], "0 week ago": [ + "tento týž", "tento týždeň" ], "0 year ago": [ @@ -149,9 +152,11 @@ "včera" ], "1 month ago": [ + "minulý mes", "minulý mesiac" ], "1 week ago": [ + "minulý týž", "minulý týždeň" ], "1 year ago": [ @@ -161,9 +166,11 @@ "zajtra" ], "in 1 month": [ + "budúci mes", "budúci mesiac" ], "in 1 week": [ + "budúci týž", "budúci týždeň" ], "in 1 year": [ diff --git a/dateparser/data/date_translation_data/sl.py b/dateparser/data/date_translation_data/sl.py index 3f839dc79..6320af78f 100644 --- a/dateparser/data/date_translation_data/sl.py +++ b/dateparser/data/date_translation_data/sl.py @@ -100,7 +100,8 @@ ], "hour": [ "h", - "ura" + "ura", + "ure" ], "minute": [ "min", @@ -122,12 +123,14 @@ "to minuto" ], "0 month ago": [ + "ta mes", "ta mesec" ], "0 second ago": [ "zdaj" ], "0 week ago": [ + "ta ted", "ta teden" ], "0 year ago": [ @@ -137,9 +140,13 @@ "včeraj" ], "1 month ago": [ + "prej mes", + "prejšnji mes", "prejšnji mesec" ], "1 week ago": [ + "prej ted", + "prejšnji ted", "prejšnji teden" ], "1 year ago": [ @@ -149,9 +156,13 @@ "jutri" ], "in 1 month": [ + "nasl mes", + "naslednji mes", "naslednji mesec" ], "in 1 week": [ + "nasl ted", + "naslednji ted", "naslednji teden" ], "in 1 year": [ diff --git a/dateparser/data/date_translation_data/smn.py b/dateparser/data/date_translation_data/smn.py index 628485a1f..59395dc34 100644 --- a/dateparser/data/date_translation_data/smn.py +++ b/dateparser/data/date_translation_data/smn.py @@ -103,7 +103,8 @@ "day" ], "hour": [ - "hour" + "hour", + "tiijmeh" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/sn.py b/dateparser/data/date_translation_data/sn.py index b22665608..40f4cb9a2 100644 --- a/dateparser/data/date_translation_data/sn.py +++ b/dateparser/data/date_translation_data/sn.py @@ -96,7 +96,8 @@ "zuva" ], "hour": [ - "awa" + "awa", + "hr" ], "minute": [ "mineti" diff --git a/dateparser/data/date_translation_data/so.py b/dateparser/data/date_translation_data/so.py index 9430810a3..79cdea5f8 100644 --- a/dateparser/data/date_translation_data/so.py +++ b/dateparser/data/date_translation_data/so.py @@ -3,50 +3,73 @@ "date_order": "DMY", "january": [ "bisha koobaad", + "jan", + "jannaayo", "kob" ], "february": [ "bisha labaad", + "feb", + "febraayo", "lab" ], "march": [ "bisha saddexaad", + "maarso", + "mar", "sad" ], "april": [ - "afr", - "bisha afraad" + "abr", + "abriil", + "bisha afraad", + "afr" ], "may": [ "bisha shanaad", + "may", "sha" ], "june": [ "bisha lixaad", + "jun", + "juun", "lix" ], "july": [ "bisha todobaad", + "lul", + "luuliyo", "tod" ], "august": [ "bisha sideedaad", + "ogosto", + "ogs", "sid" ], "september": [ "bisha sagaalaad", + "seb", + "sebteembar", "sag" ], "october": [ "bisha tobnaad", + "okt", + "oktoobar", "tob" ], "november": [ "bisha kow iyo tobnaad", + "nof", + "noofeembar", "kit" ], "december": [ "bisha laba iyo tobnaad", + "dis", + "diseembar", "lit" ], "monday": [ @@ -54,54 +77,76 @@ "isniin" ], "tuesday": [ - "tal", - "talaado" + "talaado", + "tldo", + "tal" ], "wednesday": [ - "arb", - "arbaco" + "arbaco", + "arbc", + "arb" ], "thursday": [ - "kha", - "khamiis" + "khamiis", + "khms", + "kha" ], "friday": [ - "jim", - "jimco" + "jimco", + "jmc", + "jim" ], "saturday": [ - "sab", - "sabti" + "sabti", + "sbti", + "sab" ], "sunday": [ "axad", "axd" ], "am": [ + "am", + "gh", "sn" ], "pm": [ + "gd", "gn" ], "year": [ + "sannad", + "snd", "year" ], "month": [ + "bil", "month" ], "week": [ + "tdbd", + "toddobaad", "week" ], "day": [ + "maalin", + "mln", "day" ], "hour": [ + "saacad", + "saacado", + "scd", "hour" ], "minute": [ + "daqiiqad", + "dqqd", "minute" ], "second": [ + "ilbiriqsi", + "ilbrqsi", "second" ], "relative-type": { @@ -109,48 +154,133 @@ "maanta" ], "0 hour ago": [ + "saacadan", "this hour" ], "0 minute ago": [ + "daqiiqadan", "this minute" ], "0 month ago": [ + "bishan", "this month" ], "0 second ago": [ + "imika", + "iminka", "now" ], "0 week ago": [ + "toddobaadkan", + "usbuucan", "this week" ], "0 year ago": [ + "sannadkan", "this year" ], "1 day ago": [ "shalay" ], "1 month ago": [ + "bishii hore", "last month" ], "1 week ago": [ + "toddobaadkii hore", "last week" ], "1 year ago": [ + "sannadkii hore", + "sannadkii la soo dhaafay", "last year" ], "in 1 day": [ "berri" ], "in 1 month": [ + "bisha danbe", "next month" ], "in 1 week": [ + "toddobaadka danbe", "next week" ], "in 1 year": [ + "sannadka danbe", + "sannadka xiga", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "(\\d++[.,]?\\d*+) maalin kahor", + "(\\d++[.,]?\\d*+) maalmood kahor", + "(\\d++[.,]?\\d*+) mlmd khr", + "(\\d++[.,]?\\d*+) mln khr" + ], + "\\1 hour ago": [ + "(\\d++[.,]?\\d*+) saacad kahor", + "(\\d++[.,]?\\d*+) saacadood kahor", + "(\\d++[.,]?\\d*+) scd khr" + ], + "\\1 minute ago": [ + "(\\d++[.,]?\\d*+) daqiiqad kahor", + "(\\d++[.,]?\\d*+) daqiiqadood kahor", + "(\\d++[.,]?\\d*+) dqqd khr" + ], + "\\1 month ago": [ + "(\\d++[.,]?\\d*+) bil kahor", + "(\\d++[.,]?\\d*+) bil khr", + "(\\d++[.,]?\\d*+) bilood kahor" + ], + "\\1 second ago": [ + "(\\d++[.,]?\\d*+) ilbiriqsi kahor", + "(\\d++[.,]?\\d*+) ilbrqsi khr" + ], + "\\1 week ago": [ + "(\\d++[.,]?\\d*+) tdbd khr", + "(\\d++[.,]?\\d*+) toddobaad kahor" + ], + "\\1 year ago": [ + "(\\d++[.,]?\\d*+) sannad kahor", + "(\\d++[.,]?\\d*+) sannadood kahor", + "(\\d++[.,]?\\d*+) snd khr" + ], + "in \\1 day": [ + "(\\d++[.,]?\\d*+) maalin", + "(\\d++[.,]?\\d*+) maalmood", + "(\\d++[.,]?\\d*+) mlmd", + "(\\d++[.,]?\\d*+) mln" + ], + "in \\1 hour": [ + "(\\d++[.,]?\\d*+) saacad", + "(\\d++[.,]?\\d*+) saacadood", + "(\\d++[.,]?\\d*+) scd" + ], + "in \\1 minute": [ + "(\\d++[.,]?\\d*+) daqiidadood", + "(\\d++[.,]?\\d*+) daqiiqad", + "(\\d++[.,]?\\d*+) dqqd" + ], + "in \\1 month": [ + "(\\d++[.,]?\\d*+) bil", + "(\\d++[.,]?\\d*+) bilood" + ], + "in \\1 second": [ + "(\\d++[.,]?\\d*+) ilbiriqsi", + "(\\d++[.,]?\\d*+) ilbrqsi" + ], + "in \\1 week": [ + "(\\d++[.,]?\\d*+) tdbd", + "(\\d++[.,]?\\d*+) toddobaad" + ], + "in \\1 year": [ + "(\\d++[.,]?\\d*+) sannad", + "(\\d++[.,]?\\d*+) sannadood", + "(\\d++[.,]?\\d*+) snd" + ] + }, "locale_specific": { "so-DJ": { "name": "so-DJ" diff --git a/dateparser/data/date_translation_data/sq.py b/dateparser/data/date_translation_data/sq.py index 4cd27f3ac..dcb9ec9f9 100644 --- a/dateparser/data/date_translation_data/sq.py +++ b/dateparser/data/date_translation_data/sq.py @@ -25,12 +25,14 @@ "qershor" ], "july": [ - "kor", - "korrik" + "korr", + "korrik", + "kor" ], "august": [ - "gsh", - "gusht" + "gush", + "gusht", + "gsh" ], "september": [ "sht", @@ -78,10 +80,12 @@ ], "am": [ "e paradites", - "paradite" + "paradite", + "pd" ], "pm": [ "e pasdites", + "md", "pasdite" ], "year": [ @@ -127,7 +131,8 @@ "këtë javë" ], "0 year ago": [ - "këtë vit" + "këtë vit", + "sivjet" ], "1 day ago": [ "dje" @@ -139,7 +144,8 @@ "javën e kaluar" ], "1 year ago": [ - "vitin e kaluar" + "vitin e kaluar", + "vjet" ], "in 1 day": [ "nesër" @@ -151,6 +157,7 @@ "javën e ardhshme" ], "in 1 year": [ + "mot", "vitin e ardhshëm" ] }, diff --git a/dateparser/data/date_translation_data/sr-Cyrl.py b/dateparser/data/date_translation_data/sr-Cyrl.py index 4e4ca7415..24a7a5244 100644 --- a/dateparser/data/date_translation_data/sr-Cyrl.py +++ b/dateparser/data/date_translation_data/sr-Cyrl.py @@ -75,9 +75,11 @@ "недеља" ], "am": [ + "am", "пре подне" ], "pm": [ + "pm", "по подне" ], "year": [ @@ -86,14 +88,14 @@ "година" ], "month": [ - "м", "мес", - "месец" + "месец", + "м" ], "week": [ - "н", "нед", - "недеља" + "недеља", + "н" ], "day": [ "д", @@ -101,6 +103,7 @@ ], "hour": [ "сат", + "сати", "ч" ], "minute": [ @@ -123,39 +126,54 @@ "овог минута" ], "0 month ago": [ + "овог мес", "овог месеца" ], "0 second ago": [ "сада" ], "0 week ago": [ + "ове н", + "ове нед", "ове недеље" ], "0 year ago": [ + "ове г", + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ + "прошлог мес", "прошлог месеца" ], "1 week ago": [ + "прошле н", + "прошле нед", "прошле недеље" ], "1 year ago": [ + "прошле г", + "прошле год", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ + "следећег мес", "следећег месеца" ], "in 1 week": [ + "следеће н", + "следеће нед", "следеће недеље" ], "in 1 year": [ + "следеће г", + "следеће год", "следеће године" ] }, @@ -240,21 +258,121 @@ "locale_specific": { "sr-Cyrl-BA": { "name": "sr-Cyrl-BA", - "september": [ - "септ" - ], - "tuesday": [ - "ут" + "monday": [ + "понедјељак" ], "wednesday": [ - "ср", - "сриједа" + "сри", + "сриједа", + "ср" ], "sunday": [ "недјеља" ], "am": [ "прије подне" + ], + "pm": [ + "по подне" + ], + "month": [ + "мјес", + "мјесец" + ], + "week": [ + "седм", + "седмица" + ], + "relative-type": { + "0 month ago": [ + "овог мјес", + "овог мјесеца" + ], + "0 week ago": [ + "ове с", + "ове седм", + "ове седмице" + ], + "1 month ago": [ + "прошлог мјес", + "прошлог мјесеца" + ], + "1 week ago": [ + "прошле с", + "прошле седм", + "прошле седмице" + ], + "in 1 month": [ + "сљедећег м", + "сљедећег мјес", + "сљедећег мјесеца" + ], + "in 1 week": [ + "сљедеће с", + "сљедеће седм", + "сљедеће седмице" + ], + "in 1 year": [ + "сљедеће г", + "сљедеће год", + "сљедеће године" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "прије (\\d++[.,]?\\d*+) д", + "прије (\\d++[.,]?\\d*+) дана" + ], + "\\1 hour ago": [ + "прије (\\d++[.,]?\\d*+) сата", + "прије (\\d++[.,]?\\d*+) сати", + "прије (\\d++[.,]?\\d*+) ч" + ], + "\\1 minute ago": [ + "прије (\\d++[.,]?\\d*+) мин", + "прије (\\d++[.,]?\\d*+) минута" + ], + "\\1 month ago": [ + "прије (\\d++[.,]?\\d*+) м", + "прије (\\d++[.,]?\\d*+) мјес", + "прије (\\d++[.,]?\\d*+) мјесеца", + "прије (\\d++[.,]?\\d*+) мјесеци" + ], + "\\1 second ago": [ + "прије (\\d++[.,]?\\d*+) с", + "прије (\\d++[.,]?\\d*+) сек", + "прије (\\d++[.,]?\\d*+) секунде", + "прије (\\d++[.,]?\\d*+) секунди" + ], + "\\1 week ago": [ + "прије (\\d++[.,]?\\d*+) с", + "прије (\\d++[.,]?\\d*+) седм", + "прије (\\d++[.,]?\\d*+) седмица", + "прије (\\d++[.,]?\\d*+) седмице" + ], + "\\1 year ago": [ + "прије (\\d++[.,]?\\d*+) г", + "прије (\\d++[.,]?\\d*+) год", + "прије (\\d++[.,]?\\d*+) година", + "прије (\\d++[.,]?\\d*+) године" + ], + "in \\1 month": [ + "за (\\d++[.,]?\\d*+) мјес", + "за (\\d++[.,]?\\d*+) мјесец", + "за (\\d++[.,]?\\d*+) мјесеци" + ], + "in \\1 week": [ + "за (\\d++[.,]?\\d*+) с", + "за (\\d++[.,]?\\d*+) седм", + "за (\\d++[.,]?\\d*+) седмица", + "за (\\d++[.,]?\\d*+) седмицу" + ] + }, + "tuesday": [ + "ут" + ], + "september": [ + "септ" ] }, "sr-Cyrl-ME": { @@ -262,18 +380,21 @@ "september": [ "септ" ], - "tuesday": [ - "ут" - ], "wednesday": [ - "ср", - "сриједа" + "сриједа", + "ср" ], "sunday": [ "недјеља" ], "am": [ "прије подне" + ], + "pm": [ + "по подне" + ], + "tuesday": [ + "ут" ] }, "sr-Cyrl-XK": { diff --git a/dateparser/data/date_translation_data/sr-Latn.py b/dateparser/data/date_translation_data/sr-Latn.py index c41c6daa1..3bef6b588 100644 --- a/dateparser/data/date_translation_data/sr-Latn.py +++ b/dateparser/data/date_translation_data/sr-Latn.py @@ -75,9 +75,11 @@ "nedelja" ], "am": [ + "am", "pre podne" ], "pm": [ + "pm", "po podne" ], "year": [ @@ -86,14 +88,14 @@ "godina" ], "month": [ - "m", "mes", - "mesec" + "mesec", + "m" ], "week": [ - "n", "ned", - "nedelja" + "nedelja", + "n" ], "day": [ "d", @@ -101,6 +103,7 @@ ], "hour": [ "sat", + "sati", "č" ], "minute": [ @@ -123,39 +126,54 @@ "ovog minuta" ], "0 month ago": [ + "ovog mes", "ovog meseca" ], "0 second ago": [ "sada" ], "0 week ago": [ + "ove n", + "ove ned", "ove nedelje" ], "0 year ago": [ + "ove g", + "ove god", "ove godine" ], "1 day ago": [ "juče" ], "1 month ago": [ + "prošlog mes", "prošlog meseca" ], "1 week ago": [ + "prošle n", + "prošle ned", "prošle nedelje" ], "1 year ago": [ + "prošle g", + "prošle god", "prošle godine" ], "in 1 day": [ "sutra" ], "in 1 month": [ + "sledećeg mes", "sledećeg meseca" ], "in 1 week": [ + "sledeće n", + "sledeće ned", "sledeće nedelje" ], "in 1 year": [ + "sledeće g", + "sledeće god", "sledeće godine" ] }, @@ -240,21 +258,121 @@ "locale_specific": { "sr-Latn-BA": { "name": "sr-Latn-BA", - "september": [ - "sept" - ], - "tuesday": [ - "ut" + "monday": [ + "ponedjeljak" ], "wednesday": [ - "sr", - "srijeda" + "sri", + "srijeda", + "sr" ], "sunday": [ "nedjelja" ], "am": [ "prije podne" + ], + "pm": [ + "po podne" + ], + "month": [ + "mjes", + "mjesec" + ], + "week": [ + "sedm", + "sedmica" + ], + "relative-type": { + "0 month ago": [ + "ovog mjes", + "ovog mjeseca" + ], + "0 week ago": [ + "ove s", + "ove sedm", + "ove sedmice" + ], + "1 month ago": [ + "prošlog mjes", + "prošlog mjeseca" + ], + "1 week ago": [ + "prošle s", + "prošle sedm", + "prošle sedmice" + ], + "in 1 month": [ + "sljedećeg m", + "sljedećeg mjes", + "sljedećeg mjeseca" + ], + "in 1 week": [ + "sljedeće s", + "sljedeće sedm", + "sljedeće sedmice" + ], + "in 1 year": [ + "sljedeće g", + "sljedeće god", + "sljedeće godine" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "prije (\\d++[.,]?\\d*+) d", + "prije (\\d++[.,]?\\d*+) dana" + ], + "\\1 hour ago": [ + "prije (\\d++[.,]?\\d*+) sata", + "prije (\\d++[.,]?\\d*+) sati", + "prije (\\d++[.,]?\\d*+) č" + ], + "\\1 minute ago": [ + "prije (\\d++[.,]?\\d*+) min", + "prije (\\d++[.,]?\\d*+) minuta" + ], + "\\1 month ago": [ + "prije (\\d++[.,]?\\d*+) m", + "prije (\\d++[.,]?\\d*+) mjes", + "prije (\\d++[.,]?\\d*+) mjeseca", + "prije (\\d++[.,]?\\d*+) mjeseci" + ], + "\\1 second ago": [ + "prije (\\d++[.,]?\\d*+) s", + "prije (\\d++[.,]?\\d*+) sek", + "prije (\\d++[.,]?\\d*+) sekunde", + "prije (\\d++[.,]?\\d*+) sekundi" + ], + "\\1 week ago": [ + "prije (\\d++[.,]?\\d*+) s", + "prije (\\d++[.,]?\\d*+) sedm", + "prije (\\d++[.,]?\\d*+) sedmica", + "prije (\\d++[.,]?\\d*+) sedmice" + ], + "\\1 year ago": [ + "prije (\\d++[.,]?\\d*+) g", + "prije (\\d++[.,]?\\d*+) god", + "prije (\\d++[.,]?\\d*+) godina", + "prije (\\d++[.,]?\\d*+) godine" + ], + "in \\1 month": [ + "za (\\d++[.,]?\\d*+) mjes", + "za (\\d++[.,]?\\d*+) mjesec", + "za (\\d++[.,]?\\d*+) mjeseci" + ], + "in \\1 week": [ + "za (\\d++[.,]?\\d*+) s", + "za (\\d++[.,]?\\d*+) sedm", + "za (\\d++[.,]?\\d*+) sedmica", + "za (\\d++[.,]?\\d*+) sedmicu" + ] + }, + "tuesday": [ + "ut" + ], + "september": [ + "sept" ] }, "sr-Latn-ME": { @@ -262,18 +380,21 @@ "september": [ "sept" ], - "tuesday": [ - "ut" - ], "wednesday": [ - "sr", - "srijeda" + "srijeda", + "sr" ], "sunday": [ "nedjelja" ], "am": [ "prije podne" + ], + "pm": [ + "po podne" + ], + "tuesday": [ + "ut" ] }, "sr-Latn-XK": { diff --git a/dateparser/data/date_translation_data/sr.py b/dateparser/data/date_translation_data/sr.py index f93b76224..f17b88a57 100644 --- a/dateparser/data/date_translation_data/sr.py +++ b/dateparser/data/date_translation_data/sr.py @@ -75,9 +75,11 @@ "недеља" ], "am": [ + "am", "пре подне" ], "pm": [ + "pm", "по подне" ], "year": [ @@ -86,14 +88,14 @@ "година" ], "month": [ - "м", "мес", - "месец" + "месец", + "м" ], "week": [ - "н", "нед", - "недеља" + "недеља", + "н" ], "day": [ "д", @@ -101,6 +103,7 @@ ], "hour": [ "сат", + "сати", "ч" ], "minute": [ @@ -123,39 +126,54 @@ "овог минута" ], "0 month ago": [ + "овог мес", "овог месеца" ], "0 second ago": [ "сада" ], "0 week ago": [ + "ове н", + "ове нед", "ове недеље" ], "0 year ago": [ + "ове г", + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ + "прошлог мес", "прошлог месеца" ], "1 week ago": [ + "прошле н", + "прошле нед", "прошле недеље" ], "1 year ago": [ + "прошле г", + "прошле год", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ + "следећег мес", "следећег месеца" ], "in 1 week": [ + "следеће н", + "следеће нед", "следеће недеље" ], "in 1 year": [ + "следеће г", + "следеће год", "следеће године" ] }, diff --git a/dateparser/data/date_translation_data/sv.py b/dateparser/data/date_translation_data/sv.py index 1ac211789..657fba160 100644 --- a/dateparser/data/date_translation_data/sv.py +++ b/dateparser/data/date_translation_data/sv.py @@ -114,6 +114,7 @@ "hour": [ "h", "tim", + "timmar", "timme", "timmar", "t" @@ -133,6 +134,7 @@ "relative-type": { "0 day ago": [ "i dag", + "idag", "idag" ], "0 hour ago": [ @@ -142,6 +144,7 @@ "denna minut" ], "0 month ago": [ + "den här månaden", "denna mån", "denna månad" ], @@ -157,6 +160,7 @@ ], "1 day ago": [ "i går", + "igår", "igår" ], "1 month ago": [ @@ -173,6 +177,7 @@ ], "in 1 day": [ "i morgon", + "imorgon", "imorgon" ], "in 1 month": [ @@ -204,22 +209,25 @@ "−(\\d++[.,]?\\d*+) h" ], "\\1 minute ago": [ - "för (\\d++[.,]?\\d*+) min sedan", + "för (\\d++[.,]?\\d*+) min sen", "för (\\d++[.,]?\\d*+) minut sedan", "för (\\d++[.,]?\\d*+) minuter sedan", - "−(\\d++[.,]?\\d*+) min" + "−(\\d++[.,]?\\d*+) min", + "för (\\d++[.,]?\\d*+) min sedan" ], "\\1 month ago": [ - "för (\\d++[.,]?\\d*+) mån sedan", + "för (\\d++[.,]?\\d*+) mån sen", "för (\\d++[.,]?\\d*+) månad sedan", "för (\\d++[.,]?\\d*+) månader sedan", - "−(\\d++[.,]?\\d*+) mån" + "−(\\d++[.,]?\\d*+) mån", + "för (\\d++[.,]?\\d*+) mån sedan" ], "\\1 second ago": [ - "för (\\d++[.,]?\\d*+) sek sedan", + "för (\\d++[.,]?\\d*+) s sen", "för (\\d++[.,]?\\d*+) sekund sedan", "för (\\d++[.,]?\\d*+) sekunder sedan", - "−(\\d++[.,]?\\d*+) s" + "−(\\d++[.,]?\\d*+) s", + "för (\\d++[.,]?\\d*+) sek sedan" ], "\\1 week ago": [ "för (\\d++[.,]?\\d*+) v sedan", @@ -229,6 +237,7 @@ ], "\\1 year ago": [ "för (\\d++[.,]?\\d*+) år sedan", + "för (\\d++[.,]?\\d*+) år sen", "−(\\d++[.,]?\\d*+) år" ], "in \\1 day": [ @@ -270,8 +279,7 @@ "name": "sv-AX" }, "sv-FI": { - "name": "sv-FI", - "date_order": "DMY" + "name": "sv-FI" } }, "skip": [ diff --git a/dateparser/data/date_translation_data/sw.py b/dateparser/data/date_translation_data/sw.py index 979e5ac5b..4981f20bf 100644 --- a/dateparser/data/date_translation_data/sw.py +++ b/dateparser/data/date_translation_data/sw.py @@ -74,8 +74,8 @@ "asubuhi" ], "pm": [ - "mchana", - "pm" + "pm", + "mchana" ], "year": [ "mwaka" diff --git a/dateparser/data/date_translation_data/ta.py b/dateparser/data/date_translation_data/ta.py index 1ea21b793..e01988790 100644 --- a/dateparser/data/date_translation_data/ta.py +++ b/dateparser/data/date_translation_data/ta.py @@ -74,6 +74,7 @@ "ஞாயிறு" ], "am": [ + "am", "முற்பகல்" ], "pm": [ @@ -98,7 +99,8 @@ ], "hour": [ "ம", - "மணி" + "மணி", + "மணிநேரங்கள்" ], "minute": [ "நிமி", @@ -189,6 +191,7 @@ "(\\d++[.,]?\\d*+) வா முன்", "(\\d++[.,]?\\d*+) வார முன்", "(\\d++[.,]?\\d*+) வாரங்களுக்கு முன்", + "(\\d++[.,]?\\d*+) வாரத்திற்கு முன்", "(\\d++[.,]?\\d*+) வாரத்திற்கு முன்பு" ], "\\1 year ago": [ diff --git a/dateparser/data/date_translation_data/te.py b/dateparser/data/date_translation_data/te.py index 78693c960..831ae9995 100644 --- a/dateparser/data/date_translation_data/te.py +++ b/dateparser/data/date_translation_data/te.py @@ -92,17 +92,19 @@ "వారము" ], "day": [ - "ది", - "దినం" + "దినం", + "రోజు", + "ది" ], "hour": [ "గం", - "గంట" + "గంట", + "గంటలు" ], "minute": [ - "ని", "నిమి", - "నిమిషము" + "నిమిషము", + "ని" ], "second": [ "సెక", @@ -128,6 +130,8 @@ "ఈ వారం" ], "0 year ago": [ + "ఈ సం", + "ఈ సంవ", "ఈ సంవత్సరం" ], "1 day ago": [ @@ -140,6 +144,8 @@ "గత వారం" ], "1 year ago": [ + "గత సం", + "గత సంవ", "గత సంవత్సరం" ], "in 1 day": [ @@ -152,6 +158,8 @@ "తదుపరి వారం" ], "in 1 year": [ + "తదుపరి సం", + "తదుపరి సంవ", "తదుపరి సంవత్సరం" ] }, @@ -209,7 +217,8 @@ "in \\1 second": [ "(\\d++[.,]?\\d*+) సెక లో", "(\\d++[.,]?\\d*+) సెకనులో", - "(\\d++[.,]?\\d*+) సెకన్లలో" + "(\\d++[.,]?\\d*+) సెకన్లలో", + "(\\d++[.,]?\\d*+) సెకలో" ], "in \\1 week": [ "(\\d++[.,]?\\d*+) వారంలో", @@ -217,6 +226,7 @@ ], "in \\1 year": [ "(\\d++[.,]?\\d*+) సంలో", + "(\\d++[.,]?\\d*+) సంల్లో", "(\\d++[.,]?\\d*+) సంవత్సరంలో", "(\\d++[.,]?\\d*+) సంవత్సరాల్లో" ] diff --git a/dateparser/data/date_translation_data/teo.py b/dateparser/data/date_translation_data/teo.py index 94c9877e5..30a6bd1a3 100644 --- a/dateparser/data/date_translation_data/teo.py +++ b/dateparser/data/date_translation_data/teo.py @@ -96,7 +96,8 @@ "aparan" ], "hour": [ - "esaa" + "esaa", + "hr" ], "minute": [ "idakika" diff --git a/dateparser/data/date_translation_data/th.py b/dateparser/data/date_translation_data/th.py index 208765477..53789c9da 100644 --- a/dateparser/data/date_translation_data/th.py +++ b/dateparser/data/date_translation_data/th.py @@ -117,9 +117,11 @@ "วันอาทิตย์ที่" ], "am": [ + "am", "ก่อนเที่ยง" ], "pm": [ + "pm", "หลังเที่ยง" ], "year": [ @@ -139,8 +141,8 @@ "ชั่วโมง" ], "minute": [ - "น", - "นาที" + "นาที", + "น" ], "second": [ "วิ", diff --git a/dateparser/data/date_translation_data/ti.py b/dateparser/data/date_translation_data/ti.py index 284937e53..2b4b31f15 100644 --- a/dateparser/data/date_translation_data/ti.py +++ b/dateparser/data/date_translation_data/ti.py @@ -52,9 +52,9 @@ "ሰኑይ" ], "tuesday": [ - "ሠሉስ", "ሰሉ", - "ሰሉስ" + "ሰሉስ", + "ሠሉስ" ], "wednesday": [ "ረቡ", @@ -78,79 +78,150 @@ "ሰንበት" ], "am": [ + "ቅቀ", "ንጉሆ ሰዓተ" ], "pm": [ + "ድቀ", "ድሕር ሰዓት" ], "year": [ + "ዓመት", "year" ], "month": [ + "ወርሒ", "month" ], "week": [ + "ሰሙን", "week" ], "day": [ + "መዓልቲ", "day" ], "hour": [ + "hr", + "ሰዓት", "hour" ], "minute": [ + "ደቒ", + "ደቒቕ", "minute" ], "second": [ + "ካልኢት", "second" ], "relative-type": { "0 day ago": [ + "ሎሚ", "today" ], "0 hour ago": [ + "ኣብዚ ሰዓት", "this hour" ], "0 minute ago": [ + "ኣብዚ ደቒቕ", "this minute" ], "0 month ago": [ + "ህሉው ወርሒ", "this month" ], "0 second ago": [ + "ሕጂ", "now" ], "0 week ago": [ + "ህሉው ሰሙን", "this week" ], "0 year ago": [ + "ሎሚ ዓመት", "this year" ], "1 day ago": [ + "ትማሊ", "yesterday" ], "1 month ago": [ + "ዝሓለፈ ወርሒ", "last month" ], "1 week ago": [ + "ዝሓለፈ ሰሙን", "last week" ], "1 year ago": [ + "ዓሚ", "last year" ], "in 1 day": [ + "ጽባሕ", "tomorrow" ], "in 1 month": [ + "ዝመጽእ ወርሒ", "next month" ], "in 1 week": [ + "ዝመጽእ ሰሙን", "next week" ], "in 1 year": [ + "ንዓመታ", "next year" ] }, + "relative-type-regex": { + "\\1 day ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) መዓልቲ", + "ኣብ (\\d++[.,]?\\d*+) መዓልቲ" + ], + "\\1 hour ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ሰዓት" + ], + "\\1 minute ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ደቒቕ" + ], + "\\1 month ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ወርሒ" + ], + "\\1 second ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ካልኢት" + ], + "\\1 week ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ሰሙን" + ], + "\\1 year ago": [ + "ቅድሚ (\\d++[.,]?\\d*+) ዓ" + ], + "in \\1 day": [ + "ኣብ (\\d++[.,]?\\d*+) መዓልቲ" + ], + "in \\1 hour": [ + "ኣብ (\\d++[.,]?\\d*+) ሰዓት" + ], + "in \\1 minute": [ + "ኣብ (\\d++[.,]?\\d*+) ደቒቕ" + ], + "in \\1 month": [ + "ኣብ (\\d++[.,]?\\d*+) ወርሒ" + ], + "in \\1 second": [ + "ኣብ (\\d++[.,]?\\d*+) ካልኢት" + ], + "in \\1 week": [ + "ኣብ (\\d++[.,]?\\d*+) ሰሙን" + ], + "in \\1 year": [ + "ኣብ (\\d++[.,]?\\d*+) ዓ" + ] + }, "locale_specific": { "ti-ER": { "name": "ti-ER" diff --git a/dateparser/data/date_translation_data/to.py b/dateparser/data/date_translation_data/to.py index 05cb62fdf..7d2985b40 100644 --- a/dateparser/data/date_translation_data/to.py +++ b/dateparser/data/date_translation_data/to.py @@ -33,8 +33,10 @@ "'aokosi" ], "september": [ - "sep", - "sepitema" + "sepitema", + "sēp", + "sēpitema", + "sep" ], "october": [ "'oka", @@ -77,9 +79,9 @@ "sāpate" ], "am": [ - "am", "hengihengi", - "hh" + "hh", + "am" ], "pm": [ "ea", @@ -87,71 +89,92 @@ "pm" ], "year": [ + "t", "ta'u" ], "month": [ + "mh", "māhina" ], "week": [ + "ui", "uike" ], "day": [ + "'a", "'aho" ], "hour": [ + "h", "houa" ], "minute": [ + "m", "miniti" ], "second": [ + "s", "sekoni" ], "relative-type": { "0 day ago": [ - "'ahó ni" + "'ahó ni", + "'ani" ], "0 hour ago": [ + "ko e houa 'eni", "this hour" ], "0 minute ago": [ + "ko e miniti 'eni", "this minute" ], "0 month ago": [ + "mhni", "māhiná ni" ], "0 second ago": [ "taimí ni" ], "0 week ago": [ - "uiké ni" + "uiké ni", + "uini" ], "0 year ago": [ - "ta'ú ni" + "ta'ú ni", + "tni" ], "1 day ago": [ + "'ane", "'aneafi" ], "1 month ago": [ + "mh'osi", "māhina kuo'osi" ], "1 week ago": [ + "ui'osi", "uike kuo'osi" ], "1 year ago": [ + "t'osi", "ta'u kuo'osi" ], "in 1 day": [ + "'apo", "'apongipongi" ], "in 1 month": [ + "mhha'u", "māhina kaha'u" ], "in 1 week": [ + "uiha'u", "uike kaha'u" ], "in 1 year": [ - "ta'u kaha'u" + "ta'u kaha'u", + "tha'u" ] }, "relative-type-regex": { diff --git a/dateparser/data/date_translation_data/tr.py b/dateparser/data/date_translation_data/tr.py index 62c42fd1c..2e47c258f 100644 --- a/dateparser/data/date_translation_data/tr.py +++ b/dateparser/data/date_translation_data/tr.py @@ -138,7 +138,8 @@ "şimdi" ], "0 week ago": [ - "bu hafta" + "bu hafta", + "bu hf" ], "0 year ago": [ "bu yıl" @@ -151,7 +152,8 @@ "geçen ay" ], "1 week ago": [ - "geçen hafta" + "geçen hafta", + "geçen hf" ], "1 year ago": [ "geçen yıl" @@ -166,6 +168,7 @@ ], "in 1 week": [ "gelecek hafta", + "gelecek hf", "haftaya", "önümüzdeki hafta" ], diff --git a/dateparser/data/date_translation_data/twq.py b/dateparser/data/date_translation_data/twq.py index 2146c0b40..55ea8260a 100644 --- a/dateparser/data/date_translation_data/twq.py +++ b/dateparser/data/date_translation_data/twq.py @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser/data/date_translation_data/tzm.py b/dateparser/data/date_translation_data/tzm.py index efba48a80..a88a45fc2 100644 --- a/dateparser/data/date_translation_data/tzm.py +++ b/dateparser/data/date_translation_data/tzm.py @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tasragt" ], "minute": [ diff --git a/dateparser/data/date_translation_data/ug.py b/dateparser/data/date_translation_data/ug.py index 6aacd554f..31ec22778 100644 --- a/dateparser/data/date_translation_data/ug.py +++ b/dateparser/data/date_translation_data/ug.py @@ -86,6 +86,7 @@ "كۈن" ], "hour": [ + "hr", "سائەت" ], "minute": [ diff --git a/dateparser/data/date_translation_data/uk.py b/dateparser/data/date_translation_data/uk.py index 94adb39b6..4958ccbaa 100644 --- a/dateparser/data/date_translation_data/uk.py +++ b/dateparser/data/date_translation_data/uk.py @@ -18,22 +18,22 @@ "берез" ], "april": [ - "кві", "квіт", "квітень", - "квітня" + "квітня", + "кві" ], "may": [ - "тра", "трав", "травень", - "травня" + "травня", + "тра" ], "june": [ - "чер", "черв", "червень", - "червня" + "червня", + "чер" ], "july": [ "лип", @@ -41,10 +41,10 @@ "липня" ], "august": [ - "сер", "серп", "серпень", - "серпня" + "серпня", + "сер" ], "september": [ "вер", @@ -53,23 +53,23 @@ "верес" ], "october": [ - "жов", "жовт", "жовтень", - "жовтня" + "жовтня", + "жов" ], "november": [ - "лис", "лист", "листопад", "листопада", - "листоп" + "листоп", + "лис" ], "december": [ - "гру", "груд", "грудень", - "грудня" + "грудня", + "гру" ], "monday": [ "пн", @@ -89,6 +89,7 @@ ], "wednesday": [ "середа", + "середу", "ср", "ср", "сер", @@ -104,6 +105,7 @@ "четвер" ], "friday": [ + "п'ятницю", "п'ятниця", "пт", "пят" @@ -111,6 +113,7 @@ "saturday": [ "сб", "субота", + "суботу", "сб", "суб", "субот", @@ -119,6 +122,7 @@ ], "sunday": [ "нд", + "неділю", "неділя", "нд", "нед", @@ -151,6 +155,7 @@ "рокові" ], "month": [ + "м", "міс", "місяць", "м", @@ -167,6 +172,7 @@ "місяцями" ], "week": [ + "т", "тиж", "тиждень", "т", @@ -197,6 +203,7 @@ "hour": [ "год", "година", + "години", "г", "год", "годин", @@ -245,6 +252,7 @@ "цієї хвилини" ], "0 month ago": [ + "цього міс", "цього місяця" ], "0 second ago": [ @@ -254,31 +262,39 @@ "цього тижня" ], "0 year ago": [ - "цього року" + "цього року", + "цьогоріч" ], "1 day ago": [ "учора", "вчора" ], "1 month ago": [ + "мин міс", "минулого місяця" ], "1 week ago": [ + "мин тижня", "минулого тижня" ], "1 year ago": [ + "минулого року", "торік" ], "in 1 day": [ "завтра" ], "in 1 month": [ + "наст міс", "наступного місяця" ], "in 1 week": [ + "наст тижня", "наступного тижня" ], "in 1 year": [ + "наст р", + "наст року", "наступного року" ], "2 day ago": [ @@ -290,10 +306,10 @@ }, "relative-type-regex": { "\\1 day ago": [ - "(\\d++[.,]?\\d*+) д тому", "(\\d++[.,]?\\d*+) день тому", "(\\d++[.,]?\\d*+) дн тому", - "(\\d++[.,]?\\d*+) дня тому" + "(\\d++[.,]?\\d*+) дня тому", + "(\\d++[.,]?\\d*+) д тому" ], "\\1 hour ago": [ "(\\d++[.,]?\\d*+) год тому", @@ -329,10 +345,11 @@ "(\\d++[.,]?\\d*+) рік тому" ], "in \\1 day": [ - "за (\\d++[.,]?\\d*+) д", + "за (\\d++[.,]?\\d*+) дн", "через (\\d++[.,]?\\d*+) день", "через (\\d++[.,]?\\d*+) дн", - "через (\\d++[.,]?\\d*+) дня" + "через (\\d++[.,]?\\d*+) дня", + "за (\\d++[.,]?\\d*+) д" ], "in \\1 hour": [ "за (\\d++[.,]?\\d*+) год", diff --git a/dateparser/data/date_translation_data/ur.py b/dateparser/data/date_translation_data/ur.py index 0acb9671e..5b4fdcc86 100644 --- a/dateparser/data/date_translation_data/ur.py +++ b/dateparser/data/date_translation_data/ur.py @@ -38,6 +38,7 @@ "دسمبر" ], "monday": [ + "پیر", "سوموار" ], "tuesday": [ @@ -78,7 +79,8 @@ "دن" ], "hour": [ - "گھنٹہ" + "گھنٹہ", + "گھنٹے" ], "minute": [ "منٹ" @@ -97,6 +99,7 @@ "اس منٹ" ], "0 month ago": [ + "اس ماہ", "اس مہینہ" ], "0 second ago": [ @@ -112,10 +115,12 @@ "گزشتہ کل" ], "1 month ago": [ - "پچھلے مہینہ" + "پچھلے مہینہ", + "گزشتہ ماہ" ], "1 week ago": [ - "پچھلے ہفتہ" + "پچھلے ہفتہ", + "گزشتہ ہفتے" ], "1 year ago": [ "گزشتہ سال" @@ -124,10 +129,13 @@ "آئندہ کل" ], "in 1 month": [ + "اگلا مہینہ", + "اگلے ماہ", "اگلے مہینہ" ], "in 1 week": [ - "اگلے ہفتہ" + "اگلے ہفتہ", + "اگلے ہفتے" ], "in 1 year": [ "اگلے سال" @@ -167,8 +175,8 @@ ], "in \\1 hour": [ "(\\d++[.,]?\\d*+) گھنٹوں میں", - "(\\d++[.,]?\\d*+) گھنٹہ میں", - "(\\d++[.,]?\\d*+) گھنٹے میں" + "(\\d++[.,]?\\d*+) گھنٹے میں", + "(\\d++[.,]?\\d*+) گھنٹہ میں" ], "in \\1 minute": [ "(\\d++[.,]?\\d*+) منٹ میں" @@ -192,21 +200,9 @@ "locale_specific": { "ur-IN": { "name": "ur-IN", - "monday": [ - "پیر" - ], "relative-type": { - "0 month ago": [ - "اس ماہ" - ], - "1 month ago": [ - "گزشتہ ماہ" - ], "1 week ago": [ "گزشتہ ہفتہ" - ], - "in 1 month": [ - "اگلے ماہ" ] }, "relative-type-regex": { diff --git a/dateparser/data/date_translation_data/uz-Arab.py b/dateparser/data/date_translation_data/uz-Arab.py index 00f0f570e..63ce35dcf 100644 --- a/dateparser/data/date_translation_data/uz-Arab.py +++ b/dateparser/data/date_translation_data/uz-Arab.py @@ -94,7 +94,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser/data/date_translation_data/uz-Cyrl.py b/dateparser/data/date_translation_data/uz-Cyrl.py index 3074a773b..ed4ef4c05 100644 --- a/dateparser/data/date_translation_data/uz-Cyrl.py +++ b/dateparser/data/date_translation_data/uz-Cyrl.py @@ -93,6 +93,7 @@ "кун" ], "hour": [ + "hr", "соат" ], "minute": [ diff --git a/dateparser/data/date_translation_data/uz-Latn.py b/dateparser/data/date_translation_data/uz-Latn.py index d49fbf56d..a65711151 100644 --- a/dateparser/data/date_translation_data/uz-Latn.py +++ b/dateparser/data/date_translation_data/uz-Latn.py @@ -116,12 +116,14 @@ "shu daqiqada" ], "0 month ago": [ + "bu oy", "shu oy" ], "0 second ago": [ "hozir" ], "0 week ago": [ + "bu hafta", "shu hafta" ], "0 year ago": [ @@ -138,8 +140,9 @@ "o‘tgan hafta" ], "1 year ago": [ - "o'tgan yil", - "o‘tgan yil" + "o‘'tgan yil", + "o‘tgan yil", + "o'tgan yil" ], "in 1 day": [ "ertaga" diff --git a/dateparser/data/date_translation_data/uz.py b/dateparser/data/date_translation_data/uz.py index 0ac605960..0bd3ce885 100644 --- a/dateparser/data/date_translation_data/uz.py +++ b/dateparser/data/date_translation_data/uz.py @@ -116,12 +116,14 @@ "shu daqiqada" ], "0 month ago": [ + "bu oy", "shu oy" ], "0 second ago": [ "hozir" ], "0 week ago": [ + "bu hafta", "shu hafta" ], "0 year ago": [ @@ -138,8 +140,9 @@ "o‘tgan hafta" ], "1 year ago": [ - "o'tgan yil", - "o‘tgan yil" + "o‘'tgan yil", + "o‘tgan yil", + "o'tgan yil" ], "in 1 day": [ "ertaga" diff --git a/dateparser/data/date_translation_data/vun.py b/dateparser/data/date_translation_data/vun.py index 431c71473..633dd8716 100644 --- a/dateparser/data/date_translation_data/vun.py +++ b/dateparser/data/date_translation_data/vun.py @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser/data/date_translation_data/wae.py b/dateparser/data/date_translation_data/wae.py index c894ab959..614eb62c5 100644 --- a/dateparser/data/date_translation_data/wae.py +++ b/dateparser/data/date_translation_data/wae.py @@ -96,7 +96,8 @@ "tag" ], "hour": [ - "schtund" + "schtund", + "stunde" ], "minute": [ "mínütta" diff --git a/dateparser/data/date_translation_data/xog.py b/dateparser/data/date_translation_data/xog.py index 125158899..e30aa5949 100644 --- a/dateparser/data/date_translation_data/xog.py +++ b/dateparser/data/date_translation_data/xog.py @@ -96,7 +96,8 @@ "olunaku" ], "hour": [ - "essawa" + "essawa", + "hr" ], "minute": [ "edakiika" diff --git a/dateparser/data/date_translation_data/yav.py b/dateparser/data/date_translation_data/yav.py index f59defcd5..24b76d278 100644 --- a/dateparser/data/date_translation_data/yav.py +++ b/dateparser/data/date_translation_data/yav.py @@ -96,6 +96,7 @@ "puɔ́sɛ́" ], "hour": [ + "hr", "kisikɛl," ], "minute": [ diff --git a/dateparser/data/date_translation_data/yi.py b/dateparser/data/date_translation_data/yi.py index 45544ec2c..a93450b8b 100644 --- a/dateparser/data/date_translation_data/yi.py +++ b/dateparser/data/date_translation_data/yi.py @@ -85,6 +85,7 @@ "טאָג" ], "hour": [ + "hr", "שעה" ], "minute": [ diff --git a/dateparser/data/date_translation_data/yo.py b/dateparser/data/date_translation_data/yo.py index a33322489..7ba3009cf 100644 --- a/dateparser/data/date_translation_data/yo.py +++ b/dateparser/data/date_translation_data/yo.py @@ -3,75 +3,106 @@ "date_order": "DMY", "january": [ "oṣù ṣẹ́rẹ́", + "ṣẹ́", + "ṣẹ́r", "ṣẹ́rẹ́" ], "february": [ "oṣù èrèlè", + "èr", + "èrèl", "èrèlè" ], "march": [ "oṣù ẹrẹ̀nà", + "ẹr", + "ẹrẹ̀n", "ẹrẹ̀nà" ], "april": [ "oṣù ìgbé", + "ìg", + "ìgb", "ìgbé" ], "may": [ "oṣù ẹ̀bibi", + "ẹ̀b", + "ẹ̀bi", "ẹ̀bibi" ], "june": [ "oṣù òkúdu", + "òk", + "òkú", "òkúdu" ], "july": [ + "ag", + "agẹ", "agẹmọ", "oṣù agẹmọ" ], "august": [ "oṣù ògún", + "òg", + "ògú", "ògún" ], "september": [ + "ow", + "owe", "owewe", "oṣù owewe" ], "october": [ "oṣù ọ̀wàrà", + "ọ̀w", + "ọ̀wà", "ọ̀wàrà" ], "november": [ + "bé", + "bél", "bélú", "oṣù bélú" ], "december": [ "oṣù ọ̀pẹ̀", + "ọ̀p", + "ọ̀pẹ", "ọ̀pẹ̀" ], "monday": [ + "aj", "ajé", "ọjọ́ ajé" ], "tuesday": [ + "ìsẹ́g", "ìsẹ́gun", "ọjọ́ ìsẹ́gun" ], "wednesday": [ + "ọjọ́r", "ọjọ́rú" ], "thursday": [ + "ọjọ́b", "ọjọ́bọ" ], "friday": [ + "ẹt", "ẹtì", "ọjọ́ ẹtì" ], "saturday": [ + "àbám", "àbámẹ́ta", "ọjọ́ àbámẹ́ta" ], "sunday": [ + "àìk", "àìkú", "ọjọ́ àìkú" ], @@ -85,15 +116,18 @@ "ọdún" ], "month": [ - "osù" + "osù", + "oṣù" ], "week": [ + "ọ̀sẹ̀", "ọ̀sè" ], "day": [ "ọjọ́" ], "hour": [ + "wkt", "wákàtí" ], "minute": [ @@ -113,39 +147,51 @@ "this minute" ], "0 month ago": [ + "oṣù yìí", "this month" ], "0 second ago": [ "now" ], "0 week ago": [ + "ọ̀sẹ̀ yìí", "this week" ], "0 year ago": [ + "ọdún yìí", + "ọdúnǹí", "this year" ], "1 day ago": [ "àná" ], "1 month ago": [ + "óṣù tó kọjá", "last month" ], "1 week ago": [ + "ọ̀sẹ̀ tó kọjá", "last week" ], "1 year ago": [ + "èṣín", + "ọdún tó kọjá", "last year" ], "in 1 day": [ "ọ̀la" ], "in 1 month": [ + "óṣù tó ń bọ̀,", "next month" ], "in 1 week": [ + "ọ́sẹ̀ tó ń bọ̀", "next week" ], "in 1 year": [ + "àmọ́dún", + "ọdún tó ńbọ̀", "next year" ] }, @@ -154,6 +200,8 @@ "name": "yo-BJ", "january": [ "oshù shɛ́rɛ́", + "shɛ́", + "shɛ́r", "shɛ́rɛ́" ], "february": [ @@ -161,6 +209,8 @@ ], "march": [ "oshù ɛrɛ̀nà", + "ɛr", + "ɛrɛ̀n", "ɛrɛ̀nà" ], "april": [ @@ -168,12 +218,15 @@ ], "may": [ "oshù ɛ̀bibi", + "ɛ̀b", + "ɛ̀bi", "ɛ̀bibi" ], "june": [ "oshù òkúdu" ], "july": [ + "agɛ", "agɛmɔ", "oshù agɛmɔ" ], @@ -185,6 +238,8 @@ ], "october": [ "oshù ɔ̀wàrà", + "ɔ̀w", + "ɔ̀wà", "ɔ̀wàrà" ], "november": [ @@ -192,23 +247,29 @@ ], "december": [ "oshù ɔ̀pɛ̀", + "ɔ̀p", + "ɔ̀pɛ", "ɔ̀pɛ̀" ], "monday": [ "ɔjɔ́ ajé" ], "tuesday": [ + "ìsɛ́g", "ìsɛ́gun", "ɔjɔ́ ìsɛ́gun" ], "wednesday": [ + "ɔjɔ́r", "ɔjɔ́rú" ], "thursday": [ + "ɔjɔ́b", "ɔjɔ́bɔ" ], "friday": [ "ɔjɔ́ ɛtì", + "ɛt", "ɛtì" ], "saturday": [ @@ -227,7 +288,11 @@ "year": [ "ɔdún" ], + "month": [ + "oshù" + ], "week": [ + "ɔ̀sɛ̀", "ɔ̀sè" ], "day": [ @@ -240,8 +305,38 @@ "ìsɛ́jú ààyá" ], "relative-type": { + "0 month ago": [ + "oshù yìí" + ], + "0 week ago": [ + "ɔ̀sɛ̀ yìí" + ], + "0 year ago": [ + "ɔdún yìí", + "ɔdúnǹí" + ], + "1 month ago": [ + "óshù tó kɔjá" + ], + "1 week ago": [ + "ɔ̀sɛ̀ tó kɔjá" + ], + "1 year ago": [ + "èshín", + "ɔdún tó kɔjá" + ], "in 1 day": [ "ɔ̀la" + ], + "in 1 month": [ + "óshù tó ń bɔ̀," + ], + "in 1 week": [ + "ɔ́sɛ̀ tó ń bɔ̀" + ], + "in 1 year": [ + "àmɔ́dún", + "ɔdún tó ńbɔ̀" ] } } diff --git a/dateparser/data/date_translation_data/zgh.py b/dateparser/data/date_translation_data/zgh.py index 06337d547..a2542f50f 100644 --- a/dateparser/data/date_translation_data/zgh.py +++ b/dateparser/data/date_translation_data/zgh.py @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser/data/date_translation_data/zh-Hant.py b/dateparser/data/date_translation_data/zh-Hant.py index 16f7f3bee..adf523cfd 100644 --- a/dateparser/data/date_translation_data/zh-Hant.py +++ b/dateparser/data/date_translation_data/zh-Hant.py @@ -212,9 +212,6 @@ "1 day ago": [ "昨日" ], - "1 month ago": [ - "上月" - ], "1 week ago": [ "上星期" ], @@ -224,14 +221,17 @@ "in 1 day": [ "明日" ], - "in 1 month": [ - "下月" - ], "in 1 week": [ "下星期" ], "in 1 year": [ "下年" + ], + "1 month ago": [ + "上月" + ], + "in 1 month": [ + "下月" ] }, "relative-type-regex": { @@ -253,6 +253,7 @@ ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) 星期前", + "(\\d++[.,]?\\d*+)星期前", "(\\d++[.,]?\\d*+)週前" ], "\\1 year ago": [ @@ -276,6 +277,7 @@ ], "in \\1 week": [ "(\\d++[.,]?\\d*+) 星期後", + "(\\d++[.,]?\\d*+)星期後", "(\\d++[.,]?\\d*+)週後" ], "in \\1 year": [ @@ -311,9 +313,6 @@ "1 day ago": [ "昨日" ], - "1 month ago": [ - "上月" - ], "1 week ago": [ "上星期" ], @@ -323,14 +322,17 @@ "in 1 day": [ "明日" ], - "in 1 month": [ - "下月" - ], "in 1 week": [ "下星期" ], "in 1 year": [ "下年" + ], + "1 month ago": [ + "上月" + ], + "in 1 month": [ + "下月" ] }, "relative-type-regex": { @@ -352,6 +354,7 @@ ], "\\1 week ago": [ "(\\d++[.,]?\\d*+) 星期前", + "(\\d++[.,]?\\d*+)星期前", "(\\d++[.,]?\\d*+)週前" ], "\\1 year ago": [ @@ -375,6 +378,7 @@ ], "in \\1 week": [ "(\\d++[.,]?\\d*+) 星期後", + "(\\d++[.,]?\\d*+)星期後", "(\\d++[.,]?\\d*+)週後" ], "in \\1 year": [ diff --git a/dateparser/data/date_translation_data/zu.py b/dateparser/data/date_translation_data/zu.py index e608a7edb..ae4fa914e 100644 --- a/dateparser/data/date_translation_data/zu.py +++ b/dateparser/data/date_translation_data/zu.py @@ -97,6 +97,7 @@ "usuku" ], "hour": [ + "amahora", "ihora" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/af.json b/dateparser_data/cldr_language_data/date_translation_data/af.json index a96e9f0f4..dfe398227 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/af.json +++ b/dateparser_data/cldr_language_data/date_translation_data/af.json @@ -109,7 +109,6 @@ ], "second": [ "s", - "sek", "sekonde" ], "relative-type": { @@ -123,39 +122,48 @@ "hierdie minuut" ], "0 month ago": [ + "hierdie md", "vandeesmaand" ], "0 second ago": [ "nou" ], "0 week ago": [ - "vandeesweek" + "hierdie w", + "hierdie week" ], "0 year ago": [ + "hierdie j", "hierdie jaar" ], "1 day ago": [ "gister" ], "1 month ago": [ - "verlede maand" + "verlede maand", + "verlede md" ], "1 week ago": [ + "verlede w", "verlede week" ], "1 year ago": [ + "verlede j", "verlede jaar" ], "in 1 day": [ "môre" ], "in 1 month": [ - "volgende maand" + "volgende maand", + "volgende md" ], "in 1 week": [ + "volgende w", "volgende week" ], "in 1 year": [ + "volgende j", "volgende jaar" ] }, @@ -165,6 +173,7 @@ "{0} dag gelede" ], "\\1 hour ago": [ + "{0} u gelede", "{0} uur gelede" ], "\\1 minute ago": [ @@ -178,7 +187,7 @@ "{0} md gelede" ], "\\1 second ago": [ - "{0} sek gelede", + "{0} s gelede", "{0} sekonde gelede", "{0} sekondes gelede" ], @@ -188,26 +197,29 @@ "{0} weke gelede" ], "\\1 year ago": [ + "{0} j gelede", "{0} jaar gelede" ], "in \\1 day": [ "oor {0} dae", - "oor {0} dag", - "oor {0} minuut" + "oor {0} dag" ], "in \\1 hour": [ + "oor {0} u", "oor {0} uur" ], "in \\1 minute": [ "oor {0} min", + "oor {0} minute", "oor {0} minuut" ], "in \\1 month": [ - "oor {0} md", - "oor {0} minuut" + "oor {0} maand", + "oor {0} maande", + "oor {0} md" ], "in \\1 second": [ - "oor {0} sek", + "oor {0} s", "oor {0} sekonde", "oor {0} sekondes" ], @@ -217,6 +229,7 @@ "oor {0} weke" ], "in \\1 year": [ + "oor {0} j", "oor {0} jaar" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/agq.json b/dateparser_data/cldr_language_data/date_translation_data/agq.json index 7de864742..3f9f4469c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/agq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/agq.json @@ -96,6 +96,7 @@ "utsuʔ" ], "hour": [ + "hr", "tàm" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ak.json b/dateparser_data/cldr_language_data/date_translation_data/ak.json index c21f1124c..e0e678fbe 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ak.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ak.json @@ -96,7 +96,8 @@ "da" ], "hour": [ - "dɔnhwer" + "dɔnhwer", + "hr" ], "minute": [ "sema" diff --git a/dateparser_data/cldr_language_data/date_translation_data/am.json b/dateparser_data/cldr_language_data/date_translation_data/am.json index 9418a71bb..810cbdfa3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/am.json +++ b/dateparser_data/cldr_language_data/date_translation_data/am.json @@ -2,12 +2,12 @@ "name": "am", "date_order": "DMY", "january": [ - "ጃንዩ", - "ጃንዩወሪ" + "ጃን", + "ጃንዋሪ" ], "february": [ - "ፌብሩ", - "ፌብሩወሪ" + "ፌብ", + "ፌብሩዋሪ" ], "march": [ "ማርች" @@ -86,7 +86,8 @@ "ቀን" ], "hour": [ - "ሰዓት" + "ሰዓት", + "ሰዓቶች" ], "minute": [ "ደቂቃ" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ar.json b/dateparser_data/cldr_language_data/date_translation_data/ar.json index f144bddce..5dbeb4b27 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ar.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ar.json @@ -79,7 +79,8 @@ "يوم" ], "hour": [ - "الساعات" + "الساعات", + "ساعات" ], "minute": [ "الدقائق" @@ -262,8 +263,7 @@ "أيلول" ], "october": [ - "تشرين الأول", - "تشرین الأول" + "تشرين الأول" ], "november": [ "تشرين الثاني" diff --git a/dateparser_data/cldr_language_data/date_translation_data/as.json b/dateparser_data/cldr_language_data/date_translation_data/as.json index bb432d2b8..048ebdf1c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/as.json +++ b/dateparser_data/cldr_language_data/date_translation_data/as.json @@ -1,6 +1,6 @@ { "name": "as", - "date_order": "YMD", + "date_order": "DMY", "january": [ "জানু", "জানুৱাৰী" @@ -16,7 +16,7 @@ "এপ্ৰিল" ], "may": [ - "মে" + "মে'" ], "june": [ "জুন" @@ -29,20 +29,20 @@ "আগষ্ট" ], "september": [ - "ছেপ্তেম্বৰ", - "সেপ্ট" + "ছেপ্তে", + "ছেপ্তেম্বৰ" ], "october": [ "অক্টো", "অক্টোবৰ" ], "november": [ - "নভে", + "নৱে", "নৱেম্বৰ" ], "december": [ - "ডিচেম্বৰ", - "ডিসে" + "ডিচে", + "ডিচেম্বৰ" ], "monday": [ "সোম", @@ -57,8 +57,8 @@ "বুধবাৰ" ], "thursday": [ - "বৃহষ্পতি", - "বৃহষ্পতিবাৰ" + "বৃহ", + "বৃহস্পতিবাৰ" ], "friday": [ "শুক্ৰ", @@ -69,14 +69,14 @@ "শনিবাৰ" ], "sunday": [ - "দেওবাৰ", - "ৰবি" + "দেও", + "দেওবাৰ" ], "am": [ - "পূৰ্বাহ্ণ" + "পূৰ্বাহ্ন" ], "pm": [ - "অপৰাহ্ণ" + "অপৰাহ্ন" ], "year": [ "বছৰ" @@ -104,46 +104,92 @@ "আজি" ], "0 hour ago": [ - "this hour" + "এইটো ঘণ্টাত" ], "0 minute ago": [ - "this minute" + "এইটো মিনিটত" ], "0 month ago": [ - "this month" + "এই মা", + "এই মাহ" ], "0 second ago": [ - "now" + "এতিয়া" ], "0 week ago": [ - "this week" + "এই সপ্তাহ" ], "0 year ago": [ - "this year" + "এই বছৰ" ], "1 day ago": [ "কালি" ], "1 month ago": [ - "last month" + "যোৱা মা", + "যোৱা মাহ" ], "1 week ago": [ - "last week" + "যোৱা সপ্তাহ" ], "1 year ago": [ - "last year" + "যোৱা বছৰ" ], "in 1 day": [ "কাইলৈ" ], "in 1 month": [ - "next month" + "অহা মাহ" ], "in 1 week": [ - "next week" + "অহা সপ্তাহ" ], "in 1 year": [ - "next year" + "অহা বছৰ" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "{0} দিন পূৰ্বে" + ], + "\\1 hour ago": [ + "{0} ঘণ্টা পূৰ্বে" + ], + "\\1 minute ago": [ + "{0} মিনিট পূৰ্বে" + ], + "\\1 month ago": [ + "{0} মাহ পূৰ্বে" + ], + "\\1 second ago": [ + "{0} ছেকেণ্ড পূৰ্বে" + ], + "\\1 week ago": [ + "{0} সপ্তাহ পূৰ্বে" + ], + "\\1 year ago": [ + "{0} বছৰৰ পূৰ্বে" + ], + "in \\1 day": [ + "{0} দিনত" + ], + "in \\1 hour": [ + "{0} ঘণ্টাত" + ], + "in \\1 minute": [ + "{0} মিনিটত" + ], + "in \\1 month": [ + "{0} মাহত" + ], + "in \\1 second": [ + "{0} ছেকেণ্ডত" + ], + "in \\1 week": [ + "{0} সপ্তাহত" + ], + "in \\1 year": [ + "{0} বছৰত" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/asa.json b/dateparser_data/cldr_language_data/date_translation_data/asa.json index 0fb5fcd39..28c9cbb1b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/asa.json +++ b/dateparser_data/cldr_language_data/date_translation_data/asa.json @@ -95,6 +95,7 @@ "thiku" ], "hour": [ + "hr", "thaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ast.json b/dateparser_data/cldr_language_data/date_translation_data/ast.json index bde84f295..88e831430 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ast.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ast.json @@ -114,7 +114,8 @@ ], "hour": [ "h", - "hora" + "hora", + "hores" ], "minute": [ "m", diff --git a/dateparser_data/cldr_language_data/date_translation_data/az-Cyrl.json b/dateparser_data/cldr_language_data/date_translation_data/az-Cyrl.json index 120985fcb..a7792ece7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/az-Cyrl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/az-Cyrl.json @@ -95,7 +95,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/az-Latn.json b/dateparser_data/cldr_language_data/date_translation_data/az-Latn.json index d0a3d6bac..59a971ceb 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/az-Latn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/az-Latn.json @@ -22,13 +22,11 @@ ], "june": [ "iyn", - "iyun", - "i̇yun" + "iyun" ], "july": [ "iyl", - "iyul", - "i̇yul" + "iyul" ], "august": [ "avq", diff --git a/dateparser_data/cldr_language_data/date_translation_data/az.json b/dateparser_data/cldr_language_data/date_translation_data/az.json index 7607667bf..0f5684f45 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/az.json +++ b/dateparser_data/cldr_language_data/date_translation_data/az.json @@ -22,13 +22,11 @@ ], "june": [ "iyn", - "iyun", - "i̇yun" + "iyun" ], "july": [ "iyl", - "iyul", - "i̇yul" + "iyul" ], "august": [ "avq", diff --git a/dateparser_data/cldr_language_data/date_translation_data/bas.json b/dateparser_data/cldr_language_data/date_translation_data/bas.json index d6792c897..2a58d0d41 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bas.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bas.json @@ -96,6 +96,7 @@ "kɛl" ], "hour": [ + "hr", "ŋgɛŋ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/be.json b/dateparser_data/cldr_language_data/date_translation_data/be.json index 4ebcf51a9..f76bb1f83 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/be.json +++ b/dateparser_data/cldr_language_data/date_translation_data/be.json @@ -111,7 +111,8 @@ ], "hour": [ "гадз", - "гадзіна" + "гадзіна", + "гадзіны" ], "minute": [ "хв", @@ -132,12 +133,14 @@ "у гэту хвіліну" ], "0 month ago": [ + "у гэтым мес", "у гэтым месяцы" ], "0 second ago": [ "цяпер" ], "0 week ago": [ + "на гэтым тыд", "на гэтым тыдні" ], "0 year ago": [ @@ -147,30 +150,35 @@ "учора" ], "1 month ago": [ + "у мін мес", "у мінулым месяцы" ], "1 week ago": [ + "на мін тыд", "на мінулым тыдні" ], "1 year ago": [ + "у мін годзе", "у мінулым годзе" ], "in 1 day": [ "заўтра" ], "in 1 month": [ + "у наст мес", "у наступным месяцы" ], "in 1 week": [ + "на наст тыд", "на наступным тыдні" ], "in 1 year": [ + "у наст годзе", "у наступным годзе" ] }, "relative-type-regex": { "\\1 day ago": [ - "{0} д таму", "{0} дзень таму", "{0} дня таму" ], @@ -205,7 +213,6 @@ "{0} года таму" ], "in \\1 day": [ - "праз {0} д", "праз {0} дзень", "праз {0} дня" ], diff --git a/dateparser_data/cldr_language_data/date_translation_data/bem.json b/dateparser_data/cldr_language_data/date_translation_data/bem.json index a67b7bbfd..50d29b792 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bem.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bem.json @@ -88,6 +88,7 @@ "ubushiku" ], "hour": [ + "hr", "insa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/bez.json b/dateparser_data/cldr_language_data/date_translation_data/bez.json index 5e6eca7e5..d331940a6 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bez.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bez.json @@ -96,6 +96,7 @@ "sihu" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/bg.json b/dateparser_data/cldr_language_data/date_translation_data/bg.json index 63b57171d..e279706b5 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bg.json @@ -83,10 +83,11 @@ ], "year": [ "г", + "год", "година" ], "month": [ - "м", + "мес", "месец" ], "week": [ @@ -99,14 +100,15 @@ ], "hour": [ "ч", - "час" + "час", + "часове" ], "minute": [ "мин", "минута" ], "second": [ - "с", + "сек", "секунда" ], "relative-type": { @@ -145,7 +147,6 @@ ], "1 week ago": [ "мин седм", - "миналата седмица", "предходната седмица" ], "1 year ago": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/bm.json b/dateparser_data/cldr_language_data/date_translation_data/bm.json index 5f869a256..297b4e716 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bm.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bm.json @@ -94,6 +94,7 @@ "don" ], "hour": [ + "hr", "lɛrɛ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/bn.json b/dateparser_data/cldr_language_data/date_translation_data/bn.json index 323afb47d..0cc83110b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bn.json @@ -13,6 +13,7 @@ "মার্চ" ], "april": [ + "এপ্রি", "এপ্রিল" ], "may": [ @@ -22,21 +23,27 @@ "জুন" ], "july": [ + "জুল", "জুলাই" ], "august": [ + "আগ", "আগস্ট" ], "september": [ + "সেপ", "সেপ্টেম্বর" ], "october": [ + "অক্টো", "অক্টোবর" ], "november": [ + "নভে", "নভেম্বর" ], "december": [ + "ডিসে", "ডিসেম্বর" ], "monday": [ @@ -52,7 +59,6 @@ "বুধবার" ], "thursday": [ - "বৃহষ্পতিবার", "বৃহস্পতি", "বৃহস্পতিবার" ], @@ -87,6 +93,7 @@ "দিন" ], "hour": [ + "ঘণ্টা", "ঘন্টা" ], "minute": [ @@ -150,8 +157,7 @@ "{0} ঘন্টা আগে" ], "\\1 minute ago": [ - "{0} মিনিট আগে", - "{0} মিনিট পূর্বে" + "{0} মিনিট আগে" ], "\\1 month ago": [ "{0} মাস আগে" @@ -190,7 +196,19 @@ }, "locale_specific": { "bn-IN": { - "name": "bn-IN" + "name": "bn-IN", + "september": [ + "সেপ্টেঃ" + ], + "october": [ + "অক্টোঃ" + ], + "november": [ + "নভেঃ" + ], + "december": [ + "ডিসেঃ" + ] } } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/bo.json b/dateparser_data/cldr_language_data/date_translation_data/bo.json index 8a93daa47..7c9bff6a1 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bo.json @@ -108,6 +108,7 @@ "ཉིན།" ], "hour": [ + "hr", "ཆུ་ཚོད་" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/br.json b/dateparser_data/cldr_language_data/date_translation_data/br.json index 87ce96aff..036e88d63 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/br.json +++ b/dateparser_data/cldr_language_data/date_translation_data/br.json @@ -1,6 +1,6 @@ { "name": "br", - "date_order": "YMD", + "date_order": "DMY", "january": [ "gen", "genver" @@ -42,7 +42,6 @@ "du" ], "december": [ - "ker", "kerzu", "kzu" ], @@ -78,13 +77,16 @@ "gm" ], "year": [ + "b", "bl", "bloaz" ], "month": [ + "m", "miz" ], "week": [ + "sizh", "sizhun" ], "day": [ @@ -93,7 +95,8 @@ ], "hour": [ "e", - "eur" + "eur", + "eurioù" ], "minute": [ "min", @@ -108,12 +111,13 @@ "hiziv" ], "0 hour ago": [ - "this hour" + "d'an eur-mañ" ], "0 minute ago": [ - "this minute" + "ar munut-mañ" ], "0 month ago": [ + "ar m-mañ", "ar miz-mañ" ], "0 second ago": [ @@ -121,6 +125,7 @@ "bremañ" ], "0 week ago": [ + "ar sizh-mañ", "ar sizhun-mañ" ], "0 year ago": [ @@ -130,9 +135,11 @@ "dec'h" ], "1 month ago": [ + "ar m diaraok", "ar miz diaraok" ], "1 week ago": [ + "ar sizh diaraok", "ar sizhun diaraok" ], "1 year ago": [ @@ -142,9 +149,11 @@ "warc'hoazh" ], "in 1 month": [ + "ar m a zeu", "ar miz a zeu" ], "in 1 week": [ + "ar sizh a zeu", "ar sizhun a zeu" ], "in 1 year": [ @@ -173,6 +182,7 @@ "{0} s zo" ], "\\1 week ago": [ + "{0} sizh zo", "{0} sizhun zo" ], "\\1 year ago": [ @@ -200,6 +210,7 @@ "a-benn {0} s" ], "in \\1 week": [ + "a-benn {0} sizh", "a-benn {0} sizhun" ], "in \\1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/brx.json b/dateparser_data/cldr_language_data/date_translation_data/brx.json index bcac7ebb7..c46097549 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/brx.json +++ b/dateparser_data/cldr_language_data/date_translation_data/brx.json @@ -1,17 +1,20 @@ { "name": "brx", - "date_order": "MDY", + "date_order": "DMY", "january": [ + "जान", "जानुवारी" ], "february": [ - "फेब्रुवारी" + "फेब", + "फेब्रूवारी" ], "march": [ - "मार्स" + "मार्च" ], "april": [ - "एफ्रिल" + "एप्रि", + "एप्रिल" ], "may": [ "मे" @@ -20,22 +23,28 @@ "जुन" ], "july": [ - "जुलाइ" + "जुल", + "जुलाई" ], "august": [ - "आगस्थ" + "आग", + "आगष्ट" ], "september": [ - "सेबथेज्ब़र" + "सेप", + "सेप्थेम्बर" ], "october": [ - "अखथबर" + "अक्ट'", + "अक्ट'बर" ], "november": [ - "नबेज्ब़र" + "नवे", + "नवेम्बर" ], "december": [ - "दिसेज्ब़र" + "डिसे", + "डिसेम्बर" ], "monday": [ "सम", @@ -46,20 +55,21 @@ "मंगलबार" ], "wednesday": [ - "बुद", - "बुदबार" + "बुध", + "बुधबार" ], "thursday": [ - "बिसथि", - "बिसथिबार" + "बिस्थि", + "बिस्थिबार" ], "friday": [ "सुखुर", - "सुखुरबार" + "सुखुरबार", + "सुुखुरबार" ], "saturday": [ - "सुनि", - "सुनिबार" + "सनि", + "सनिबार" ], "sunday": [ "रबि", @@ -78,65 +88,110 @@ "दान" ], "week": [ - "सबथा/हबथा" + "सप्थाह" ], "day": [ "सान" ], "hour": [ - "रिंगा" + "hr", + "घन्टा" ], "minute": [ - "मिनिथ" + "मिनित" ], "second": [ - "सेखेन्द" + "सेकेण्ड" ], "relative-type": { "0 day ago": [ "दिनै" ], "0 hour ago": [ - "this hour" + "बे घन्टा" ], "0 minute ago": [ - "this minute" + "बे मिनिट" ], "0 month ago": [ - "this month" + "बे दान" ], "0 second ago": [ - "now" + "दा" ], "0 week ago": [ - "this week" + "बे सप्थाह" ], "0 year ago": [ - "this year" + "बे बोसोर" ], "1 day ago": [ "मैया" ], "1 month ago": [ - "last month" + "थांनाय दान" ], "1 week ago": [ - "last week" + "थांनाय सप्थाह" ], "1 year ago": [ - "last year" + "थांनाय बोसोर" ], "in 1 day": [ "गाबोन" ], "in 1 month": [ - "next month" + "फैगौ दान" ], "in 1 week": [ - "next week" + "फैगौ सप्थाह" ], "in 1 year": [ - "next year" + "फैगौ बोसोर" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "{0} सान सिगां" + ], + "\\1 hour ago": [ + "{0} घन्टा सिगां" + ], + "\\1 minute ago": [ + "{0} मिनिट सिगां" + ], + "\\1 month ago": [ + "{0} दान सिगां" + ], + "\\1 second ago": [ + "{0} सेकेण्ड सिगां" + ], + "\\1 week ago": [ + "{0} सप्थाह सिगां" + ], + "\\1 year ago": [ + "{0} बोसोर सिगां" + ], + "in \\1 day": [ + "{0} सानाव" + ], + "in \\1 hour": [ + "{0} घन्टायाव" + ], + "in \\1 minute": [ + "{0} मिनिटआव" + ], + "in \\1 month": [ + "{0} दानाव" + ], + "in \\1 second": [ + "{0} सेकेण्डआव" + ], + "in \\1 week": [ + "{0} सप्थाहयाव" + ], + "in \\1 year": [ + "{0} बोसोरआव" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/bs-Cyrl.json b/dateparser_data/cldr_language_data/date_translation_data/bs-Cyrl.json index 855eebd8c..c9e190cdd 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bs-Cyrl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bs-Cyrl.json @@ -29,8 +29,8 @@ "јули" ], "august": [ - "авг", - "август" + "ауг", + "аугуст" ], "september": [ "сеп", @@ -50,7 +50,7 @@ ], "monday": [ "пон", - "понедељак" + "понедјељак" ], "tuesday": [ "уто", @@ -74,33 +74,41 @@ ], "sunday": [ "нед", - "недеља" + "недјеља" ], "am": [ - "пре подне" + "пре подне", + "прије подне" ], "pm": [ - "поподне" + "поподне", + "послије подне" ], "year": [ + "год", "година" ], "month": [ - "месец" + "мјес", + "мјесец" ], "week": [ - "недеља" + "седм", + "седмица" ], "day": [ "дан" ], "hour": [ - "час" + "сат", + "сати" ], "minute": [ + "мин", "минут" ], "second": [ + "сек", "секунд" ], "relative-type": { @@ -108,76 +116,92 @@ "данас" ], "0 hour ago": [ - "this hour" + "овог сата" ], "0 minute ago": [ - "this minute" + "овог минута" ], "0 month ago": [ - "овог месеца" + "ов мјес", + "овог мјес", + "овог мјесеца" ], "0 second ago": [ - "now" + "сада" ], "0 week ago": [ - "ове недеље" + "ове седм", + "ове седмице" ], "0 year ago": [ + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ - "прошлог месеца" + "прош мјес", + "прош мјесеца", + "прошлог мјесеца" ], "1 week ago": [ - "прошле недеље" + "прош седм", + "прошле седмице" ], "1 year ago": [ + "прош године", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ - "следећег месеца" + "сљ мјес", + "сљед мјесеца", + "сљедећег мјесеца" ], "in 1 week": [ - "следеће недеље" + "сљ седм", + "сљедеће седмице" ], "in 1 year": [ - "следеће године" + "сљед године", + "сљедеће године" ] }, "relative-type-regex": { "\\1 day ago": [ - "пре {0} дан", - "пре {0} дана" + "прије {0} дан", + "прије {0} дана" ], "\\1 hour ago": [ - "пре {0} сат", - "пре {0} сати" + "прије {0} сат", + "прије {0} сати" ], "\\1 minute ago": [ - "пре {0} минут", - "пре {0} минута" + "прије {0} мин", + "прије {0} минут", + "прије {0} минута" ], "\\1 month ago": [ - "пре {0} месец", - "пре {0} месеци" + "прије {0} мјес", + "прије {0} мјесец", + "прије {0} мјесеци" ], "\\1 second ago": [ - "пре {0} секунд", - "пре {0} секунди" + "прије {0} сек", + "прије {0} секунд", + "прије {0} секунди" ], "\\1 week ago": [ - "пре {0} недеља", - "пре {0} недељу" + "прије {0} седм", + "прије {0} седмица", + "прије {0} седмицу" ], "\\1 year ago": [ - "пре {0} година", - "пре {0} годину" + "прије {0} година", + "прије {0} годину" ], "in \\1 day": [ "за {0} дан", @@ -192,16 +216,19 @@ "за {0} минута" ], "in \\1 month": [ - "за {0} месец", - "за {0} месеци" + "за {0} мјес", + "за {0} мјесец", + "за {0} мјесеци" ], "in \\1 second": [ + "за {0} сек", "за {0} секунд", "за {0} секунди" ], "in \\1 week": [ - "за {0} недеља", - "за {0} недељу" + "за {0} седм", + "за {0} седмица", + "за {0} седмицу" ], "in \\1 year": [ "за {0} година", diff --git a/dateparser_data/cldr_language_data/date_translation_data/bs-Latn.json b/dateparser_data/cldr_language_data/date_translation_data/bs-Latn.json index 8054554e8..a56d562f5 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bs-Latn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bs-Latn.json @@ -29,8 +29,8 @@ "juli" ], "august": [ - "avg", - "avgust" + "aug", + "august" ], "september": [ "sep", @@ -77,9 +77,11 @@ "nedjelja" ], "am": [ + "am", "prijepodne" ], "pm": [ + "pm", "popodne" ], "year": [ @@ -100,7 +102,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/bs.json b/dateparser_data/cldr_language_data/date_translation_data/bs.json index 19707b019..7f2b8693f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/bs.json +++ b/dateparser_data/cldr_language_data/date_translation_data/bs.json @@ -29,8 +29,8 @@ "juli" ], "august": [ - "avg", - "avgust" + "aug", + "august" ], "september": [ "sep", @@ -77,9 +77,11 @@ "nedjelja" ], "am": [ + "am", "prijepodne" ], "pm": [ + "pm", "popodne" ], "year": [ @@ -100,7 +102,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/ca.json b/dateparser_data/cldr_language_data/date_translation_data/ca.json index eff1aaae8..411384232 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ca.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ca.json @@ -116,7 +116,8 @@ ], "hour": [ "h", - "hora" + "hora", + "hores" ], "minute": [ "min", @@ -153,13 +154,11 @@ "ahir" ], "1 month ago": [ - "el mes passat", - "mes passat" + "el mes passat" ], "1 week ago": [ "la setm passada", - "la setmana passada", - "setm passada" + "la setmana passada" ], "1 year ago": [ "l'any passat" @@ -168,13 +167,11 @@ "demà" ], "in 1 month": [ - "el mes que ve", - "mes vinent" + "el mes que ve" ], "in 1 week": [ "la setm que ve", - "la setmana que ve", - "setm vinent" + "la setmana que ve" ], "in 1 year": [ "l'any que ve" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ce.json b/dateparser_data/cldr_language_data/date_translation_data/ce.json index cacb80538..70f935ce2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ce.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ce.json @@ -49,25 +49,32 @@ "декабрь" ], "monday": [ - "оршотан де" + "ор", + "оршот" ], "tuesday": [ - "шинарин де" + "ши", + "шинара" ], "wednesday": [ - "кхаарин де" + "кха", + "кхаара" ], "thursday": [ - "еарин де" + "еа", + "еара" ], "friday": [ - "пӏераскан де" + "пӏе", + "пӏераска" ], "saturday": [ - "шот де" + "шуо", + "шуот" ], "sunday": [ - "кӏиранан де" + "кӏи", + "кӏира" ], "am": [ "am" @@ -92,7 +99,8 @@ ], "hour": [ "сахь", - "сахьт" + "сахьт", + "сахьташ" ], "minute": [ "мин", @@ -107,16 +115,16 @@ "тахана" ], "0 hour ago": [ - "this hour" + "хӏокху сахьтехь" ], "0 minute ago": [ - "this minute" + "хӏокху минотехь" ], "0 month ago": [ "карарчу баттахь" ], "0 second ago": [ - "now" + "хӏинца" ], "0 week ago": [ "карарчу кӏирнахь" diff --git a/dateparser_data/cldr_language_data/date_translation_data/cgg.json b/dateparser_data/cldr_language_data/date_translation_data/cgg.json index 7765763cc..752cf9e55 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/cgg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/cgg.json @@ -96,6 +96,7 @@ "eizooba" ], "hour": [ + "hr", "shaaha" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/chr.json b/dateparser_data/cldr_language_data/date_translation_data/chr.json index aa484dbb8..018369055 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/chr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/chr.json @@ -81,6 +81,7 @@ "ꮜꮎꮄ" ], "pm": [ + "ꮢꭿᏹꭲ", "ꮢꭿᏹꭲꮧꮲ" ], "year": [ @@ -99,6 +100,7 @@ "ꭲꭶ" ], "hour": [ + "ꭲᏻꮯꮆꮣ", "ꮡꮯ", "ꮡꮯꮆꮣ" ], @@ -107,6 +109,7 @@ "ꭲꮿꮤꮼꮝꮤꮕ" ], "second": [ + "ꭰꮞ", "ꭰꮞꮲ" ], "relative-type": { @@ -120,6 +123,7 @@ "ꭿꭰ ꭲꮿꮤꮼꮝꮤꮕ" ], "0 month ago": [ + "ꭿꭰ ꭷꮈ", "ꭿꭰ ꭷꮈꭲ" ], "0 second ago": [ @@ -135,6 +139,7 @@ "ꮢꭿ" ], "1 month ago": [ + "ꭷꮈ ꮵꭸꮢ", "ꭷꮈꭲ ꮵꭸꮢ" ], "1 week ago": [ @@ -147,6 +152,8 @@ "ꮜꮎꮄꭲ" ], "in 1 month": [ + "ꭿꭰ ꭷꮈ", + "ꮤꮅꮑ ꭷꮈ", "ꮤꮅꮑ ꭷꮈꭲ" ], "in 1 week": [ @@ -163,31 +170,32 @@ ], "\\1 hour ago": [ "{0} ꭲᏻꮯꮆꮣ ꮵꭸꮢ", - "{0} ꮡꮯꮆꮣ ꮵꭸꮢ", - "ꮎꮏ {0} ꮡꮯ ꮵꭸꮢ" + "{0} ꮡꮯ ꮵꭸꮢ", + "{0} ꮡꮯꮆꮣ ꮵꭸꮢ" ], "\\1 minute ago": [ - "ꮎꮏ {0} ꭲꮿꮤ ꮵꭸꮢ", - "ꮎꮏ {0} ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ" + "{0} ꭲꮿꮤ ꮵꭸꮢ", + "{0} ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ" ], "\\1 month ago": [ - "ꮎꮏ {0} ꭷꮈ ꮵꭸꮢ", - "ꮎꮏ {0} ꭷꮈꭲ ꮵꭸꮢ", - "ꮎꮏ {0} ꮧꭷꮈꭲ ꮵꭸꮢ" + "{0} ꭷꮈ ꮵꭸꮢ", + "{0} ꭷꮈꭲ ꮵꭸꮢ", + "{0} ꮧꭷꮈꭲ ꮵꭸꮢ" ], "\\1 second ago": [ + "{0} ꭰꮞ ꮵꭸꮢ", "{0} ꭰꮞꮲ ꮵꭸꮢ", "{0} ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], "\\1 week ago": [ - "ꮎꮏ {0} ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", - "ꮎꮏ {0} ꮢꮎ ꮵꭸꮢ", - "ꮎꮏ {0} ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ" + "{0} ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ", + "{0} ꮢꮎ ꮵꭸꮢ", + "{0} ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ" ], "\\1 year ago": [ "{0} ꭲꮷꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", - "{0} ꭴꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ", - "ꮎꮏ {0} ꭴꮥ ꮵꭸꮢ" + "{0} ꭴꮥ ꮵꭸꮢ", + "{0} ꭴꮥꮨᏼꮜꮧꮢꭲ ꮵꭸꮢ" ], "in \\1 day": [ "ꮎꮏ {0} ꭲꭶ", @@ -208,6 +216,7 @@ "ꮎꮏ {0} ꮧꭷꮈꭲ" ], "in \\1 second": [ + "ꮎꮏ {0} ꭰꮞ", "ꮎꮏ {0} ꭰꮞꮲ", "ꮎꮏ {0} ꮣꮣꮎꮹꮝꭼ ꮵꭸꮢ" ], diff --git a/dateparser_data/cldr_language_data/date_translation_data/ckb.json b/dateparser_data/cldr_language_data/date_translation_data/ckb.json index 77e79baf7..d04ed463d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ckb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ckb.json @@ -77,7 +77,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/cs.json b/dateparser_data/cldr_language_data/date_translation_data/cs.json index 1b3e38285..2e4db6421 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/cs.json +++ b/dateparser_data/cldr_language_data/date_translation_data/cs.json @@ -111,7 +111,8 @@ ], "hour": [ "h", - "hodina" + "hodina", + "hodiny" ], "minute": [ "min", @@ -132,6 +133,7 @@ "tuto minutu" ], "0 month ago": [ + "tento měs", "tento měsíc" ], "0 second ago": [ @@ -148,6 +150,7 @@ "včera" ], "1 month ago": [ + "minulý měs", "minulý měsíc" ], "1 week ago": [ @@ -161,6 +164,7 @@ "zítra" ], "in 1 month": [ + "příští měs", "příští měsíc" ], "in 1 week": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/cy.json b/dateparser_data/cldr_language_data/date_translation_data/cy.json index 26a012079..815b42d59 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/cy.json +++ b/dateparser_data/cldr_language_data/date_translation_data/cy.json @@ -78,9 +78,11 @@ "sul" ], "am": [ + "am", "yb" ], "pm": [ + "pm", "yh" ], "year": [ @@ -94,10 +96,11 @@ "wythnos" ], "day": [ - "dydd" + "diwrnod" ], "hour": [ - "awr" + "awr", + "oriau" ], "minute": [ "mun", @@ -123,6 +126,7 @@ "nawr" ], "0 week ago": [ + "yr ws hon", "yr wythnos hon" ], "0 year ago": [ @@ -135,6 +139,7 @@ "mis diwethaf" ], "1 week ago": [ + "ws ddiwethaf", "wythnos ddiwethaf" ], "1 year ago": [ @@ -147,9 +152,11 @@ "mis nesaf" ], "in 1 week": [ + "ws nesaf", "wythnos nesaf" ], "in 1 year": [ + "bl nesaf", "blwyddyn nesaf" ] }, @@ -168,12 +175,15 @@ "{0} mis yn ôl" ], "\\1 second ago": [ + "{0} eil yn ôl", "{0} eiliad yn ôl" ], "\\1 week ago": [ + "{0} ws yn ôl", "{0} wythnos yn ôl" ], "\\1 year ago": [ + "{0} bl yn ôl", "{0} o flynyddoedd yn ôl" ], "in \\1 day": [ @@ -190,9 +200,11 @@ "ymhen {0} mis" ], "in \\1 second": [ + "ymhen {0} eil", "ymhen {0} eiliad" ], "in \\1 week": [ + "ymhen {0} ws", "ymhen {0} wythnos" ], "in \\1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/da.json b/dateparser_data/cldr_language_data/date_translation_data/da.json index 73ac01944..fd3a95b10 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/da.json +++ b/dateparser_data/cldr_language_data/date_translation_data/da.json @@ -53,7 +53,7 @@ "mandag" ], "tuesday": [ - "tir", + "tirs", "tirsdag" ], "wednesday": [ @@ -61,7 +61,7 @@ "onsdag" ], "thursday": [ - "tor", + "tors", "torsdag" ], "friday": [ @@ -97,7 +97,8 @@ ], "hour": [ "t", - "time" + "time", + "timer" ], "minute": [ "min", @@ -113,10 +114,10 @@ "i dag" ], "0 hour ago": [ - "i den kommende time" + "denne time" ], "0 minute ago": [ - "i det kommende minut" + "dette minut" ], "0 month ago": [ "denne md", @@ -161,34 +162,41 @@ "relative-type-regex": { "\\1 day ago": [ "for {0} dag siden", - "for {0} dage siden" + "for {0} dage siden", + "{0} dag siden", + "{0} dage siden" ], "\\1 hour ago": [ "for {0} time siden", - "for {0} timer siden" + "for {0} timer siden", + "{0} time siden", + "{0} timer siden" ], "\\1 minute ago": [ - "for {0} min siden", "for {0} minut siden", - "for {0} minutter siden" + "for {0} minutter siden", + "{0} min siden" ], "\\1 month ago": [ - "for {0} md siden", - "for {0} mdr siden", "for {0} måned siden", - "for {0} måneder siden" + "for {0} måneder siden", + "{0} md siden", + "{0} mdr siden" ], "\\1 second ago": [ - "for {0} sek siden", "for {0} sekund siden", - "for {0} sekunder siden" + "for {0} sekunder siden", + "{0} sek siden" ], "\\1 week ago": [ "for {0} uge siden", - "for {0} uger siden" + "for {0} uger siden", + "{0} uge siden", + "{0} uger siden" ], "\\1 year ago": [ - "for {0} år siden" + "for {0} år siden", + "{0} år siden" ], "in \\1 day": [ "om {0} dag", diff --git a/dateparser_data/cldr_language_data/date_translation_data/dav.json b/dateparser_data/cldr_language_data/date_translation_data/dav.json index 2b157008c..519408bdc 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dav.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dav.json @@ -96,6 +96,7 @@ "ituku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/de.json b/dateparser_data/cldr_language_data/date_translation_data/de.json index 8eb30291b..761171dbd 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/de.json +++ b/dateparser_data/cldr_language_data/date_translation_data/de.json @@ -34,6 +34,7 @@ ], "september": [ "sep", + "sept", "september" ], "october": [ @@ -77,10 +78,10 @@ "sonntag" ], "am": [ - "vorm" + "am" ], "pm": [ - "nachm" + "pm" ], "year": [ "j", @@ -99,7 +100,8 @@ ], "hour": [ "std", - "stunde" + "stunde", + "stunden" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/dje.json b/dateparser_data/cldr_language_data/date_translation_data/dje.json index bbfbcc970..05fe9d802 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dje.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dje.json @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser_data/cldr_language_data/date_translation_data/dsb.json b/dateparser_data/cldr_language_data/date_translation_data/dsb.json index af9617796..0e219da76 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dsb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dsb.json @@ -89,9 +89,11 @@ "njeźela" ], "am": [ + "dop", "dopołdnja" ], "pm": [ + "wótp", "wótpołdnja" ], "year": [ @@ -113,7 +115,8 @@ "hour": [ "g", "góź", - "góźina" + "góźina", + "góźiny" ], "minute": [ "m", @@ -127,48 +130,70 @@ ], "relative-type": { "0 day ago": [ - "źinsa" + "źins", + "źinsa", + "źis" ], "0 hour ago": [ - "this hour" + "w toś tej góźinje" ], "0 minute ago": [ - "this minute" + "w toś tej minuśe" ], "0 month ago": [ - "ten mjasec" + "te mjasec", + "ten mjasec", + "tot mjasec" ], "0 second ago": [ - "now" + "něnto" ], "0 week ago": [ - "ten tyźeń" + "te tyźeń", + "ten tyźeń", + "tot tyźeń" ], "0 year ago": [ - "lětosa" + "lět", + "lětosa", + "lěts" ], "1 day ago": [ - "cora" + "cora", + "cr", + "cra" ], "1 month ago": [ - "slědny mjasec" + "zajź mjasec", + "zajźony mjasec" ], "1 week ago": [ - "slědny tyźeń" + "zajź tyźeń", + "zajźony tyźeń" ], "1 year ago": [ + "ło", + "łon", "łoni" ], "in 1 day": [ + "wit", + "witś", "witśe" ], "in 1 month": [ + "pśid mjasec", + "pśiduc mjasec", "pśiducy mjasec" ], "in 1 week": [ + "pśid tyźeń", + "pśiduc tyźeń", "pśiducy tyźeń" ], "in 1 year": [ + "zno", + "znow", "znowa" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/dua.json b/dateparser_data/cldr_language_data/date_translation_data/dua.json index 7dab932cf..1945d3117 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dua.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dua.json @@ -96,6 +96,7 @@ "búnyá" ], "hour": [ + "hr", "ŋgandɛ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/dyo.json b/dateparser_data/cldr_language_data/date_translation_data/dyo.json index 39d23972e..974da2b3f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dyo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dyo.json @@ -95,7 +95,8 @@ "funak" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/dz.json b/dateparser_data/cldr_language_data/date_translation_data/dz.json index c5379b378..0ac4382b1 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/dz.json +++ b/dateparser_data/cldr_language_data/date_translation_data/dz.json @@ -108,6 +108,7 @@ "ཚེས་" ], "hour": [ + "hr", "ཆུ་ཚོད" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ebu.json b/dateparser_data/cldr_language_data/date_translation_data/ebu.json index fe8af614d..162b39c34 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ebu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ebu.json @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "ithaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ee.json b/dateparser_data/cldr_language_data/date_translation_data/ee.json index e688958ae..657174584 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ee.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ee.json @@ -96,7 +96,8 @@ "ŋkeke" ], "hour": [ - "gaƒoƒo" + "gaƒoƒo", + "gaƒoƒowo" ], "minute": [ "aɖabaƒoƒo" diff --git a/dateparser_data/cldr_language_data/date_translation_data/el.json b/dateparser_data/cldr_language_data/date_translation_data/el.json index a9bb09f60..93f4c4a0f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/el.json +++ b/dateparser_data/cldr_language_data/date_translation_data/el.json @@ -114,12 +114,13 @@ "εβδομάδα" ], "day": [ + "ημ", "ημέρα" ], "hour": [ "ώ", - "ώρ", - "ώρα" + "ώρα", + "ώρες" ], "minute": [ "λ", @@ -136,19 +137,22 @@ "σήμερα" ], "0 hour ago": [ - "αυτήν την ώρα" + "τρέχουσα ώρα" ], "0 minute ago": [ - "αυτό το λεπτό" + "τρέχον λεπτό" ], "0 month ago": [ + "τρέχ μήνας", "τρέχων μήνας" ], "0 second ago": [ "τώρα" ], "0 week ago": [ - "αυτήν την εβδομάδα" + "τρέχ εβδ", + "τρέχ εβδομάδα", + "τρέχουσα εβδομάδα" ], "0 year ago": [ "φέτος" @@ -157,9 +161,12 @@ "χθες" ], "1 month ago": [ + "προηγ μήνας", "προηγούμενος μήνας" ], "1 week ago": [ + "προηγ εβδ", + "προηγ εβδομάδα", "προηγούμενη εβδομάδα" ], "1 year ago": [ @@ -169,9 +176,12 @@ "αύριο" ], "in 1 month": [ + "επόμ μήνας", "επόμενος μήνας" ], "in 1 week": [ + "επόμ εβδ", + "επόμ εβδομάδα", "επόμενη εβδομάδα" ], "in 1 year": [ @@ -181,12 +191,13 @@ "relative-type-regex": { "\\1 day ago": [ "{0} ημ πριν", + "πριν από {0} ημ", "πριν από {0} ημέρα", "πριν από {0} ημέρες" ], "\\1 hour ago": [ "{0} ώ πριν", - "πριν από {0} ώρ", + "πριν από {0} ώ", "πριν από {0} ώρα", "πριν από {0} ώρες" ], @@ -226,7 +237,6 @@ ], "in \\1 hour": [ "σε {0} ώ", - "σε {0} ώρ", "σε {0} ώρα", "σε {0} ώρες" ], diff --git a/dateparser_data/cldr_language_data/date_translation_data/en.json b/dateparser_data/cldr_language_data/date_translation_data/en.json index 685df4b1f..86f92c72d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/en.json +++ b/dateparser_data/cldr_language_data/date_translation_data/en.json @@ -99,6 +99,7 @@ ], "hour": [ "hour", + "hours", "hr" ], "minute": [ @@ -168,132 +169,213 @@ "relative-type-regex": { "\\1 day ago": [ "{0} day ago", - "{0} days ago" + "{0} days ago", + "{0}d ago" ], "\\1 hour ago": [ "{0} hour ago", "{0} hours ago", - "{0} hr ago" + "{0} hr ago", + "{0}h ago" ], "\\1 minute ago": [ "{0} min ago", "{0} minute ago", - "{0} minutes ago" + "{0} minutes ago", + "{0}m ago" ], "\\1 month ago": [ "{0} mo ago", "{0} month ago", - "{0} months ago" + "{0} months ago", + "{0}mo ago" ], "\\1 second ago": [ "{0} sec ago", "{0} second ago", - "{0} seconds ago" + "{0} seconds ago", + "{0}s ago" ], "\\1 week ago": [ "{0} week ago", "{0} weeks ago", - "{0} wk ago" + "{0} wk ago", + "{0}w ago" ], "\\1 year ago": [ "{0} year ago", "{0} years ago", - "{0} yr ago" + "{0} yr ago", + "{0}y ago" ], "in \\1 day": [ "in {0} day", - "in {0} days" + "in {0} days", + "in {0}d" ], "in \\1 hour": [ "in {0} hour", "in {0} hours", - "in {0} hr" + "in {0} hr", + "in {0}h" ], "in \\1 minute": [ "in {0} min", "in {0} minute", - "in {0} minutes" + "in {0} minutes", + "in {0}m" ], "in \\1 month": [ "in {0} mo", "in {0} month", - "in {0} months" + "in {0} months", + "in {0}mo" ], "in \\1 second": [ "in {0} sec", "in {0} second", - "in {0} seconds" + "in {0} seconds", + "in {0}s" ], "in \\1 week": [ "in {0} week", "in {0} weeks", - "in {0} weeks time", - "in {0} weeks' time", - "in {0} wk" + "in {0} wk", + "in {0}w" ], "in \\1 year": [ "in {0} year", "in {0} years", - "in {0} yr" + "in {0} yr", + "in {0}y" ] }, "locale_specific": { "en-001": { "name": "en-001", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-150": { "name": "en-150", + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-AE": { + "name": "en-AE", "date_order": "DMY" }, "en-AG": { "name": "en-AG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AI": { "name": "en-AI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AS": { "name": "en-AS" }, "en-AT": { "name": "en-AT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-AU": { "name": "en-AU", "date_order": "DMY", - "hour": [ - "h" - ] + "september": [ + "sept" + ], + "relative-type-regex": { + "\\1 hour ago": [ + "{0} hrs ago" + ], + "\\1 minute ago": [ + "{0} mins ago" + ], + "\\1 second ago": [ + "{0} secs ago" + ], + "\\1 week ago": [ + "{0} wks ago" + ], + "\\1 year ago": [ + "{0} yrs ago" + ], + "in \\1 hour": [ + "in {0} hrs" + ], + "in \\1 minute": [ + "in {0} mins" + ], + "in \\1 second": [ + "in {0} secs" + ], + "in \\1 week": [ + "in {0} wks" + ], + "in \\1 year": [ + "in {0} yrs" + ] + } }, "en-BB": { "name": "en-BB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BE": { "name": "en-BE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BI": { "name": "en-BI" }, "en-BM": { "name": "en-BM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BS": { "name": "en-BS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BW": { "name": "en-BW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-BZ": { "name": "en-BZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CA": { "name": "en-CA", @@ -339,263 +421,459 @@ }, "en-CC": { "name": "en-CC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CH": { "name": "en-CH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CK": { "name": "en-CK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CM": { "name": "en-CM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CX": { "name": "en-CX", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-CY": { "name": "en-CY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DE": { "name": "en-DE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DG": { "name": "en-DG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DK": { "name": "en-DK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-DM": { "name": "en-DM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ER": { "name": "en-ER", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FI": { "name": "en-FI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FJ": { "name": "en-FJ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FK": { "name": "en-FK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-FM": { "name": "en-FM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GB": { "name": "en-GB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GD": { "name": "en-GD", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GG": { "name": "en-GG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GH": { "name": "en-GH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GI": { "name": "en-GI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GM": { "name": "en-GM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-GU": { "name": "en-GU" }, "en-GY": { "name": "en-GY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-HK": { "name": "en-HK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-ID": { + "name": "en-ID", + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IE": { "name": "en-IE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IL": { "name": "en-IL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IM": { "name": "en-IM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IN": { "name": "en-IN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-IO": { "name": "en-IO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-JE": { "name": "en-JE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-JM": { "name": "en-JM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KE": { "name": "en-KE", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KI": { "name": "en-KI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KN": { "name": "en-KN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-KY": { "name": "en-KY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LC": { "name": "en-LC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LR": { "name": "en-LR", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-LS": { "name": "en-LS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MG": { "name": "en-MG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MH": { "name": "en-MH" }, "en-MO": { "name": "en-MO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MP": { "name": "en-MP" }, "en-MS": { "name": "en-MS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MT": { "name": "en-MT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MU": { "name": "en-MU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] + }, + "en-MV": { + "name": "en-MV", + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MW": { "name": "en-MW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-MY": { "name": "en-MY", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NA": { "name": "en-NA", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NF": { "name": "en-NF", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NG": { "name": "en-NG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NL": { "name": "en-NL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NR": { "name": "en-NR", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NU": { "name": "en-NU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-NZ": { "name": "en-NZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PG": { "name": "en-PG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PH": { - "name": "en-PH", - "date_order": "DMY" + "name": "en-PH" }, "en-PK": { "name": "en-PK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PN": { "name": "en-PN", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-PR": { "name": "en-PR" }, "en-PW": { "name": "en-PW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-RW": { "name": "en-RW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SB": { "name": "en-SB", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SC": { "name": "en-SC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SD": { "name": "en-SD", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SE": { "name": "en-SE", - "date_order": "YMD" + "date_order": "YMD", + "september": [ + "sept" + ] }, "en-SG": { "name": "en-SG", "date_order": "DMY", + "september": [ + "sept" + ], "month": [ "mth" ], @@ -621,92 +899,149 @@ }, "en-SH": { "name": "en-SH", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SI": { "name": "en-SI", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SL": { "name": "en-SL", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SS": { "name": "en-SS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SX": { "name": "en-SX", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-SZ": { "name": "en-SZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TC": { "name": "en-TC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TK": { "name": "en-TK", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TO": { "name": "en-TO", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TT": { "name": "en-TT", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TV": { "name": "en-TV", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-TZ": { "name": "en-TZ", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-UG": { "name": "en-UG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-UM": { "name": "en-UM" }, - "en-US": { - "name": "en-US" - }, "en-VC": { "name": "en-VC", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-VG": { "name": "en-VG", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-VI": { "name": "en-VI" }, "en-VU": { "name": "en-VU", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-WS": { "name": "en-WS", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ZA": { "name": "en-ZA", - "date_order": "YMD" + "date_order": "YMD", + "september": [ + "sept" + ] }, "en-ZM": { "name": "en-ZM", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] }, "en-ZW": { "name": "en-ZW", - "date_order": "DMY" + "date_order": "DMY", + "september": [ + "sept" + ] } } -} +} \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/eo.json b/dateparser_data/cldr_language_data/date_translation_data/eo.json index 635541d39..76511e9fc 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/eo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/eo.json @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/es.json b/dateparser_data/cldr_language_data/date_translation_data/es.json index f72bde156..07e936e1e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/es.json +++ b/dateparser_data/cldr_language_data/date_translation_data/es.json @@ -101,7 +101,8 @@ ], "hour": [ "h", - "hora" + "hora", + "horas" ], "minute": [ "min", @@ -128,6 +129,7 @@ "ahora" ], "0 week ago": [ + "esta sem", "esta semana" ], "0 year ago": [ @@ -140,7 +142,8 @@ "el mes pasado" ], "1 week ago": [ - "la semana pasada" + "la semana pasada", + "sem ant" ], "1 year ago": [ "el año pasado" @@ -152,7 +155,8 @@ "el próximo mes" ], "in 1 week": [ - "la próxima semana" + "la próxima semana", + "próx sem" ], "in 1 year": [ "el próximo año" @@ -160,6 +164,7 @@ }, "relative-type-regex": { "\\1 day ago": [ + "hace {0} d", "hace {0} día", "hace {0} días" ], @@ -194,6 +199,7 @@ "hace {0} años" ], "in \\1 day": [ + "dentro de {0} d", "dentro de {0} día", "dentro de {0} días" ], @@ -231,18 +237,25 @@ "locale_specific": { "es-419": { "name": "es-419", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-AR": { "name": "es-AR", - "september": [ - "sep" + "hour": [ + "hs" ], "second": [ "seg" ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "relative-type-regex": { "\\1 second ago": [ "hace {0} seg" @@ -254,75 +267,97 @@ }, "es-BO": { "name": "es-BO", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-BR": { "name": "es-BR", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-BZ": { "name": "es-BZ", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-CL": { "name": "es-CL", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-CO": { "name": "es-CO", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-CR": { "name": "es-CR", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-CU": { "name": "es-CU", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-DO": { "name": "es-DO", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-EA": { "name": "es-EA" }, "es-EC": { "name": "es-EC", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-GQ": { "name": "es-GQ" }, "es-GT": { "name": "es-GT", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-HN": { "name": "es-HN", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-IC": { "name": "es-IC" @@ -333,6 +368,9 @@ "sep" ], "relative-type": { + "1 week ago": [ + "sem pas" + ], "in 1 month": [ "el mes próximo" ], @@ -352,9 +390,6 @@ "en {0} h", "en {0} n" ], - "in \\1 minute": [ - "en {0} min" - ], "in \\1 month": [ "en {0} m", "en {0} mes", @@ -373,23 +408,32 @@ }, "es-NI": { "name": "es-NI", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-PA": { "name": "es-PA", "date_order": "MDY", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-PE": { "name": "es-PE", "september": [ "set", "setiembre" - ] + ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-PH": { "name": "es-PH" @@ -397,15 +441,22 @@ "es-PR": { "name": "es-PR", "date_order": "MDY", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-PY": { "name": "es-PY", "second": [ "seg" ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + }, "relative-type-regex": { "\\1 second ago": [ "hace {0} seg" @@ -417,25 +468,42 @@ }, "es-SV": { "name": "es-SV", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-US": { "name": "es-US", - "september": [ - "sep" - ] + "relative-type": { + "1 week ago": [ + "sem pasada" + ], + "in 1 week": [ + "próxima sem" + ] + } }, "es-UY": { "name": "es-UY", "september": [ "set", "setiembre" - ] + ], + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } }, "es-VE": { - "name": "es-VE" + "name": "es-VE", + "relative-type": { + "1 week ago": [ + "sem pas" + ] + } } } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/et.json b/dateparser_data/cldr_language_data/date_translation_data/et.json index 43e33427f..5c9bea17e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/et.json +++ b/dateparser_data/cldr_language_data/date_translation_data/et.json @@ -97,7 +97,8 @@ ], "hour": [ "t", - "tund" + "tund", + "tunnid" ], "minute": [ "min", @@ -119,39 +120,57 @@ "praegusel minutil" ], "0 month ago": [ - "käesolev kuu" + "käesolev kuu", + "see k", + "see kuu" ], "0 second ago": [ "nüüd" ], "0 week ago": [ - "käesolev nädal" + "käesolev nädal", + "see n", + "see näd" ], "0 year ago": [ - "käesolev aasta" + "käesolev a", + "käesolev aasta", + "see a" ], "1 day ago": [ "eile" ], "1 month ago": [ + "eelm k", + "eelm kuu", "eelmine kuu" ], "1 week ago": [ + "eelm n", + "eelm näd", "eelmine nädal" ], "1 year ago": [ + "eelm a", + "eelmine a", "eelmine aasta" ], "in 1 day": [ "homme" ], "in 1 month": [ + "järgm k", + "järgm kuu", "järgmine kuu" ], "in 1 week": [ + "järgm n", + "järgm näd", "järgmine nädal" ], "in 1 year": [ + "järgm a", + "järgmine a", "järgmine aasta" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/eu.json b/dateparser_data/cldr_language_data/date_translation_data/eu.json index 762c7d105..94cbb4632 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/eu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/eu.json @@ -100,7 +100,8 @@ ], "hour": [ "h", - "ordua" + "ordua", + "orduak" ], "minute": [ "min", @@ -121,13 +122,13 @@ "minutu honetan" ], "0 month ago": [ - "hilabete hau" + "hilabete honetan" ], "0 second ago": [ "orain" ], "0 week ago": [ - "aste hau" + "aste honetan" ], "0 year ago": [ "aurten" @@ -136,25 +137,27 @@ "atzo" ], "1 month ago": [ - "aurreko hilabetea" + "aurreko hilabetean" ], "1 week ago": [ - "aurreko astea" + "aurreko astean" ], "1 year ago": [ - "aurreko urtea" + "aurreko urtea", + "iaz" ], "in 1 day": [ "bihar" ], "in 1 month": [ - "hurrengo hilabetea" + "hurrengo hilabetean" ], "in 1 week": [ - "hurrengo astea" + "hurrengo astean" ], "in 1 year": [ - "hurrengo urtea" + "hurrengo urtea", + "hurrengo urtean" ] }, "relative-type-regex": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/ewo.json b/dateparser_data/cldr_language_data/date_translation_data/ewo.json index 9b8b5411f..48a79201a 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ewo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ewo.json @@ -96,7 +96,8 @@ "amǒs" ], "hour": [ - "awola" + "awola", + "hr" ], "minute": [ "enútɛn" diff --git a/dateparser_data/cldr_language_data/date_translation_data/fa.json b/dateparser_data/cldr_language_data/date_translation_data/fa.json index 5fdd6216a..046c50fb9 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fa.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fa.json @@ -117,7 +117,6 @@ "دیروز" ], "1 month ago": [ - "ماه پیش", "ماه گذشته" ], "1 week ago": [ @@ -162,7 +161,8 @@ "{0} سال پیش" ], "in \\1 day": [ - "{0} روز بعد" + "{0} روز بعد", + "{0} روز دیگر" ], "in \\1 hour": [ "{0} ساعت بعد" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ff.json b/dateparser_data/cldr_language_data/date_translation_data/ff.json index cf0517d49..0f76d2ab4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ff.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ff.json @@ -96,6 +96,7 @@ "ñalnde" ], "hour": [ + "hr", "waktu" ], "minute": [ @@ -151,15 +152,5 @@ "next year" ] }, - "locale_specific": { - "ff-CM": { - "name": "ff-CM" - }, - "ff-GN": { - "name": "ff-GN" - }, - "ff-MR": { - "name": "ff-MR" - } - } + "locale_specific": {} } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/fi.json b/dateparser_data/cldr_language_data/date_translation_data/fi.json index 36772ec69..e8a69a0e7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fi.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fi.json @@ -132,6 +132,7 @@ ], "hour": [ "t", + "tunnit", "tunti" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/fil.json b/dateparser_data/cldr_language_data/date_translation_data/fil.json index d83cbba83..61b2c0a05 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fil.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fil.json @@ -96,6 +96,7 @@ "araw" ], "hour": [ + "mga oras", "oras" ], "minute": [ @@ -160,8 +161,7 @@ "{0} araw ang nakalipas" ], "\\1 hour ago": [ - "{0} oras ang nakalipas", - "{0} oras nakalipas" + "{0} oras ang nakalipas" ], "\\1 minute ago": [ "{0} min ang nakalipas", @@ -172,7 +172,6 @@ ], "\\1 second ago": [ "{0} seg ang nakalipas", - "{0} seg nakalipas", "{0} segundo ang nakalipas" ], "\\1 week ago": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/fo.json b/dateparser_data/cldr_language_data/date_translation_data/fo.json index b49f86b3e..3a4c9855b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fo.json @@ -101,6 +101,7 @@ ], "hour": [ "t", + "tímar", "tími" ], "minute": [ @@ -124,12 +125,15 @@ "hendan minuttin" ], "0 month ago": [ + "henda mnð", "henda mánaðin" ], "0 second ago": [ "nú" ], "0 week ago": [ + "hesu v", + "hesu vi", "hesu viku" ], "0 year ago": [ @@ -139,9 +143,12 @@ "í gjár" ], "1 month ago": [ + "seinasta mnð", "seinasta mánað" ], "1 week ago": [ + "seinastu v", + "seinastu vi", "seinastu viku" ], "1 year ago": [ @@ -151,9 +158,12 @@ "í morgin" ], "in 1 month": [ + "næsta mnð", "næsta mánað" ], "in 1 week": [ + "næstu v", + "næstu vi", "næstu viku" ], "in 1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/fr.json b/dateparser_data/cldr_language_data/date_translation_data/fr.json index 8de40f824..0e2476142 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fr.json @@ -98,7 +98,8 @@ ], "hour": [ "h", - "heure" + "heure", + "heures" ], "minute": [ "min", @@ -164,14 +165,12 @@ "\\1 hour ago": [ "il y a {0} h", "il y a {0} heure", - "il y a {0} heures", - "il y a {0}h" + "il y a {0} heures" ], "\\1 minute ago": [ "il y a {0} min", "il y a {0} minute", - "il y a {0} minutes", - "il y a {0}min" + "il y a {0} minutes" ], "\\1 month ago": [ "il y a {0} m", @@ -200,8 +199,7 @@ "in \\1 hour": [ "dans {0} h", "dans {0} heure", - "dans {0} heures", - "dans {0}h" + "dans {0} heures" ], "in \\1 minute": [ "dans {0} min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/fur.json b/dateparser_data/cldr_language_data/date_translation_data/fur.json index a65e0736a..c847e71bd 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/fur.json +++ b/dateparser_data/cldr_language_data/date_translation_data/fur.json @@ -94,7 +94,8 @@ "dì" ], "hour": [ - "ore" + "ore", + "oris" ], "minute": [ "minût" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ga.json b/dateparser_data/cldr_language_data/date_translation_data/ga.json index bea9d952c..249c31c6f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ga.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ga.json @@ -76,10 +76,10 @@ "dé domhnaigh" ], "am": [ - "am" + "rn" ], "pm": [ - "pm" + "in" ], "year": [ "bl", @@ -130,8 +130,8 @@ "an tseachtain seo" ], "0 year ago": [ - "an bhl seo", - "an bhliain seo" + "i mbl", + "i mbliana" ], "1 day ago": [ "inné" @@ -204,7 +204,8 @@ ], "in \\1 month": [ "i gceann {0} mhí", - "i gceann {0} mí" + "i gceann {0} mí", + "i gceann {0} míosa" ], "in \\1 second": [ "i gceann {0} soic", @@ -212,13 +213,18 @@ ], "in \\1 week": [ "i gceann {0} scht", - "i gceann {0} seachtain" + "i gceann {0} seachtain", + "i gceann {0} seachtaine" ], "in \\1 year": [ - "i gceann {0} bhliain", "i gceann {0} bl", - "i gceann {0} bliain" + "i gceann {0} bliain", + "i gceann {0} bliana" ] }, - "locale_specific": {} + "locale_specific": { + "ga-GB": { + "name": "ga-GB" + } + } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/gd.json b/dateparser_data/cldr_language_data/date_translation_data/gd.json index e26903cfd..8f52d418d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/gd.json +++ b/dateparser_data/cldr_language_data/date_translation_data/gd.json @@ -132,10 +132,14 @@ "an-diugh" ], "0 hour ago": [ - "this hour" + "am broinn uair", + "am broinn uair a thìde", + "san uair" ], "0 minute ago": [ - "this minute" + "am broinn mion", + "am broinn mionaid", + "sa mhion" ], "0 month ago": [ "am mì seo", diff --git a/dateparser_data/cldr_language_data/date_translation_data/gl.json b/dateparser_data/cldr_language_data/date_translation_data/gl.json index d38482e0f..8a3b46b5e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/gl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/gl.json @@ -81,11 +81,9 @@ "pm" ], "year": [ - "a", "ano" ], "month": [ - "m", "mes" ], "week": [ @@ -93,12 +91,12 @@ "semana" ], "day": [ - "d", "día" ], "hour": [ "h", - "hora" + "hora", + "horas" ], "minute": [ "min", @@ -113,13 +111,12 @@ "hoxe" ], "0 hour ago": [ - "nesta hora" + "esta hora" ], "0 minute ago": [ - "neste minuto" + "este minuto" ], "0 month ago": [ - "este m", "este mes" ], "0 second ago": [ @@ -136,36 +133,37 @@ "onte" ], "1 month ago": [ - "m pasado", + "o mes pas", "o mes pasado" ], "1 week ago": [ - "a semana pasada", - "sem pasada" + "a sem pas", + "a sem pasada", + "a semana pasada" ], "1 year ago": [ - "ano pasado", + "o ano pas", "o ano pasado" ], "in 1 day": [ "mañá" ], "in 1 month": [ - "m seguinte", + "o próx mes", "o próximo mes" ], "in 1 week": [ - "a próxima semana", - "sem seguinte" + "a próx sem", + "a próxima sem", + "a próxima semana" ], "in 1 year": [ - "o próximo ano", - "seguinte ano" + "o próx ano", + "o próximo ano" ] }, "relative-type-regex": { "\\1 day ago": [ - "hai {0} d", "hai {0} día", "hai {0} días" ], @@ -180,7 +178,6 @@ "hai {0} minutos" ], "\\1 month ago": [ - "hai {0} m", "hai {0} mes", "hai {0} meses" ], @@ -195,12 +192,10 @@ "hai {0} semanas" ], "\\1 year ago": [ - "hai {0} a", "hai {0} ano", "hai {0} anos" ], "in \\1 day": [ - "en {0} d", "en {0} día", "en {0} días" ], @@ -215,7 +210,6 @@ "en {0} minutos" ], "in \\1 month": [ - "en {0} m", "en {0} mes", "en {0} meses" ], @@ -230,7 +224,6 @@ "en {0} semanas" ], "in \\1 year": [ - "en {0} a", "en {0} ano", "en {0} anos" ] diff --git a/dateparser_data/cldr_language_data/date_translation_data/gsw.json b/dateparser_data/cldr_language_data/date_translation_data/gsw.json index 7d57904c5..d2ed95874 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/gsw.json +++ b/dateparser_data/cldr_language_data/date_translation_data/gsw.json @@ -99,6 +99,7 @@ "tag" ], "hour": [ + "hr", "schtund" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/gu.json b/dateparser_data/cldr_language_data/date_translation_data/gu.json index c08747a36..04c9d6284 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/gu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/gu.json @@ -172,7 +172,6 @@ "{0} અઠવાડિયા પહેલાં" ], "\\1 year ago": [ - "{0} વર્ષ પહેલા", "{0} વર્ષ પહેલાં" ], "in \\1 day": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/guz.json b/dateparser_data/cldr_language_data/date_translation_data/guz.json index 576390b5d..2ec82c64b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/guz.json +++ b/dateparser_data/cldr_language_data/date_translation_data/guz.json @@ -97,7 +97,8 @@ "rituko" ], "hour": [ - "ensa" + "ensa", + "hr" ], "minute": [ "edakika" diff --git a/dateparser_data/cldr_language_data/date_translation_data/gv.json b/dateparser_data/cldr_language_data/date_translation_data/gv.json index d2764794f..644619445 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/gv.json +++ b/dateparser_data/cldr_language_data/date_translation_data/gv.json @@ -93,7 +93,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ha.json b/dateparser_data/cldr_language_data/date_translation_data/ha.json index 19a5140fe..2f30883f6 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ha.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ha.json @@ -78,10 +78,12 @@ "lahadi" ], "am": [ - "am" + "safiya", + "sf" ], "pm": [ - "pm" + "yamma", + "ym" ], "year": [ "shekara" @@ -96,7 +98,8 @@ "kwana" ], "hour": [ - "awa" + "awa", + "sa'o'i" ], "minute": [ "minti" @@ -109,46 +112,98 @@ "yau" ], "0 hour ago": [ - "this hour" + "wannan awa" ], "0 minute ago": [ - "this minute" + "wannan mintin" ], "0 month ago": [ - "this month" + "wannan watan" ], "0 second ago": [ - "now" + "yanzu" ], "0 week ago": [ - "this week" + "wannan satin" ], "0 year ago": [ - "this year" + "bana" ], "1 day ago": [ "jiya" ], "1 month ago": [ - "last month" + "watan da ya gabata" ], "1 week ago": [ - "last week" + "satin da ya gabata" ], "1 year ago": [ - "last year" + "bara" ], "in 1 day": [ "gobe" ], "in 1 month": [ - "next month" + "wata na gaba" ], "in 1 week": [ - "next week" + "sati na gaba" ], "in 1 year": [ - "next year" + "badi" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "kwanaki da suka gabata {0}", + "rana da ya gabata {0}" + ], + "\\1 hour ago": [ + "{0} awa da ya gabata" + ], + "\\1 minute ago": [ + "{0} minti da ya gabata" + ], + "\\1 month ago": [ + "watan da ya gabata {0}", + "watanni da suka gabata {0}}" + ], + "\\1 second ago": [ + "{0} dakika da ya gabata" + ], + "\\1 week ago": [ + "mako da suka gabata {0}", + "mako da ya gabata {0}", + "makonni da suka gabata {0}" + ], + "\\1 year ago": [ + "shekara da suka gabata {0}" + ], + "in \\1 day": [ + "a cikin kwanaki {0}", + "a cikin rana {0}" + ], + "in \\1 hour": [ + "cikin {0} awa" + ], + "in \\1 minute": [ + "cikin {0} minti" + ], + "in \\1 month": [ + "a cikin watan {0}", + "a cikin watanni {0}" + ], + "in \\1 second": [ + "cikin {0} dakika" + ], + "in \\1 week": [ + "a cikin mako {0}", + "a cikin makonni {0}" + ], + "in \\1 year": [ + "a shekarar {0}", + "a shekaru {0}" ] }, "locale_specific": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/haw.json b/dateparser_data/cldr_language_data/date_translation_data/haw.json index b53dfe76d..6726e9506 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/haw.json +++ b/dateparser_data/cldr_language_data/date_translation_data/haw.json @@ -95,7 +95,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/he.json b/dateparser_data/cldr_language_data/date_translation_data/he.json index 12b9a92d4..0686375f7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/he.json +++ b/dateparser_data/cldr_language_data/date_translation_data/he.json @@ -74,9 +74,11 @@ "יום ראשון" ], "am": [ + "am", "לפנה״צ" ], "pm": [ + "pm", "אחה״צ" ], "year": [ @@ -96,6 +98,7 @@ ], "hour": [ "שעה", + "שעות", "שע׳" ], "minute": [ @@ -114,7 +117,8 @@ "בשעה זו" ], "0 minute ago": [ - "בדקה זו" + "בדקה זו", + "דקה זו" ], "0 month ago": [ "החודש" @@ -156,7 +160,6 @@ "relative-type-regex": { "\\1 day ago": [ "לפני {0} ימים", - "לפני {0} ימ׳", "לפני יום {0}" ], "\\1 hour ago": [ @@ -184,7 +187,6 @@ ], "in \\1 day": [ "בעוד {0} ימים", - "בעוד {0} ימ׳", "בעוד יום {0}" ], "in \\1 hour": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/hi.json b/dateparser_data/cldr_language_data/date_translation_data/hi.json index 09ef1c048..bbdaf0891 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/hi.json +++ b/dateparser_data/cldr_language_data/date_translation_data/hi.json @@ -74,10 +74,10 @@ "रविवार" ], "am": [ - "पूर्वाह्न" + "am" ], "pm": [ - "अपराह्न" + "pm" ], "year": [ "वर्ष" @@ -92,16 +92,17 @@ "दिन" ], "hour": [ - "घं", - "घंटा" + "घंटा", + "घंटे", + "घं॰" ], "minute": [ - "मि", - "मिनट" + "मिनट", + "मि॰" ], "second": [ - "से", - "सेकंड" + "सेकंड", + "से॰" ], "relative-type": { "0 day ago": [ @@ -123,10 +124,12 @@ "इस सप्ताह" ], "0 year ago": [ - "इस वर्ष" + "इस वर्ष", + "इस साल" ], "1 day ago": [ - "कल" + "कल", + "बीता कल" ], "1 month ago": [ "पिछला माह" @@ -135,9 +138,11 @@ "पिछला सप्ताह" ], "1 year ago": [ - "पिछला वर्ष" + "पिछला वर्ष", + "पिछले साल" ], "in 1 day": [ + "आने वाला कल", "कल" ], "in 1 month": [ @@ -147,7 +152,8 @@ "अगला सप्ताह" ], "in 1 year": [ - "अगला वर्ष" + "अगला वर्ष", + "अगले साल" ] }, "relative-type-regex": { @@ -155,19 +161,19 @@ "{0} दिन पहले" ], "\\1 hour ago": [ - "{0} घं पहले", - "{0} घंटे पहले" + "{0} घंटे पहले", + "{0} घं॰ पहले" ], "\\1 minute ago": [ - "{0} मि पहले", - "{0} मिनट पहले" + "{0} मिनट पहले", + "{0} मि॰ पहले" ], "\\1 month ago": [ "{0} माह पहले" ], "\\1 second ago": [ - "{0} से पहले", - "{0} सेकंड पहले" + "{0} सेकंड पहले", + "{0} से॰ पहले" ], "\\1 week ago": [ "{0} सप्ताह पहले" @@ -179,19 +185,19 @@ "{0} दिन में" ], "in \\1 hour": [ - "{0} घं में", - "{0} घंटे में" + "{0} घंटे में", + "{0} घं॰ में" ], "in \\1 minute": [ - "{0} मि में", - "{0} मिनट में" + "{0} मिनट में", + "{0} मि॰ में" ], "in \\1 month": [ "{0} माह में" ], "in \\1 second": [ - "{0} से में", - "{0} सेकंड में" + "{0} सेकंड में", + "{0} से॰ में" ], "in \\1 week": [ "{0} सप्ताह में" diff --git a/dateparser_data/cldr_language_data/date_translation_data/hr.json b/dateparser_data/cldr_language_data/date_translation_data/hr.json index 150bab092..03981c4c3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/hr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/hr.json @@ -114,7 +114,8 @@ ], "hour": [ "h", - "sat" + "sat", + "sati" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/hsb.json b/dateparser_data/cldr_language_data/date_translation_data/hsb.json index cc3f6ea3f..7fec618d4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/hsb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/hsb.json @@ -90,9 +90,11 @@ "njedźela" ], "am": [ + "dop", "dopołdnja" ], "pm": [ + "pop", "popołdnju" ], "year": [ @@ -114,7 +116,8 @@ "hour": [ "h", "hodź", - "hodźina" + "hodźina", + "hodźiny" ], "minute": [ "m", @@ -128,48 +131,72 @@ ], "relative-type": { "0 day ago": [ + "dźe", + "dźens", "dźensa" ], "0 hour ago": [ - "this hour" + "w tutej hodźinje" ], "0 minute ago": [ - "this minute" + "w tutej mjeńšinje" ], "0 month ago": [ + "tu měsac", + "tut měsac", "tutón měsac" ], "0 second ago": [ - "now" + "nětko" ], "0 week ago": [ + "tu tydźeń", + "tut tydźeń", "tutón tydźeń" ], "0 year ago": [ + "lět", + "lěts", "lětsa" ], "1 day ago": [ + "wč", + "wčer", "wčera" ], "1 month ago": [ + "zaš měsac", + "zašł měsac", "zašły měsac" ], "1 week ago": [ + "zaš tydźeń", + "zašł tydźeń", "zašły tydźeń" ], "1 year ago": [ + "lo", + "lon", "loni" ], "in 1 day": [ + "jut", + "jutř", "jutře" ], "in 1 month": [ + "přich měsac", + "přichodn měsac", "přichodny měsac" ], "in 1 week": [ + "přich tydźeń", + "přichodn tydźeń", "přichodny tydźeń" ], "in 1 year": [ + "klě", + "klět", "klětu" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/hu.json b/dateparser_data/cldr_language_data/date_translation_data/hu.json index 094d547aa..99460888f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/hu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/hu.json @@ -96,12 +96,15 @@ "nap" ], "hour": [ + "ó", "óra" ], "minute": [ + "p", "perc" ], "second": [ + "mp", "másodperc" ], "relative-type": { @@ -157,21 +160,27 @@ "{0} nappal ezelőtt" ], "\\1 hour ago": [ + "{0} órája", "{0} órával ezelőtt" ], "\\1 minute ago": [ - "{0} perccel ezelőtt" + "{0} perccel ezelőtt", + "{0} perce" ], "\\1 month ago": [ + "{0} hónapja", "{0} hónappal ezelőtt" ], "\\1 second ago": [ + "{0} mperce", "{0} másodperccel ezelőtt" ], "\\1 week ago": [ + "{0} hete", "{0} héttel ezelőtt" ], "\\1 year ago": [ + "{0} éve", "{0} évvel ezelőtt" ], "in \\1 day": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/hy.json b/dateparser_data/cldr_language_data/date_translation_data/hy.json index 0f47ad0c8..19c735ab0 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/hy.json +++ b/dateparser_data/cldr_language_data/date_translation_data/hy.json @@ -90,12 +90,10 @@ "կիրակի" ], "am": [ - "am", - "կա" + "am" ], "pm": [ - "pm", - "կհ" + "pm" ], "year": [ "տ", @@ -114,7 +112,8 @@ ], "hour": [ "ժ", - "ժամ" + "ժամ", + "ժամեր" ], "minute": [ "ր", @@ -138,7 +137,7 @@ "այս ամիս" ], "0 second ago": [ - "այժմ" + "հիմա" ], "0 week ago": [ "այս շաբաթ" @@ -150,7 +149,6 @@ "երեկ" ], "1 month ago": [ - "անցյալ ամիս", "նախորդ ամիս" ], "1 week ago": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/id.json b/dateparser_data/cldr_language_data/date_translation_data/id.json index 120620634..afef324fa 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/id.json +++ b/dateparser_data/cldr_language_data/date_translation_data/id.json @@ -29,7 +29,7 @@ "juli" ], "august": [ - "agt", + "agu", "agustus" ], "september": [ @@ -96,7 +96,8 @@ ], "day": [ "h", - "hari" + "hari", + "hr" ], "hour": [ "j", @@ -120,43 +121,53 @@ "jam ini" ], "0 minute ago": [ - "menit ini" + "menit ini", + "mnt ini" ], "0 month ago": [ + "bln ini", "bulan ini" ], "0 second ago": [ "sekarang" ], "0 week ago": [ + "mgg ini", "minggu ini" ], "0 year ago": [ - "tahun ini" + "tahun ini", + "thn ini" ], "1 day ago": [ "kemarin" ], "1 month ago": [ + "bln lalu", "bulan lalu" ], "1 week ago": [ + "mgg lalu", "minggu lalu" ], "1 year ago": [ - "tahun lalu" + "tahun lalu", + "thn lalu" ], "in 1 day": [ "besok" ], "in 1 month": [ - "bulan berikutnya" + "bln berikutnya", + "bulan depan" ], "in 1 week": [ + "mgg depan", "minggu depan" ], "in 1 year": [ - "tahun depan" + "tahun depan", + "thn depan" ] }, "relative-type-regex": { @@ -193,7 +204,8 @@ "dalam {0} hari" ], "in \\1 hour": [ - "dalam {0} jam" + "dalam {0} jam", + "dlm {0} jam" ], "in \\1 minute": [ "dalam {0} menit", diff --git a/dateparser_data/cldr_language_data/date_translation_data/ig.json b/dateparser_data/cldr_language_data/date_translation_data/ig.json index 540fe8588..e039bd560 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ig.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ig.json @@ -15,7 +15,7 @@ ], "april": [ "epr", - "eprel" + "epreel" ], "may": [ "mee" @@ -73,13 +73,15 @@ "satọdee" ], "sunday": [ - "mbọsị ụka", - "ụka" + "sọn", + "sọndee" ], "am": [ - "am" + "am", + "n'ụtụtụ" ], "pm": [ + "n'abali", "pm" ], "year": [ @@ -95,59 +97,61 @@ "ụbọchị" ], "hour": [ - "elekere" + "elekere", + "hr" ], "minute": [ "nkeji" ], "second": [ - "nkejinta" + "tịm kọm" ], "relative-type": { "0 day ago": [ + "taa", "taata" ], "0 hour ago": [ - "this hour" + "elekere a" ], "0 minute ago": [ - "this minute" + "nkejị a" ], "0 month ago": [ - "this month" + "ọnwa a" ], "0 second ago": [ - "now" + "ụgbụa" ], "0 week ago": [ - "this week" + "izu a" ], "0 year ago": [ - "this year" + "afọ a" ], "1 day ago": [ - "nnyaafụ" + "ụnyaahụ" ], "1 month ago": [ - "last month" + "ọnwa gara aga" ], "1 week ago": [ - "last week" + "izu gara aga" ], "1 year ago": [ - "last year" + "afọ gara aga" ], "in 1 day": [ "echi" ], "in 1 month": [ - "next month" + "ọnwa ọzọ" ], "in 1 week": [ - "next week" + "izu na-esote" ], "in 1 year": [ - "next year" + "afọ ọzọ" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/ii.json b/dateparser_data/cldr_language_data/date_translation_data/ii.json index 3d80342b2..7e25d1ff5 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ii.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ii.json @@ -84,6 +84,7 @@ "ꑍ" ], "hour": [ + "hr", "ꄮꈉ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/is.json b/dateparser_data/cldr_language_data/date_translation_data/is.json index 1f5815825..fe034da87 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/is.json +++ b/dateparser_data/cldr_language_data/date_translation_data/is.json @@ -94,12 +94,12 @@ "vika" ], "day": [ - "d", "dagur" ], "hour": [ "klst", - "klukkustund" + "klukkustund", + "klukkustundir" ], "minute": [ "mín", @@ -114,10 +114,10 @@ "í dag" ], "0 hour ago": [ - "this hour" + "þessa stundina" ], "0 minute ago": [ - "this minute" + "á þessari mínútu" ], "0 month ago": [ "í þessum mán", diff --git a/dateparser_data/cldr_language_data/date_translation_data/it.json b/dateparser_data/cldr_language_data/date_translation_data/it.json index 7d7524ce5..f44102df4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/it.json +++ b/dateparser_data/cldr_language_data/date_translation_data/it.json @@ -99,16 +99,15 @@ ], "hour": [ "h", - "ora" + "ora", + "ore" ], "minute": [ - "m", "min", "minuto" ], "second": [ "s", - "sec", "secondo" ], "relative-type": { @@ -128,6 +127,7 @@ "ora" ], "0 week ago": [ + "questa sett", "questa settimana" ], "0 year ago": [ @@ -140,6 +140,7 @@ "mese scorso" ], "1 week ago": [ + "sett scorsa", "settimana scorsa" ], "1 year ago": [ @@ -152,6 +153,7 @@ "mese prossimo" ], "in 1 week": [ + "sett prossima", "settimana prossima" ], "in 1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ja.json b/dateparser_data/cldr_language_data/date_translation_data/ja.json index 7b8596ff6..76566ef81 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ja.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ja.json @@ -84,7 +84,8 @@ "日" ], "hour": [ - "時" + "時", + "時間" ], "minute": [ "分" @@ -130,13 +131,13 @@ "明日" ], "in 1 month": [ - "翌月" + "来月" ], "in 1 week": [ - "翌週" + "来週" ], "in 1 year": [ - "翌年" + "来年" ] }, "relative-type-regex": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/jgo.json b/dateparser_data/cldr_language_data/date_translation_data/jgo.json index d1a58fc60..e8542cbc0 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/jgo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/jgo.json @@ -77,7 +77,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/jmc.json b/dateparser_data/cldr_language_data/date_translation_data/jmc.json index 97240f49b..3ff3cb380 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/jmc.json +++ b/dateparser_data/cldr_language_data/date_translation_data/jmc.json @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ka.json b/dateparser_data/cldr_language_data/date_translation_data/ka.json index 3a7b4f783..ffdba8c92 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ka.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ka.json @@ -81,8 +81,7 @@ "am" ], "pm": [ - "pm", - "შუადღ შემდეგ" + "pm" ], "year": [ "წ", diff --git a/dateparser_data/cldr_language_data/date_translation_data/kab.json b/dateparser_data/cldr_language_data/date_translation_data/kab.json index 8098f20b3..2964812fa 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kab.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kab.json @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tamert" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kam.json b/dateparser_data/cldr_language_data/date_translation_data/kam.json index 77dc7515d..dbd084ff8 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kam.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kam.json @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kde.json b/dateparser_data/cldr_language_data/date_translation_data/kde.json index eb38ec1a4..8cd05fa05 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kde.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kde.json @@ -96,6 +96,7 @@ "lihiku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kea.json b/dateparser_data/cldr_language_data/date_translation_data/kea.json index 5be041a23..9fb61e47f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kea.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kea.json @@ -71,7 +71,6 @@ ], "saturday": [ "sab", - "sabadu", "sábadu" ], "sunday": [ @@ -116,16 +115,16 @@ "oji" ], "0 hour ago": [ - "this hour" + "es ora li" ], "0 minute ago": [ - "this minute" + "es minutu li" ], "0 month ago": [ "es mes li" ], "0 second ago": [ - "now" + "agora" ], "0 week ago": [ "es simana li" @@ -146,7 +145,7 @@ "anu pasadu" ], "in 1 day": [ - "manha" + "manhan" ], "in 1 month": [ "prósimu mes" diff --git a/dateparser_data/cldr_language_data/date_translation_data/khq.json b/dateparser_data/cldr_language_data/date_translation_data/khq.json index c1b0c883f..7457f5b58 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/khq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/khq.json @@ -94,7 +94,8 @@ "jaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ki.json b/dateparser_data/cldr_language_data/date_translation_data/ki.json index df75e61dc..db3d4eb1f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ki.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ki.json @@ -96,6 +96,7 @@ "mũthenya" ], "hour": [ + "hr", "ithaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kl.json b/dateparser_data/cldr_language_data/date_translation_data/kl.json index 90e80016a..abd37af29 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kl.json @@ -3,51 +3,63 @@ "date_order": "YMD", "january": [ "jan", - "januari" + "januaari", + "januaarip" ], "february": [ - "feb", - "februari" + "febr", + "februaari", + "februaarip" ], "march": [ "mar", - "martsi" + "marsi", + "marsip" ], "april": [ "apr", - "aprili" + "apriili", + "apriilip" ], "may": [ - "maj", - "maji" + "maaji", + "maajip", + "maj" ], "june": [ "jun", - "juni" + "juuni", + "juunip" ], "july": [ "jul", - "juli" + "juuli", + "juulip" ], "august": [ - "aug", - "augustusi" + "aggusti", + "aggustip", + "aug" ], "september": [ - "sep", - "septemberi" + "sept", + "septembari", + "septembarip" ], "october": [ "okt", - "oktoberi" + "oktobari", + "oktobarip" ], "november": [ "nov", - "novemberi" + "novembari", + "novembarip" ], "december": [ "dec", - "decemberi" + "decembari", + "decembarip" ], "monday": [ "ata", @@ -74,8 +86,8 @@ "arfininngorneq" ], "sunday": [ - "sab", - "sabaat" + "sap", + "sapaat" ], "am": [ "am" @@ -96,7 +108,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/kln.json b/dateparser_data/cldr_language_data/date_translation_data/kln.json index d62ec4ca1..88433d15f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kln.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kln.json @@ -98,6 +98,7 @@ "betut" ], "hour": [ + "hr", "sait" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/km.json b/dateparser_data/cldr_language_data/date_translation_data/km.json index f57e747c2..027602d4b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/km.json +++ b/dateparser_data/cldr_language_data/date_translation_data/km.json @@ -38,6 +38,7 @@ "ធ្នូ" ], "monday": [ + "ចន្ទ", "ច័ន្ទ" ], "tuesday": [ @@ -47,6 +48,7 @@ "ពុធ" ], "thursday": [ + "ព្រហ", "ព្រហស្បតិ៍" ], "friday": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kn.json b/dateparser_data/cldr_language_data/date_translation_data/kn.json index 8197f4aee..152ff7501 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kn.json @@ -92,7 +92,8 @@ "ದಿನ" ], "hour": [ - "ಗಂಟೆ" + "ಗಂಟೆ", + "ಗಂಟೆಗಳು" ], "minute": [ "ನಿಮಿಷ" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ko.json b/dateparser_data/cldr_language_data/date_translation_data/ko.json index 0aa9a72fb..c786e76d4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ko.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ko.json @@ -86,7 +86,8 @@ "일" ], "hour": [ - "시" + "시", + "시간" ], "minute": [ "분" @@ -186,6 +187,9 @@ ] }, "locale_specific": { + "ko-CN": { + "name": "ko-CN" + }, "ko-KP": { "name": "ko-KP" } diff --git a/dateparser_data/cldr_language_data/date_translation_data/kok.json b/dateparser_data/cldr_language_data/date_translation_data/kok.json index c9bbfcd99..fa4692b95 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kok.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kok.json @@ -1,17 +1,20 @@ { "name": "kok", - "date_order": "YMD", + "date_order": "DMY", "january": [ + "जाने", "जानेवारी" ], "february": [ + "फेब्रु", "फेब्रुवारी" ], "march": [ "मार्च" ], "april": [ - "एप्रिल" + "एप्री", + "एप्रील" ], "may": [ "मे" @@ -20,123 +23,172 @@ "जून" ], "july": [ - "जुलै" + "जुल", + "जुलय" ], "august": [ - "ओगस्ट" + "ऑग", + "ऑगस्ट" ], "september": [ - "सेप्टेंबर" + "सप्टें", + "सप्टेंबर" ], "october": [ - "ओक्टोबर" + "ऑक्टो", + "ऑक्टोबर" ], "november": [ + "नो", "नोव्हेंबर" ], "december": [ + "डिसे", "डिसेंबर" ], "monday": [ - "सोम", - "सोमवार" + "सोमार" ], "tuesday": [ - "मंगळ", "मंगळार" ], "wednesday": [ - "बुध", "बुधवार" ], "thursday": [ - "गुरु", - "गुरुवार" + "बिरेस्तार" ], "friday": [ - "शुक्र", - "शुक्रवार" + "शुक्रार" ], "saturday": [ - "शनि", - "शनिवार" + "शेनवार" ], "sunday": [ - "आदित्यवार", - "रवि" + "आयतार" ], "am": [ - "मपू" + "am", + "सकाळ" ], "pm": [ - "मनं" + "pm", + "सांज" ], "year": [ - "year" + "वर्स" ], "month": [ - "month" + "म्हयनो" ], "week": [ - "week" + "सप्तक" ], "day": [ - "day" + "दीस" ], "hour": [ - "hour" + "वर", + "वरां" ], "minute": [ - "minute" + "मिनीट" ], "second": [ - "second" + "सेकंद" ], "relative-type": { "0 day ago": [ - "today" + "आयज" ], "0 hour ago": [ - "this hour" + "हें वर" ], "0 minute ago": [ - "this minute" + "हें मिनीट" ], "0 month ago": [ - "this month" + "हो म्हयनो" ], "0 second ago": [ - "now" + "आतां" ], "0 week ago": [ - "this week" + "हो सप्तक" ], "0 year ago": [ - "this year" + "हें वर्स" ], "1 day ago": [ - "yesterday" + "काल" ], "1 month ago": [ - "last month" + "फाटलो म्हयनो" ], "1 week ago": [ - "last week" + "निमाणो सप्तक" ], "1 year ago": [ - "last year" + "फाटलें वर्स" ], "in 1 day": [ - "tomorrow" + "फाल्यां" ], "in 1 month": [ - "next month" + "फुडलो म्हयनो" ], "in 1 week": [ - "next week" + "फुडलो सप्तक" ], "in 1 year": [ - "next year" + "फुडलें वर्स" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "{0} दीस आदीं" + ], + "\\1 hour ago": [ + "{0} वरा आदीं" + ], + "\\1 minute ago": [ + "{0} मिन्टां आदीं" + ], + "\\1 month ago": [ + "{0} म्हयन्यां आदीं" + ], + "\\1 second ago": [ + "{0} से आदीं", + "{0} सेकंद आदीं" + ], + "\\1 week ago": [ + "{0} सप्त आदीं", + "{0} सप्तकां आदीं" + ], + "\\1 year ago": [ + "{0} वर्स आदीं", + "{0} वर्सां आदीं" + ], + "in \\1 day": [ + "{0} दिसानीं" + ], + "in \\1 hour": [ + "{0} वरांनीं" + ], + "in \\1 minute": [ + "{0} मिन्टां" + ], + "in \\1 month": [ + "{0} म्हयन्यानीं" + ], + "in \\1 second": [ + "{0} सेकंदानीं" + ], + "in \\1 week": [ + "{0} सप्तकांनीं" + ], + "in \\1 year": [ + "{0} वर्सांनीं" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/ks.json b/dateparser_data/cldr_language_data/date_translation_data/ks.json index 2452fdeea..83373ee43 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ks.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ks.json @@ -14,13 +14,14 @@ "اپریل" ], "may": [ - "میٔ" + "مئی" ], "june": [ "جوٗن" ], "july": [ - "جوٗلایی" + "جوٗلایی", + "جُلَے" ], "august": [ "اگست" @@ -35,20 +36,21 @@ "نومبر" ], "december": [ - "دسمبر" + "دسمبر", + "دَسَمبَر" ], "monday": [ - "ژٔنٛدرٕروار", - "ژٔنٛدٕروار" + "ژٔندرٕروار", + "ژٔندٕروار" ], "tuesday": [ - "بوٚموار" + "بۆموار" ], "wednesday": [ "بودوار" ], "thursday": [ - "برٛٮ۪سوار" + "برؠسوار" ], "friday": [ "جُمہ" @@ -61,16 +63,18 @@ "اَتھوار" ], "am": [ - "am" + "am", + "اے ایم" ], "pm": [ - "pm" + "pm", + "پی ایم" ], "year": [ "ؤری" ], "month": [ - "رٮ۪تھ" + "رؠتھ" ], "week": [ "ہفتہٕ" @@ -79,13 +83,14 @@ "دۄہ" ], "hour": [ - "گٲنٛٹہٕ" + "hr", + "گٲنٹہٕ" ], "minute": [ "مِنَٹ" ], "second": [ - "سٮ۪کَنڑ" + "سؠکَنڈ" ], "relative-type": { "0 day ago": [ @@ -98,40 +103,40 @@ "this minute" ], "0 month ago": [ - "this month" + "یٕہ ریتھۍ" ], "0 second ago": [ "now" ], "0 week ago": [ - "this week" + "یٕہ ہفتہ" ], "0 year ago": [ - "this year" + "یٕہ ؤری" ], "1 day ago": [ "راتھ" ], "1 month ago": [ - "last month" + "پٔتِم ریتھۍ" ], "1 week ago": [ - "last week" + "پٔتِم ہفتہ" ], "1 year ago": [ - "last year" + "پٔتِم ؤری" ], "in 1 day": [ "پگاہ" ], "in 1 month": [ - "next month" + "نو ریتھۍ" ], "in 1 week": [ - "next week" + "نو ہفتہ" ], "in 1 year": [ - "next year" + "نو ؤری" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/ksb.json b/dateparser_data/cldr_language_data/date_translation_data/ksb.json index 463811890..8bf838594 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ksb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ksb.json @@ -95,6 +95,7 @@ "siku" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ksf.json b/dateparser_data/cldr_language_data/date_translation_data/ksf.json index 21eec6922..d07c4c33a 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ksf.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ksf.json @@ -96,7 +96,8 @@ "ŋwós" ], "hour": [ - "cámɛɛn" + "cámɛɛn", + "hr" ], "minute": [ "mǝnít" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ksh.json b/dateparser_data/cldr_language_data/date_translation_data/ksh.json index ad9d7c509..18bc30aba 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ksh.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ksh.json @@ -105,6 +105,7 @@ "hour": [ "s", "schtund", + "schtunde", "std" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/kw.json b/dateparser_data/cldr_language_data/date_translation_data/kw.json index 2c2038b1c..e671e8738 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/kw.json +++ b/dateparser_data/cldr_language_data/date_translation_data/kw.json @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ky.json b/dateparser_data/cldr_language_data/date_translation_data/ky.json index b74d3287c..b8df5edb6 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ky.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ky.json @@ -147,7 +147,7 @@ "былтыр" ], "in 1 day": [ - "эртеӊ" + "эртең" ], "in 1 month": [ "эмдиги айда" diff --git a/dateparser_data/cldr_language_data/date_translation_data/lag.json b/dateparser_data/cldr_language_data/date_translation_data/lag.json index 3cfeddc6c..f6bb5e81c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lag.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lag.json @@ -96,6 +96,7 @@ "sikʉ" ], "hour": [ + "hr", "sáa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/lb.json b/dateparser_data/cldr_language_data/date_translation_data/lb.json index c8385fc12..d3798c988 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lb.json @@ -100,7 +100,8 @@ ], "hour": [ "st", - "stonn" + "stonn", + "stonnen" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/lg.json b/dateparser_data/cldr_language_data/date_translation_data/lg.json index 3ee5fc230..df2c022b3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lg.json @@ -96,6 +96,7 @@ "lunaku" ], "hour": [ + "hr", "saawa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/lkt.json b/dateparser_data/cldr_language_data/date_translation_data/lkt.json index 74707657c..e70d94c86 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lkt.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lkt.json @@ -1,6 +1,6 @@ { "name": "lkt", - "date_order": "YMD", + "date_order": "MDY", "january": [ "wiótheȟika wí" ], @@ -77,6 +77,7 @@ "aŋpétu" ], "hour": [ + "hr", "owápȟe" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ln.json b/dateparser_data/cldr_language_data/date_translation_data/ln.json index 7e6321da6..66bd8665e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ln.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ln.json @@ -96,6 +96,7 @@ "mokɔlɔ" ], "hour": [ + "hr", "ngonga" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/lo.json b/dateparser_data/cldr_language_data/date_translation_data/lo.json index 113c3931a..bb2e285cb 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lo.json @@ -191,8 +191,8 @@ "ໃນອີກ {0} ຊົ່ວໂມງ" ], "in \\1 minute": [ - "{0} ໃນອີກ 0 ນາທີ", - "ໃນ {0} ນທ" + "ໃນ {0} ນທ", + "ໃນອີກ {0} ນາທີ" ], "in \\1 month": [ "ໃນອີກ {0} ດ", diff --git a/dateparser_data/cldr_language_data/date_translation_data/lrc.json b/dateparser_data/cldr_language_data/date_translation_data/lrc.json index 2c20cf10e..ad8346d7d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lrc.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lrc.json @@ -77,6 +77,7 @@ "روٙز" ], "hour": [ + "hr", "ساأت" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/lt.json b/dateparser_data/cldr_language_data/date_translation_data/lt.json index 8981948c7..9b397dba9 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lt.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lt.json @@ -114,7 +114,8 @@ "hour": [ "h", "val", - "valanda" + "valanda", + "valandos" ], "minute": [ "min", diff --git a/dateparser_data/cldr_language_data/date_translation_data/lu.json b/dateparser_data/cldr_language_data/date_translation_data/lu.json index 88c33d7e4..8705a76b7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lu.json @@ -96,7 +96,8 @@ "dituku" ], "hour": [ - "diba" + "diba", + "hr" ], "minute": [ "kasunsu" diff --git a/dateparser_data/cldr_language_data/date_translation_data/luo.json b/dateparser_data/cldr_language_data/date_translation_data/luo.json index 6834a4af1..3f051df39 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/luo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/luo.json @@ -96,6 +96,7 @@ "chieng'" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/luy.json b/dateparser_data/cldr_language_data/date_translation_data/luy.json index dddfb7506..00bfce102 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/luy.json +++ b/dateparser_data/cldr_language_data/date_translation_data/luy.json @@ -95,6 +95,7 @@ "ridiku" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/lv.json b/dateparser_data/cldr_language_data/date_translation_data/lv.json index f768fb4fb..7e038300f 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/lv.json +++ b/dateparser_data/cldr_language_data/date_translation_data/lv.json @@ -127,39 +127,48 @@ "šajā minūtē" ], "0 month ago": [ + "šajā mēn", "šajā mēnesī" ], "0 second ago": [ "tagad" ], "0 week ago": [ + "šajā ned", "šajā nedēļā" ], "0 year ago": [ + "šajā g", "šajā gadā" ], "1 day ago": [ "vakar" ], "1 month ago": [ + "pag mēn", "pagājušajā mēnesī" ], "1 week ago": [ + "pag ned", "pagājušajā nedēļā" ], "1 year ago": [ + "pag gadā", "pagājušajā gadā" ], "in 1 day": [ "rīt" ], "in 1 month": [ + "nāk mēn", "nākamajā mēnesī" ], "in 1 week": [ + "nāk ned", "nākamajā nedēļā" ], "in 1 year": [ + "nāk gadā", "nākamajā gadā" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/mas.json b/dateparser_data/cldr_language_data/date_translation_data/mas.json index 38ac9cda8..a795bd07d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mas.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mas.json @@ -96,6 +96,7 @@ "ɛnkɔlɔ́ŋ" ], "hour": [ + "hr", "ɛ́sáâ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/mer.json b/dateparser_data/cldr_language_data/date_translation_data/mer.json index 52158fb38..65e0e5602 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mer.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mer.json @@ -95,6 +95,7 @@ "ntukũ" ], "hour": [ + "hr", "ĩthaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/mfe.json b/dateparser_data/cldr_language_data/date_translation_data/mfe.json index d77abaf84..a3bcc1b3c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mfe.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mfe.json @@ -93,6 +93,7 @@ "zour" ], "hour": [ + "hr", "ler" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/mg.json b/dateparser_data/cldr_language_data/date_translation_data/mg.json index 36d8a84a3..20857e892 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mg.json @@ -95,6 +95,7 @@ "andro" ], "hour": [ + "hr", "ora" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/mgh.json b/dateparser_data/cldr_language_data/date_translation_data/mgh.json index 4dd179be5..8ef7c5167 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mgh.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mgh.json @@ -96,6 +96,7 @@ "nihuku" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/mgo.json b/dateparser_data/cldr_language_data/date_translation_data/mgo.json index a13337522..b3c32da77 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mgo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mgo.json @@ -78,7 +78,8 @@ "anəg" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/mk.json b/dateparser_data/cldr_language_data/date_translation_data/mk.json index ecabcd0c0..2c36202c4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mk.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mk.json @@ -33,7 +33,7 @@ "август" ], "september": [ - "септ", + "сеп", "септември" ], "october": [ @@ -41,7 +41,7 @@ "октомври" ], "november": [ - "ноем", + "ное", "ноември" ], "december": [ @@ -53,7 +53,6 @@ "понеделник" ], "tuesday": [ - "вт", "вто", "вторник" ], @@ -78,12 +77,10 @@ "недела" ], "am": [ - "претпл", - "претпладне" + "претпл" ], "pm": [ - "попл", - "попладне" + "попл" ], "year": [ "год", @@ -94,14 +91,16 @@ "месец" ], "week": [ - "недела", - "сед" + "сед", + "седмица" ], "day": [ "ден" ], "hour": [ - "час" + "ч", + "час", + "часа" ], "minute": [ "мин", @@ -131,6 +130,7 @@ "оваа седмица" ], "0 year ago": [ + "оваа год", "оваа година" ], "1 day ago": [ @@ -143,7 +143,8 @@ "минатата седмица" ], "1 year ago": [ - "минатата година" + "лани", + "минатата год" ], "in 1 day": [ "утре" @@ -155,7 +156,8 @@ "следната седмица" ], "in 1 year": [ - "следната година" + "догодина", + "следната год" ] }, "relative-type-regex": { @@ -168,6 +170,7 @@ "пред {0} часа" ], "\\1 minute ago": [ + "пред {0} мин", "пред {0} минута", "пред {0} минути" ], @@ -176,6 +179,7 @@ "пред {0} месеци" ], "\\1 second ago": [ + "пред {0} сек", "пред {0} секунда", "пред {0} секунди" ], @@ -184,6 +188,7 @@ "пред {0} седмици" ], "\\1 year ago": [ + "пред {0} год", "пред {0} година", "пред {0} години" ], @@ -196,6 +201,7 @@ "за {0} часа" ], "in \\1 minute": [ + "за {0} мин", "за {0} минута", "за {0} минути" ], @@ -204,6 +210,7 @@ "за {0} месеци" ], "in \\1 second": [ + "за {0} сек", "за {0} секунда", "за {0} секунди" ], @@ -212,6 +219,7 @@ "за {0} седмици" ], "in \\1 year": [ + "за {0} год", "за {0} година", "за {0} години" ] diff --git a/dateparser_data/cldr_language_data/date_translation_data/mn.json b/dateparser_data/cldr_language_data/date_translation_data/mn.json index 1ec4c969e..a1a89dfe1 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mn.json @@ -23,11 +23,11 @@ ], "june": [ "6-р сар", - "зургадугаар сар" + "зургаадугаар сар" ], "july": [ "7-р сар", - "долдугаар сар" + "долоодугаар сар" ], "august": [ "8-р сар", @@ -90,7 +90,7 @@ "сар" ], "week": [ - "7х", + "7 хоног", "долоо хоног" ], "day": [ @@ -125,6 +125,7 @@ "одоо" ], "0 week ago": [ + "энэ 7 хоног", "энэ долоо хоног" ], "0 year ago": [ @@ -137,6 +138,7 @@ "өнгөрсөн сар" ], "1 week ago": [ + "өнгөрсөн 7 хоног", "өнгөрсөн долоо хоног" ], "1 year ago": [ @@ -149,6 +151,7 @@ "ирэх сар" ], "in 1 week": [ + "ирэх 7 хоног", "ирэх долоо хоног" ], "in 1 year": [ @@ -175,14 +178,14 @@ "{0} секундын өмнө" ], "\\1 week ago": [ - "{0} 7х-ийн өмнө" + "{0} 7 хоногийн өмнө", + "{0} долоо хоногийн өмнө" ], "\\1 year ago": [ "{0} жилийн өмнө" ], "in \\1 day": [ - "{0} өдрийн дараа", - "{0} өдөрт" + "{0} өдрийн дараа" ], "in \\1 hour": [ "{0} ц дараа", @@ -200,7 +203,8 @@ "{0} секундын дараа" ], "in \\1 week": [ - "{0} 7х-ийн дараа" + "{0} 7 хоногийн дараа", + "{0} долоо хоногийн дараа" ], "in \\1 year": [ "{0} жилийн дараа" diff --git a/dateparser_data/cldr_language_data/date_translation_data/mr.json b/dateparser_data/cldr_language_data/date_translation_data/mr.json index 6b9cba56f..956c6ec8b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mr.json @@ -74,24 +74,28 @@ "रविवार" ], "am": [ - "मपू" + "am" ], "pm": [ - "मउ" + "pm" ], "year": [ "वर्ष" ], "month": [ + "म", "महिना" ], "week": [ + "आठ", "आठवडा" ], "day": [ + "दि", "दिवस" ], "hour": [ + "ता", "तास" ], "minute": [ @@ -182,11 +186,15 @@ ], "in \\1 day": [ "{0} दिवसांमध्ये", - "{0} दिवसामध्ये" + "{0} दिवसामध्ये", + "येत्या {0} दिवसांमध्ये", + "येत्या {0} दिवसामध्ये" ], "in \\1 hour": [ "{0} तासांमध्ये", - "{0} तासामध्ये" + "{0} तासामध्ये", + "येत्या {0} तासांमध्ये", + "येत्या {0} तासामध्ये" ], "in \\1 minute": [ "{0} मिनि मध्ये", @@ -195,20 +203,27 @@ ], "in \\1 month": [ "{0} महिन्यांमध्ये", - "{0} महिन्यामध्ये" + "{0} महिन्यामध्ये", + "येत्या {0} महिन्यांमध्ये", + "येत्या {0} महिन्यामध्ये" ], "in \\1 second": [ "{0} से मध्ये", "{0} सेकंदांमध्ये", - "{0} सेकंदामध्ये" + "{0} सेकंदामध्ये", + "येत्या {0} से मध्ये" ], "in \\1 week": [ "{0} आठवड्यांमध्ये", - "{0} आठवड्यामध्ये" + "{0} आठवड्यामध्ये", + "येत्या {0} आठवड्यांमध्ये", + "येत्या {0} आठवड्यामध्ये" ], "in \\1 year": [ "{0} वर्षांमध्ये", - "{0} वर्षामध्ये" + "{0} वर्षामध्ये", + "येत्या {0} वर्षांमध्ये", + "येत्या {0} वर्षामध्ये" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/ms.json b/dateparser_data/cldr_language_data/date_translation_data/ms.json index 3de154dd6..c7e63b73c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ms.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ms.json @@ -123,8 +123,8 @@ "sekarang" ], "0 week ago": [ - "minggu ini", - "mng ini" + "mgu ini", + "minggu ini" ], "0 year ago": [ "tahun ini", @@ -139,8 +139,8 @@ "bulan lalu" ], "1 week ago": [ - "minggu lalu", - "mng lepas" + "mgu lepas", + "minggu lalu" ], "1 year ago": [ "tahun lalu", @@ -154,8 +154,8 @@ "bulan depan" ], "in 1 week": [ - "minggu depan", - "mng depan" + "mgu depan", + "minggu depan" ], "in 1 year": [ "tahun depan", @@ -213,7 +213,7 @@ "dlm {0} mgu" ], "in \\1 year": [ - "dalam {0} saat", + "dalam {0} tahun", "dalam {0} thn" ] }, @@ -221,6 +221,9 @@ "ms-BN": { "name": "ms-BN" }, + "ms-ID": { + "name": "ms-ID" + }, "ms-SG": { "name": "ms-SG" } diff --git a/dateparser_data/cldr_language_data/date_translation_data/mt.json b/dateparser_data/cldr_language_data/date_translation_data/mt.json index 2b31830c8..85e5ee439 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mt.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mt.json @@ -84,24 +84,31 @@ "pm" ], "year": [ - "sena" + "sena", + "sn" ], "month": [ "xahar" ], "week": [ - "ġimgħa" + "ġimgħa", + "ġm" ], "day": [ "jum" ], "hour": [ + "hr", "siegħa" ], "minute": [ + "m", + "min", "minuta" ], "second": [ + "s", + "sek", "sekonda" ], "relative-type": { @@ -109,16 +116,16 @@ "illum" ], "0 hour ago": [ - "this hour" + "din is-siegħa" ], "0 minute ago": [ - "this minute" + "din il-minuta" ], "0 month ago": [ "dan ix-xahar" ], "0 second ago": [ - "now" + "issa" ], "0 week ago": [ "din il-ġimgħa" @@ -127,7 +134,7 @@ "din is-sena" ], "1 day ago": [ - "ilbieraħ" + "lbieraħ" ], "1 month ago": [ "ix-xahar li għadda" @@ -136,7 +143,7 @@ "il-ġimgħa li għaddiet" ], "1 year ago": [ - "is-sena li għaddiet" + "is-sena l-oħra" ], "in 1 day": [ "għada" @@ -152,9 +159,52 @@ ] }, "relative-type-regex": { + "\\1 day ago": [ + "{0} ġurnata ilu" + ], + "\\1 hour ago": [ + "{0} siegħa ilu" + ], + "\\1 minute ago": [ + "{0} min ilu", + "{0} minuta ilu" + ], + "\\1 month ago": [ + "{0} xahar ilu" + ], + "\\1 second ago": [ + "{0} sek ilu", + "{0} sekonda ilu" + ], + "\\1 week ago": [ + "{0} ġimgħa ilu" + ], "\\1 year ago": [ - "{0} sena ilu", - "{0} snin ilu" + "{0} sena ilu" + ], + "in \\1 day": [ + "fi żmien {0} ġurnata oħra" + ], + "in \\1 hour": [ + "fi żmien {0} siegħa" + ], + "in \\1 minute": [ + "sa {0} min oħra", + "sa {0} minuta oħra" + ], + "in \\1 month": [ + "fi {0} xahar oħra", + "sa {0} xahar oħra" + ], + "in \\1 second": [ + "sa {0} sek oħra", + "sa {0} sekonda oħra" + ], + "in \\1 week": [ + "sa {0} ġimgħa oħra" + ], + "in \\1 year": [ + "fi żmien {0} sena oħra" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/mua.json b/dateparser_data/cldr_language_data/date_translation_data/mua.json index cd38efd39..b993730e0 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/mua.json +++ b/dateparser_data/cldr_language_data/date_translation_data/mua.json @@ -96,7 +96,8 @@ "zah'nane/ comme" ], "hour": [ - "cok comme" + "cok comme", + "hr" ], "minute": [ "cok comme ma laŋne" diff --git a/dateparser_data/cldr_language_data/date_translation_data/naq.json b/dateparser_data/cldr_language_data/date_translation_data/naq.json index fb7235fc4..e29213842 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/naq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/naq.json @@ -96,6 +96,7 @@ "tsees" ], "hour": [ + "hr", "iiri" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/nb.json b/dateparser_data/cldr_language_data/date_translation_data/nb.json index 0cc2aeaca..b782c52f4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nb.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nb.json @@ -100,7 +100,8 @@ ], "hour": [ "t", - "time" + "time", + "timer" ], "minute": [ "m", @@ -193,8 +194,7 @@ "for {0} uker siden" ], "\\1 year ago": [ - "for {0} år siden", - "–{0} år" + "for {0} år siden" ], "in \\1 day": [ "om {0} d", diff --git a/dateparser_data/cldr_language_data/date_translation_data/nd.json b/dateparser_data/cldr_language_data/date_translation_data/nd.json index 52d196951..02e7bac1b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nd.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nd.json @@ -96,6 +96,7 @@ "ilanga" ], "hour": [ + "hr", "ihola" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ne.json b/dateparser_data/cldr_language_data/date_translation_data/ne.json index 68757c5a8..402c83d69 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ne.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ne.json @@ -14,7 +14,6 @@ "अप्रिल" ], "may": [ - "मई", "मे" ], "june": [ @@ -73,7 +72,6 @@ "अपराह्न" ], "year": [ - "बर्ष", "वर्ष" ], "month": [ @@ -99,7 +97,7 @@ "आज" ], "0 hour ago": [ - "यो घडीमा" + "यस घडीमा" ], "0 minute ago": [ "यही मिनेटमा" @@ -108,7 +106,7 @@ "यो महिना" ], "0 second ago": [ - "अब" + "अहिले" ], "0 week ago": [ "यो हप्ता" @@ -132,13 +130,14 @@ "भोलि" ], "in 1 month": [ - "अर्को महिना" + "अर्को महिना", + "आगामी महिना" ], "in 1 week": [ - "आउने हप्ता" + "आगामी हप्ता" ], "in 1 year": [ - "अर्को वर्ष" + "आगामी वर्ष" ] }, "relative-type-regex": { @@ -155,7 +154,7 @@ "{0} महिना पहिले" ], "\\1 second ago": [ - "{0} सेकेण्ड पहिले" + "{0} सेकेन्ड पहिले" ], "\\1 week ago": [ "{0} हप्ता पहिले" @@ -176,7 +175,7 @@ "{0} महिनामा" ], "in \\1 second": [ - "{0} सेकेण्डमा" + "{0} सेकेन्डमा" ], "in \\1 week": [ "{0} हप्तामा" diff --git a/dateparser_data/cldr_language_data/date_translation_data/nl.json b/dateparser_data/cldr_language_data/date_translation_data/nl.json index effe53b6f..bbfd1b614 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nl.json @@ -98,6 +98,7 @@ "dag" ], "hour": [ + "u", "uur" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/nmg.json b/dateparser_data/cldr_language_data/date_translation_data/nmg.json index 47a6b722f..8749959ad 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nmg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nmg.json @@ -96,6 +96,7 @@ "duö" ], "hour": [ + "hr", "wulā" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/nn.json b/dateparser_data/cldr_language_data/date_translation_data/nn.json index d0dda1795..e801e0fc3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nn.json @@ -84,32 +84,39 @@ "søndag" ], "am": [ - "fm", - "formiddag" + "fm" ], "pm": [ - "em", - "ettermiddag" + "em" ], "year": [ "år" ], "month": [ + "md", "månad" ], "week": [ + "v", "veke" ], "day": [ + "d", "dag" ], "hour": [ + "t", + "timar", "time" ], "minute": [ + "m", + "min", "minutt" ], "second": [ + "s", + "sek", "sekund" ], "relative-type": { @@ -117,97 +124,114 @@ "i dag" ], "0 hour ago": [ - "this hour" + "denne timen" ], "0 minute ago": [ - "this minute" + "dette minuttet" ], "0 month ago": [ - "this month" + "denne md", + "denne månaden" ], "0 second ago": [ - "now" + "no" ], "0 week ago": [ - "this week" + "denne veka" ], "0 year ago": [ - "this year" + "i år" ], "1 day ago": [ "i går" ], "1 month ago": [ - "last month" + "førre md", + "førre månad" ], "1 week ago": [ - "last week" + "førre veke" ], "1 year ago": [ - "last year" + "i fjor" ], "in 1 day": [ "i morgon" ], "in 1 month": [ - "next month" + "neste md", + "neste månad" ], "in 1 week": [ - "next week" + "neste veke" ], "in 1 year": [ - "next year" + "neste år" ] }, "relative-type-regex": { "\\1 day ago": [ - "for {0} døgn siden" + "for {0} d sidan", + "for {0} døgn sidan", + "–{0} d" ], "\\1 hour ago": [ - "for {0} time siden", - "for {0} timer siden" + "for {0} t sidan", + "for {0} timar sidan", + "for {0} time sidan", + "–{0} t" ], "\\1 minute ago": [ - "for {0} minutt siden", - "for {0} minutter siden" + "for {0} min sidan", + "for {0} minutt sidan", + "–{0} min" ], "\\1 month ago": [ - "for {0} måned siden", - "for {0} måneder siden" + "for {0} md sidan", + "for {0} månad sidan", + "for {0} månadar sidan", + "–{0} md" ], "\\1 second ago": [ - "for {0} sekund siden", - "for {0} sekunder siden" + "for {0} sek sidan", + "for {0} sekund sidan", + "–{0} s" ], "\\1 week ago": [ - "for {0} uke siden", - "for {0} uker siden" + "for {0} v sidan", + "for {0} veke sidan", + "for {0} veker sidan", + "–{0} v" ], "\\1 year ago": [ - "for {0} år siden" + "for {0} år sidan" ], "in \\1 day": [ + "om {0} d", "om {0} døgn" ], "in \\1 hour": [ - "om {0} time", - "om {0} timer" + "om {0} t", + "om {0} timar", + "om {0} time" ], "in \\1 minute": [ - "om {0} minutt", - "om {0} minutter" + "om {0} min", + "om {0} minutt" ], "in \\1 month": [ - "om {0} måned", - "om {0} måneder" + "om {0} md", + "om {0} månad", + "om {0} månadar" ], "in \\1 second": [ - "om {0} sekund", - "om {0} sekunder" + "om {0} sek", + "om {0} sekund" ], "in \\1 week": [ - "om {0} uke", - "om {0} uker" + "om {0} v", + "om {0} veke", + "om {0} veker" ], "in \\1 year": [ "om {0} år" diff --git a/dateparser_data/cldr_language_data/date_translation_data/nnh.json b/dateparser_data/cldr_language_data/date_translation_data/nnh.json index c8d5ff8bf..4383eacde 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nnh.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nnh.json @@ -77,7 +77,8 @@ "lyɛ̌'" ], "hour": [ - "fʉ̀' nèm" + "fʉ̀' nèm", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/nus.json b/dateparser_data/cldr_language_data/date_translation_data/nus.json index f79ebb4cd..75d6756cc 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nus.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nus.json @@ -93,6 +93,7 @@ "cäŋ" ], "hour": [ + "hr", "thaak" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/nyn.json b/dateparser_data/cldr_language_data/date_translation_data/nyn.json index 519bc9ac3..f8f929b1e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/nyn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/nyn.json @@ -96,6 +96,7 @@ "eizooba" ], "hour": [ + "hr", "shaaha" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/om.json b/dateparser_data/cldr_language_data/date_translation_data/om.json index a4bc22e56..c09f1039d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/om.json +++ b/dateparser_data/cldr_language_data/date_translation_data/om.json @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/or.json b/dateparser_data/cldr_language_data/date_translation_data/or.json index 92ed23210..845691458 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/or.json +++ b/dateparser_data/cldr_language_data/date_translation_data/or.json @@ -1,6 +1,6 @@ { "name": "or", - "date_order": "DMY", + "date_order": "MDY", "january": [ "ଜାନୁଆରୀ" ], @@ -66,77 +66,141 @@ "ରବିବାର" ], "am": [ - "am" + "am", + "ପୂର୍ବାହ୍ନ" ], "pm": [ - "pm" + "pm", + "ଅପରାହ୍ନ" ], "year": [ - "year" + "ବ", + "ବର୍ଷ" ], "month": [ - "month" + "ମା", + "ମାସ" ], "week": [ - "week" + "ସ", + "ସପ୍ତାହ" ], "day": [ - "day" + "ଦିନ" ], "hour": [ - "hour" + "ଘ", + "ଘଣ୍ଟା" ], "minute": [ - "minute" + "ମି", + "ମିନିଟ୍" ], "second": [ - "second" + "ସେ", + "ସେକେଣ୍ଡ୍" ], "relative-type": { "0 day ago": [ - "today" + "ଆଜି" ], "0 hour ago": [ - "this hour" + "ଏହି ଘଣ୍ଟା" ], "0 minute ago": [ - "this minute" + "ଏହି ମିନିଟ୍" ], "0 month ago": [ - "this month" + "ଏହି ମାସ" ], "0 second ago": [ - "now" + "ବର୍ତ୍ତମାନ" ], "0 week ago": [ - "this week" + "ଏହି ସପ୍ତାହ" ], "0 year ago": [ - "this year" + "ଏହି ବର୍ଷ" ], "1 day ago": [ - "yesterday" + "ଗତକାଲି" ], "1 month ago": [ - "last month" + "ଗତ ମାସ" ], "1 week ago": [ - "last week" + "ଗତ ସପ୍ତାହ" ], "1 year ago": [ - "last year" + "ଗତ ବର୍ଷ" ], "in 1 day": [ - "tomorrow" + "ଆସନ୍ତାକାଲି" ], "in 1 month": [ - "next month" + "ଆଗାମୀ ମାସ" ], "in 1 week": [ - "next week" + "ଆଗାମୀ ସପ୍ତାହ" ], "in 1 year": [ - "next year" + "ଆଗାମୀ ବର୍ଷ" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "{0} ଦିନ ପୂର୍ବେ" + ], + "\\1 hour ago": [ + "{0} ଘ ପୂର୍ବେ", + "{0} ଘଣ୍ଟା ପୂର୍ବେ" + ], + "\\1 minute ago": [ + "{0} ମି ପୂର୍ବେ", + "{0} ମିନିଟ୍ ପୂର୍ବେ" + ], + "\\1 month ago": [ + "{0} ମା ପୂର୍ବେ", + "{0} ମାସ ପୂର୍ବେ" + ], + "\\1 second ago": [ + "{0} ସେ ପୂର୍ବେ", + "{0} ସେକେଣ୍ଡ ପୂର୍ବେ" + ], + "\\1 week ago": [ + "{0} ସପ୍ତା ପୂର୍ବେ", + "{0} ସପ୍ତାହ ପୂର୍ବେ" + ], + "\\1 year ago": [ + "{0} ବ ପୂର୍ବେ", + "{0} ବର୍ଷ ପୂର୍ବେ" + ], + "in \\1 day": [ + "{0} ଦିନରେ" + ], + "in \\1 hour": [ + "{0} ଘ ରେ", + "{0} ଘଣ୍ଟାରେ" + ], + "in \\1 minute": [ + "{0} ମି ରେ", + "{0} ମିନିଟ୍‌‌ରେ" + ], + "in \\1 month": [ + "{0} ମା ରେ", + "{0} ମାସରେ" + ], + "in \\1 second": [ + "{0} ସେ ରେ", + "{0} ସେକେଣ୍ଡରେ" + ], + "in \\1 week": [ + "{0} ସପ୍ତା ରେ", + "{0} ସପ୍ତାହରେ" + ], + "in \\1 year": [ + "{0} ବ ରେ", + "{0} ବର୍ଷରେ" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/os.json b/dateparser_data/cldr_language_data/date_translation_data/os.json index c2cd204c0..5762d8afb 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/os.json +++ b/dateparser_data/cldr_language_data/date_translation_data/os.json @@ -111,7 +111,8 @@ "бон" ], "hour": [ - "сахат" + "сахат", + "сахаты" ], "minute": [ "минут" diff --git a/dateparser_data/cldr_language_data/date_translation_data/pa-Arab.json b/dateparser_data/cldr_language_data/date_translation_data/pa-Arab.json index ee529521e..9b2155c58 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/pa-Arab.json +++ b/dateparser_data/cldr_language_data/date_translation_data/pa-Arab.json @@ -77,6 +77,7 @@ "دئن" ], "hour": [ + "hr", "گھنٹا" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/pa-Guru.json b/dateparser_data/cldr_language_data/date_translation_data/pa-Guru.json index 37718bb20..fb79a30df 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/pa-Guru.json +++ b/dateparser_data/cldr_language_data/date_translation_data/pa-Guru.json @@ -94,7 +94,8 @@ ], "hour": [ "ਘੰ", - "ਘੰਟਾ" + "ਘੰਟਾ", + "ਘੰਟੇ" ], "minute": [ "ਮਿੰਟ" diff --git a/dateparser_data/cldr_language_data/date_translation_data/pa.json b/dateparser_data/cldr_language_data/date_translation_data/pa.json index 6b6c980db..fe76d5c0c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/pa.json +++ b/dateparser_data/cldr_language_data/date_translation_data/pa.json @@ -94,7 +94,8 @@ ], "hour": [ "ਘੰ", - "ਘੰਟਾ" + "ਘੰਟਾ", + "ਘੰਟੇ" ], "minute": [ "ਮਿੰਟ" diff --git a/dateparser_data/cldr_language_data/date_translation_data/pl.json b/dateparser_data/cldr_language_data/date_translation_data/pl.json index 1a8f6e9e1..8a73f7486 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/pl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/pl.json @@ -108,12 +108,15 @@ "tydzień" ], "day": [ + "d", + "dz", "dzień" ], "hour": [ "g", "godz", - "godzina" + "godzina", + "godziny" ], "minute": [ "min", @@ -126,7 +129,8 @@ ], "relative-type": { "0 day ago": [ - "dzisiaj" + "dzisiaj", + "dziś" ], "0 hour ago": [ "ta godzina" @@ -135,24 +139,29 @@ "ta minuta" ], "0 month ago": [ + "w tym mies", "w tym miesiącu" ], "0 second ago": [ "teraz" ], "0 week ago": [ + "w tym tyg", "w tym tygodniu" ], "0 year ago": [ "w tym roku" ], "1 day ago": [ + "wcz", "wczoraj" ], "1 month ago": [ + "w zeszłym mies", "w zeszłym miesiącu" ], "1 week ago": [ + "w zeszłym tyg", "w zeszłym tygodniu" ], "1 year ago": [ @@ -162,9 +171,11 @@ "jutro" ], "in 1 month": [ + "w przyszłym mies", "w przyszłym miesiącu" ], "in 1 week": [ + "w przyszłym tyg", "w przyszłym tygodniu" ], "in 1 year": [ @@ -190,8 +201,7 @@ "\\1 month ago": [ "{0} mies temu", "{0} miesiąc temu", - "{0} miesiąca temu", - "–{0} mies" + "{0} miesiąca temu" ], "\\1 second ago": [ "{0} s temu", diff --git a/dateparser_data/cldr_language_data/date_translation_data/ps.json b/dateparser_data/cldr_language_data/date_translation_data/ps.json index 0cd9f6c11..821df60f2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ps.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ps.json @@ -5,7 +5,8 @@ "جنوري" ], "february": [ - "فبروري" + "فبروري", + "فېبروري" ], "march": [ "مارچ" @@ -26,7 +27,8 @@ "اګست" ], "september": [ - "سپتمبر" + "سپتمبر", + "سېپتمبر" ], "october": [ "اکتوبر" @@ -38,99 +40,179 @@ "دسمبر" ], "monday": [ - "دوشنبه" + "دونۍ" ], "tuesday": [ - "سه‌شنبه" + "درېنۍ" ], "wednesday": [ - "چهارشنبه" + "څلرنۍ" ], "thursday": [ - "پنجشنبه" + "پينځنۍ" ], "friday": [ "جمعه" ], "saturday": [ - "شنبه" + "اونۍ" ], "sunday": [ - "یکشنبه" + "يونۍ" ], "am": [ + "am", "غم" ], "pm": [ + "pm", "غو" ], "year": [ - "year" + "کال" ], "month": [ - "month" + "مياشت" ], "week": [ - "week" + "اونۍ" ], "day": [ - "day" + "ورځ" ], "hour": [ - "hour" + "ساعت", + "ساعتونه" ], "minute": [ - "minute" + "دقيقه" ], "second": [ - "second" + "ثانيه" ], "relative-type": { "0 day ago": [ - "today" + "نن" ], "0 hour ago": [ - "this hour" + "دا ساعت" ], "0 minute ago": [ - "this minute" + "دا دقيقه" ], "0 month ago": [ - "this month" + "دا مياشت" ], "0 second ago": [ - "now" + "اوس" ], "0 week ago": [ - "this week" + "دا اونۍ" ], "0 year ago": [ - "this year" + "سږ کال", + "سږکال" ], "1 day ago": [ - "yesterday" + "پرون" ], "1 month ago": [ - "last month" + "تېره مياشت" ], "1 week ago": [ - "last week" + "تيره اونۍ", + "تېره اونۍ" ], "1 year ago": [ - "last year" + "تير کال", + "تېر کال", + "پروسږکال" ], "in 1 day": [ - "tomorrow" + "سبا" ], "in 1 month": [ - "next month" + "راتلونکې مياشت" ], "in 1 week": [ - "next week" + "راتلونکې اونۍ" ], "in 1 year": [ - "next year" + "راتلونکی کال", + "روتلونکی کال" ] }, - "locale_specific": {} + "relative-type-regex": { + "\\1 day ago": [ + "{0} ورځ مخکې", + "{0} ورځې مخکې" + ], + "\\1 hour ago": [ + "{0} ساعت مخکې", + "{0} ساعتونه مخکې" + ], + "\\1 minute ago": [ + "{0} دقيقه مخکې", + "{0} دقيقې مخکې" + ], + "\\1 month ago": [ + "{0} مياشت مخکې", + "{0} مياشتې مخکې" + ], + "\\1 second ago": [ + "{0} ثانيه مخکې", + "{0} ثانيه کې", + "{0} ثانيې مخکې" + ], + "\\1 week ago": [ + "{0} اونۍ مخکې" + ], + "\\1 year ago": [ + "{0} کال مخکې", + "{0} کاله مخکې" + ], + "in \\1 day": [ + "په {0} ورځ کې", + "په {0} ورځو کې" + ], + "in \\1 hour": [ + "په {0} ساعت کې", + "په {0} ساعتو کې" + ], + "in \\1 minute": [ + "په {0} دقيقه کې", + "په {0} دقيقو کې" + ], + "in \\1 month": [ + "په {0} مياشت کې", + "په {0} مياشتو کې" + ], + "in \\1 second": [ + "په {0} ثانيه کې", + "په {0} ثانيو کې" + ], + "in \\1 week": [ + "په {0} اونيو کې", + "په {0} اونۍ کې" + ], + "in \\1 year": [ + "په {0} کال کې", + "په {0} کالونو کې" + ] + }, + "locale_specific": { + "ps-PK": { + "name": "ps-PK", + "relative-type-regex": { + "\\1 year ago": [ + "{0} کال مخکے", + "{0} کاله مخکے" + ], + "in \\1 year": [ + "په {0} کال کے", + "په {0} کالونو کے" + ] + } + } + } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/pt.json b/dateparser_data/cldr_language_data/date_translation_data/pt.json index afb0132f1..05584c30b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/pt.json +++ b/dateparser_data/cldr_language_data/date_translation_data/pt.json @@ -98,15 +98,14 @@ ], "hour": [ "h", - "hora" + "hora", + "horas" ], "minute": [ - "m", "min", "minuto" ], "second": [ - "s", "seg", "segundo" ], @@ -169,7 +168,6 @@ ], "\\1 minute ago": [ "há {0} min", - "há {0} mins", "há {0} minuto", "há {0} minutos" ], @@ -202,7 +200,6 @@ ], "in \\1 minute": [ "em {0} min", - "em {0} mins", "em {0} minuto", "em {0} minutos" ], @@ -212,7 +209,6 @@ ], "in \\1 second": [ "em {0} seg", - "em {0} segs", "em {0} segundo", "em {0} segundos" ], @@ -252,6 +248,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -315,6 +314,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -378,6 +380,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -441,6 +446,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -504,6 +512,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -567,6 +578,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -630,6 +644,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -693,6 +710,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -756,6 +776,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -819,6 +842,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" @@ -882,6 +908,9 @@ "da tarde", "tarde" ], + "second": [ + "s" + ], "relative-type-regex": { "\\1 second ago": [ "há {0} s" diff --git a/dateparser_data/cldr_language_data/date_translation_data/qu.json b/dateparser_data/cldr_language_data/date_translation_data/qu.json index 6b58c6cae..0a42aa547 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/qu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/qu.json @@ -2,52 +2,52 @@ "name": "qu", "date_order": "DMY", "january": [ - "qul", - "qulla puquy" + "ene", + "enero" ], "february": [ - "hat", - "hatun puquy" + "feb", + "febrero" ], "march": [ - "pau", - "pauqar waray" + "mar", + "marzo" ], "april": [ - "ayr", - "ayriwa" + "abr", + "abril" ], "may": [ - "aym", - "aymuray" + "may", + "mayo" ], "june": [ - "int", - "inti raymi" + "jun", + "junio" ], "july": [ - "ant", - "anta sitwa" + "jul", + "julio" ], "august": [ - "qha", - "qhapaq sitwa" + "ago", + "agosto" ], "september": [ - "uma", - "uma raymi" + "set", + "setiembre" ], "october": [ - "kan", - "kantaray" + "oct", + "octubre" ], "november": [ - "aya", - "ayamarq'a" + "nov", + "noviembre" ], "december": [ - "kap", - "kapaq raymi" + "dic", + "diciembre" ], "monday": [ "lun", @@ -96,6 +96,7 @@ "day" ], "hour": [ + "hora", "hour" ], "minute": [ @@ -106,49 +107,49 @@ ], "relative-type": { "0 day ago": [ - "today" + "kunan punchaw" ], "0 hour ago": [ - "this hour" + "kay hora" ], "0 minute ago": [ - "this minute" + "kay minuto" ], "0 month ago": [ - "this month" + "kunan killa" ], "0 second ago": [ "now" ], "0 week ago": [ - "this week" + "kunan semana" ], "0 year ago": [ - "this year" + "kunan wata" ], "1 day ago": [ - "yesterday" + "qayna punchaw" ], "1 month ago": [ - "last month" + "qayna killa" ], "1 week ago": [ - "last week" + "qayna semana" ], "1 year ago": [ - "last year" + "qayna wata" ], "in 1 day": [ - "tomorrow" + "paqarin" ], "in 1 month": [ - "next month" + "hamuq killa" ], "in 1 week": [ - "next week" + "hamuq semana" ], "in 1 year": [ - "next year" + "hamuq wata" ] }, "locale_specific": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/rm.json b/dateparser_data/cldr_language_data/date_translation_data/rm.json index 69d1b68c5..35402b266 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/rm.json +++ b/dateparser_data/cldr_language_data/date_translation_data/rm.json @@ -2,47 +2,59 @@ "name": "rm", "date_order": "DMY", "january": [ + "da schaner", "schan", "schaner" ], "february": [ + "da favrer", "favr", "favrer" ], "march": [ + "da mars", "mars" ], "april": [ "avr", - "avrigl" + "avrigl", + "d'avrigl" ], "may": [ + "da matg", "matg" ], "june": [ + "da zercladur", "zercl", "zercladur" ], "july": [ + "da fanadur", "fan", "fanadur" ], "august": [ - "avust" + "avust", + "d'avust" ], "september": [ + "da settember", "sett", "settember" ], "october": [ + "d'october", "oct", "october" ], "november": [ + "da november", "nov", "november" ], "december": [ + "da december", "dec", "december" ], @@ -90,15 +102,19 @@ "emna" ], "day": [ - "tag" + "d", + "di" ], "hour": [ - "ura" + "ura", + "uras" ], "minute": [ + "min", "minuta" ], "second": [ + "s", "secunda" ], "relative-type": { @@ -121,7 +137,7 @@ "this week" ], "0 year ago": [ - "this year" + "quest onn" ], "1 day ago": [ "ier" @@ -133,7 +149,7 @@ "last week" ], "1 year ago": [ - "last year" + "l'onn passà" ], "in 1 day": [ "damaun" @@ -145,7 +161,7 @@ "next week" ], "in 1 year": [ - "next year" + "l'onn proxim" ] }, "locale_specific": {} diff --git a/dateparser_data/cldr_language_data/date_translation_data/rn.json b/dateparser_data/cldr_language_data/date_translation_data/rn.json index f2226ce37..dae88e0b8 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/rn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/rn.json @@ -96,6 +96,7 @@ "umusi" ], "hour": [ + "hr", "isaha" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ro.json b/dateparser_data/cldr_language_data/date_translation_data/ro.json index 41f9cc339..996d53fde 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ro.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ro.json @@ -96,6 +96,7 @@ ], "hour": [ "h", + "ore", "oră" ], "minute": [ @@ -125,6 +126,7 @@ "acum" ], "0 week ago": [ + "săpt aceasta", "săptămâna aceasta" ], "0 year ago": [ @@ -137,6 +139,7 @@ "luna trecută" ], "1 week ago": [ + "săpt trecută", "săptămâna trecută" ], "1 year ago": [ @@ -149,6 +152,7 @@ "luna viitoare" ], "in 1 week": [ + "săpt viitoare", "săptămâna viitoare" ], "in 1 year": [ @@ -158,8 +162,7 @@ "relative-type-regex": { "\\1 day ago": [ "acum {0} de zile", - "acum {0} zi", - "acum {0} zile" + "acum {0} zi" ], "\\1 hour ago": [ "acum {0} de ore", @@ -192,8 +195,7 @@ ], "in \\1 day": [ "peste {0} de zile", - "peste {0} zi", - "peste {0} zile" + "peste {0} zi" ], "in \\1 hour": [ "peste {0} de ore", @@ -222,7 +224,6 @@ ], "in \\1 year": [ "peste {0} an", - "peste {0} ani", "peste {0} de ani" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/rof.json b/dateparser_data/cldr_language_data/date_translation_data/rof.json index d13b18c97..859d73603 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/rof.json +++ b/dateparser_data/cldr_language_data/date_translation_data/rof.json @@ -84,6 +84,7 @@ "mfiri" ], "hour": [ + "hr", "isaa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ru.json b/dateparser_data/cldr_language_data/date_translation_data/ru.json index 8994aaa86..fc6130eb3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ru.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ru.json @@ -89,10 +89,10 @@ "вс" ], "am": [ - "дп" + "am" ], "pm": [ - "пп" + "pm" ], "year": [ "г", @@ -112,7 +112,8 @@ ], "hour": [ "ч", - "час" + "час", + "часы" ], "minute": [ "мин", @@ -128,51 +129,68 @@ "сегодня" ], "0 hour ago": [ - "в этом часе" + "в этот час" ], "0 minute ago": [ "в эту минуту" ], "0 month ago": [ + "в эт мес", + "в этом мес", "в этом месяце" ], "0 second ago": [ "сейчас" ], "0 week ago": [ + "на эт нед", + "на этой нед", "на этой неделе" ], "0 year ago": [ + "в эт г", + "в этом г", "в этом году" ], "1 day ago": [ "вчера" ], "1 month ago": [ + "в пр мес", + "в прошлом мес", "в прошлом месяце" ], "1 week ago": [ + "на пр нед", + "на прошлой нед", "на прошлой неделе" ], "1 year ago": [ + "в пр г", + "в прошлом г", "в прошлом году" ], "in 1 day": [ "завтра" ], "in 1 month": [ + "в след мес", + "в следующем мес", "в следующем месяце" ], "in 1 week": [ + "на след нед", + "на следующей нед", "на следующей неделе" ], "in 1 year": [ + "в сл г", + "в след г", "в следующем году" ] }, "relative-type-regex": { "\\1 day ago": [ - "{0} д назад", "{0} день назад", "{0} дн назад", "{0} дня назад" @@ -208,7 +226,6 @@ "{0} года назад" ], "in \\1 day": [ - "через {0} д", "через {0} день", "через {0} дн", "через {0} дня" @@ -258,13 +275,7 @@ "name": "ru-MD" }, "ru-UA": { - "name": "ru-UA", - "am": [ - "am" - ], - "pm": [ - "pm" - ] + "name": "ru-UA" } } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/rw.json b/dateparser_data/cldr_language_data/date_translation_data/rw.json index 8b4dda315..df9c8f795 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/rw.json +++ b/dateparser_data/cldr_language_data/date_translation_data/rw.json @@ -19,7 +19,7 @@ ], "may": [ "gic", - "gicuransi" + "gicurasi" ], "june": [ "kam", @@ -96,7 +96,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/rwk.json b/dateparser_data/cldr_language_data/date_translation_data/rwk.json index 21b5e41a7..44a4766e7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/rwk.json +++ b/dateparser_data/cldr_language_data/date_translation_data/rwk.json @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/saq.json b/dateparser_data/cldr_language_data/date_translation_data/saq.json index a84ade947..415843f4e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/saq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/saq.json @@ -96,6 +96,7 @@ "mpari" ], "hour": [ + "hr", "saai" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/sbp.json b/dateparser_data/cldr_language_data/date_translation_data/sbp.json index acd44b6cc..322243561 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sbp.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sbp.json @@ -96,6 +96,7 @@ "lusiku" ], "hour": [ + "hr", "ilisala" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/se.json b/dateparser_data/cldr_language_data/date_translation_data/se.json index 95e57a715..85604aed5 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/se.json +++ b/dateparser_data/cldr_language_data/date_translation_data/se.json @@ -100,7 +100,8 @@ "beaivi" ], "hour": [ - "diibmu" + "diibmu", + "diibmur" ], "minute": [ "minuhtta" @@ -214,47 +215,151 @@ "locale_specific": { "se-FI": { "name": "se-FI", + "date_order": "DMY", + "april": [ + "cuoŋ" + ], "monday": [ - "vuossárgga" + "má", + "mánnodat" ], "tuesday": [ - "maŋŋebárgga" + "di", + "disdat" ], "wednesday": [ - "gaskavahku" + "ga" ], "thursday": [ - "duorastaga" + "du", + "duorastat" ], "friday": [ - "bearjadaga" + "be" ], "saturday": [ - "lávvardaga" + "lá", + "lávvordat" + ], + "sunday": [ + "so" ], "year": [ "j", "jahki" ], + "month": [ + "m" + ], "week": [ + "v(k)", "vahkku" ], + "day": [ + "b" + ], + "hour": [ + "dmu" + ], + "minute": [ + "min" + ], + "second": [ + "sek" + ], "relative-type": { + "0 hour ago": [ + "dán diimmu" + ], + "0 minute ago": [ + "dán minuhta" + ], + "0 month ago": [ + "dán mánu" + ], + "0 second ago": [ + "dál" + ], + "0 week ago": [ + "dán vahku" + ], "0 year ago": [ "dán jagi" ], + "1 month ago": [ + "mannan mánu" + ], + "1 week ago": [ + "mannan vahku" + ], "1 year ago": [ - "mannan jagi" + "diibmá" + ], + "in 1 month": [ + "boahtte mánu" + ], + "in 1 week": [ + "boahtte vahku" ], "in 1 year": [ "boahtte jagi" ] }, "relative-type-regex": { + "\\1 day ago": [ + "{0} beaivve dás ovdal" + ], + "\\1 hour ago": [ + "{0} diibmu áigi", + "{0} diimmu áigi", + "{0} dmu áigi" + ], + "\\1 minute ago": [ + "{0} min áigi", + "{0} minuhta áigi", + "{0} minuhtta áigi" + ], + "\\1 month ago": [ + "{0} mánnu dás ovdal", + "{0} mánu dás ovdal" + ], + "\\1 second ago": [ + "{0} sek áigi", + "{0} sekunda áigi", + "{0} sekundda áigi" + ], + "\\1 week ago": [ + "{0} vahkku dás ovdal", + "{0} vahku dás ovdal" + ], "\\1 year ago": [ - "{0} jagi árat" + "{0} j dás ovdal", + "{0} jagi dás ovdal" + ], + "in \\1 day": [ + "{0} beaivve siste" + ], + "in \\1 hour": [ + "{0} diimmu siste", + "{0} dmu siste" + ], + "in \\1 minute": [ + "{0} min siste", + "{0} minuhta siste" + ], + "in \\1 month": [ + "{0} mánu geahčen", + "{0} mánu siste" + ], + "in \\1 second": [ + "{0} sek siste", + "{0} sekundda siste" + ], + "in \\1 week": [ + "{0} vahku geahčen" ], "in \\1 year": [ + "{0} j siste", "{0} jagi siste" ] } diff --git a/dateparser_data/cldr_language_data/date_translation_data/seh.json b/dateparser_data/cldr_language_data/date_translation_data/seh.json index f1792f055..dfa1f8ac7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/seh.json +++ b/dateparser_data/cldr_language_data/date_translation_data/seh.json @@ -96,7 +96,8 @@ "ntsiku" ], "hour": [ - "hora" + "hora", + "hr" ], "minute": [ "minuto" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ses.json b/dateparser_data/cldr_language_data/date_translation_data/ses.json index f935764d8..84b55e215 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ses.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ses.json @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser_data/cldr_language_data/date_translation_data/sg.json b/dateparser_data/cldr_language_data/date_translation_data/sg.json index 52cc1c08b..3b5a31060 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sg.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sg.json @@ -96,6 +96,7 @@ "lâ" ], "hour": [ + "hr", "ngbonga" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/shi-Latn.json b/dateparser_data/cldr_language_data/date_translation_data/shi-Latn.json index 61c968311..00ad2c008 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/shi-Latn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/shi-Latn.json @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tasragt" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/shi-Tfng.json b/dateparser_data/cldr_language_data/date_translation_data/shi-Tfng.json index 22b1473c0..f0d3b2f0b 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/shi-Tfng.json +++ b/dateparser_data/cldr_language_data/date_translation_data/shi-Tfng.json @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/shi.json b/dateparser_data/cldr_language_data/date_translation_data/shi.json index 5124c2d72..8888bf0b7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/shi.json +++ b/dateparser_data/cldr_language_data/date_translation_data/shi.json @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/si.json b/dateparser_data/cldr_language_data/date_translation_data/si.json index 7e7194dc5..3162d529a 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/si.json +++ b/dateparser_data/cldr_language_data/date_translation_data/si.json @@ -92,16 +92,13 @@ "දිනය" ], "hour": [ - "පැ", "පැය" ], "minute": [ - "මි", "මිනි", "මිනිත්තුව" ], "second": [ - "ත", "තත්", "තත්පරය" ], diff --git a/dateparser_data/cldr_language_data/date_translation_data/sk.json b/dateparser_data/cldr_language_data/date_translation_data/sk.json index b8b883979..bf184ecc3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sk.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sk.json @@ -110,7 +110,8 @@ ], "hour": [ "h", - "hodina" + "hodina", + "hodiny" ], "minute": [ "min", @@ -131,12 +132,14 @@ "v tejto minúte" ], "0 month ago": [ + "tento mes", "tento mesiac" ], "0 second ago": [ "teraz" ], "0 week ago": [ + "tento týž", "tento týždeň" ], "0 year ago": [ @@ -146,9 +149,11 @@ "včera" ], "1 month ago": [ + "minulý mes", "minulý mesiac" ], "1 week ago": [ + "minulý týž", "minulý týždeň" ], "1 year ago": [ @@ -158,9 +163,11 @@ "zajtra" ], "in 1 month": [ + "budúci mes", "budúci mesiac" ], "in 1 week": [ + "budúci týž", "budúci týždeň" ], "in 1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/sl.json b/dateparser_data/cldr_language_data/date_translation_data/sl.json index 77a66432d..d2cdef9a3 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sl.json @@ -100,7 +100,8 @@ ], "hour": [ "h", - "ura" + "ura", + "ure" ], "minute": [ "min", @@ -122,12 +123,14 @@ "to minuto" ], "0 month ago": [ + "ta mes", "ta mesec" ], "0 second ago": [ "zdaj" ], "0 week ago": [ + "ta ted", "ta teden" ], "0 year ago": [ @@ -137,9 +140,13 @@ "včeraj" ], "1 month ago": [ + "prej mes", + "prejšnji mes", "prejšnji mesec" ], "1 week ago": [ + "prej ted", + "prejšnji ted", "prejšnji teden" ], "1 year ago": [ @@ -149,9 +156,13 @@ "jutri" ], "in 1 month": [ + "nasl mes", + "naslednji mes", "naslednji mesec" ], "in 1 week": [ + "nasl ted", + "naslednji ted", "naslednji teden" ], "in 1 year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/smn.json b/dateparser_data/cldr_language_data/date_translation_data/smn.json index debf7b9b4..8eaadfd75 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/smn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/smn.json @@ -103,7 +103,8 @@ "day" ], "hour": [ - "hour" + "hour", + "tiijmeh" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/sn.json b/dateparser_data/cldr_language_data/date_translation_data/sn.json index f306903cf..b1e28d11d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sn.json @@ -96,7 +96,8 @@ "zuva" ], "hour": [ - "awa" + "awa", + "hr" ], "minute": [ "mineti" diff --git a/dateparser_data/cldr_language_data/date_translation_data/so.json b/dateparser_data/cldr_language_data/date_translation_data/so.json index 850727fc2..d7463da9e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/so.json +++ b/dateparser_data/cldr_language_data/date_translation_data/so.json @@ -3,152 +3,244 @@ "date_order": "DMY", "january": [ "bisha koobaad", - "kob" + "jan", + "jannaayo" ], "february": [ "bisha labaad", - "lab" + "feb", + "febraayo" ], "march": [ "bisha saddexaad", - "sad" + "maarso", + "mar" ], "april": [ - "afr", + "abr", + "abriil", "bisha afraad" ], "may": [ "bisha shanaad", - "sha" + "may" ], "june": [ "bisha lixaad", - "lix" + "jun", + "juun" ], "july": [ "bisha todobaad", - "tod" + "lul", + "luuliyo" ], "august": [ "bisha sideedaad", - "sid" + "ogosto", + "ogs" ], "september": [ "bisha sagaalaad", - "sag" + "seb", + "sebteembar" ], "october": [ "bisha tobnaad", - "tob" + "okt", + "oktoobar" ], "november": [ "bisha kow iyo tobnaad", - "kit" + "nof", + "noofeembar" ], "december": [ "bisha laba iyo tobnaad", - "lit" + "dis", + "diseembar" ], "monday": [ "isn", "isniin" ], "tuesday": [ - "tal", - "talaado" + "talaado", + "tldo" ], "wednesday": [ - "arb", - "arbaco" + "arbaco", + "arbc" ], "thursday": [ - "kha", - "khamiis" + "khamiis", + "khms" ], "friday": [ - "jim", - "jimco" + "jimco", + "jmc" ], "saturday": [ - "sab", - "sabti" + "sabti", + "sbti" ], "sunday": [ "axad", "axd" ], "am": [ - "sn" + "am", + "gh" ], "pm": [ - "gn" + "gd" ], "year": [ - "year" + "sannad", + "snd" ], "month": [ - "month" + "bil" ], "week": [ - "week" + "tdbd", + "toddobaad" ], "day": [ - "day" + "maalin", + "mln" ], "hour": [ - "hour" + "saacad", + "saacado", + "scd" ], "minute": [ - "minute" + "daqiiqad", + "dqqd" ], "second": [ - "second" + "ilbiriqsi", + "ilbrqsi" ], "relative-type": { "0 day ago": [ "maanta" ], "0 hour ago": [ - "this hour" + "saacadan" ], "0 minute ago": [ - "this minute" + "daqiiqadan" ], "0 month ago": [ - "this month" + "bishan" ], "0 second ago": [ - "now" + "imika", + "iminka" ], "0 week ago": [ - "this week" + "toddobaadkan", + "usbuucan" ], "0 year ago": [ - "this year" + "sannadkan" ], "1 day ago": [ "shalay" ], "1 month ago": [ - "last month" + "bishii hore" ], "1 week ago": [ - "last week" + "toddobaadkii hore" ], "1 year ago": [ - "last year" + "sannadkii hore", + "sannadkii la soo dhaafay" ], "in 1 day": [ "berri" ], "in 1 month": [ - "next month" + "bisha danbe" ], "in 1 week": [ - "next week" + "toddobaadka danbe" ], "in 1 year": [ - "next year" + "sannadka danbe", + "sannadka xiga" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "{0} maalin kahor", + "{0} maalmood kahor", + "{0} mlmd khr", + "{0} mln khr" + ], + "\\1 hour ago": [ + "{0} saacad kahor", + "{0} saacadood kahor", + "{0} scd khr" + ], + "\\1 minute ago": [ + "{0} daqiiqad kahor", + "{0} daqiiqadood kahor", + "{0} dqqd khr" + ], + "\\1 month ago": [ + "{0} bil kahor", + "{0} bil khr", + "{0} bilood kahor" + ], + "\\1 second ago": [ + "{0} ilbiriqsi kahor", + "{0} ilbrqsi khr" + ], + "\\1 week ago": [ + "{0} tdbd khr", + "{0} toddobaad kahor" + ], + "\\1 year ago": [ + "{0} sannad kahor", + "{0} sannadood kahor", + "{0} snd khr" + ], + "in \\1 day": [ + "{0} maalin", + "{0} maalmood", + "{0} mlmd", + "{0} mln" + ], + "in \\1 hour": [ + "{0} saacad", + "{0} saacadood", + "{0} scd" + ], + "in \\1 minute": [ + "{0} daqiidadood", + "{0} daqiiqad", + "{0} dqqd" + ], + "in \\1 month": [ + "{0} bil", + "{0} bilood" + ], + "in \\1 second": [ + "{0} ilbiriqsi", + "{0} ilbrqsi" + ], + "in \\1 week": [ + "{0} tdbd", + "{0} toddobaad" + ], + "in \\1 year": [ + "{0} sannad", + "{0} sannadood", + "{0} snd" ] }, "locale_specific": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/sq.json b/dateparser_data/cldr_language_data/date_translation_data/sq.json index 5ac218ed4..655499e53 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sq.json @@ -25,11 +25,11 @@ "qershor" ], "july": [ - "kor", + "korr", "korrik" ], "august": [ - "gsh", + "gush", "gusht" ], "september": [ @@ -78,10 +78,12 @@ ], "am": [ "e paradites", - "paradite" + "paradite", + "pd" ], "pm": [ "e pasdites", + "md", "pasdite" ], "year": [ @@ -127,7 +129,8 @@ "këtë javë" ], "0 year ago": [ - "këtë vit" + "këtë vit", + "sivjet" ], "1 day ago": [ "dje" @@ -139,7 +142,8 @@ "javën e kaluar" ], "1 year ago": [ - "vitin e kaluar" + "vitin e kaluar", + "vjet" ], "in 1 day": [ "nesër" @@ -151,6 +155,7 @@ "javën e ardhshme" ], "in 1 year": [ + "mot", "vitin e ardhshëm" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/sr-Cyrl.json b/dateparser_data/cldr_language_data/date_translation_data/sr-Cyrl.json index b894802e0..36d465c4e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sr-Cyrl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sr-Cyrl.json @@ -75,10 +75,10 @@ "недеља" ], "am": [ - "пре подне" + "am" ], "pm": [ - "по подне" + "pm" ], "year": [ "г", @@ -86,12 +86,10 @@ "година" ], "month": [ - "м", "мес", "месец" ], "week": [ - "н", "нед", "недеља" ], @@ -101,6 +99,7 @@ ], "hour": [ "сат", + "сати", "ч" ], "minute": [ @@ -123,39 +122,54 @@ "овог минута" ], "0 month ago": [ + "овог мес", "овог месеца" ], "0 second ago": [ "сада" ], "0 week ago": [ + "ове н", + "ове нед", "ове недеље" ], "0 year ago": [ + "ове г", + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ + "прошлог мес", "прошлог месеца" ], "1 week ago": [ + "прошле н", + "прошле нед", "прошле недеље" ], "1 year ago": [ + "прошле г", + "прошле год", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ + "следећег мес", "следећег месеца" ], "in 1 week": [ + "следеће н", + "следеће нед", "следеће недеље" ], "in 1 year": [ + "следеће г", + "следеће год", "следеће године" ] }, @@ -240,14 +254,11 @@ "locale_specific": { "sr-Cyrl-BA": { "name": "sr-Cyrl-BA", - "september": [ - "септ" - ], - "tuesday": [ - "ут" + "monday": [ + "понедјељак" ], "wednesday": [ - "ср", + "сри", "сриједа" ], "sunday": [ @@ -255,18 +266,110 @@ ], "am": [ "прије подне" - ] + ], + "pm": [ + "по подне" + ], + "month": [ + "мјес", + "мјесец" + ], + "week": [ + "седм", + "седмица" + ], + "relative-type": { + "0 month ago": [ + "овог мјес", + "овог мјесеца" + ], + "0 week ago": [ + "ове с", + "ове седм", + "ове седмице" + ], + "1 month ago": [ + "прошлог мјес", + "прошлог мјесеца" + ], + "1 week ago": [ + "прошле с", + "прошле седм", + "прошле седмице" + ], + "in 1 month": [ + "сљедећег м", + "сљедећег мјес", + "сљедећег мјесеца" + ], + "in 1 week": [ + "сљедеће с", + "сљедеће седм", + "сљедеће седмице" + ], + "in 1 year": [ + "сљедеће г", + "сљедеће год", + "сљедеће године" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "прије {0} д", + "прије {0} дана" + ], + "\\1 hour ago": [ + "прије {0} сата", + "прије {0} сати", + "прије {0} ч" + ], + "\\1 minute ago": [ + "прије {0} мин", + "прије {0} минута" + ], + "\\1 month ago": [ + "прије {0} м", + "прије {0} мјес", + "прије {0} мјесеца", + "прије {0} мјесеци" + ], + "\\1 second ago": [ + "прије {0} с", + "прије {0} сек", + "прије {0} секунде", + "прије {0} секунди" + ], + "\\1 week ago": [ + "прије {0} с", + "прије {0} седм", + "прије {0} седмица", + "прије {0} седмице" + ], + "\\1 year ago": [ + "прије {0} г", + "прије {0} год", + "прије {0} година", + "прије {0} године" + ], + "in \\1 month": [ + "за {0} мјес", + "за {0} мјесец", + "за {0} мјесеци" + ], + "in \\1 week": [ + "за {0} с", + "за {0} седм", + "за {0} седмица", + "за {0} седмицу" + ] + } }, "sr-Cyrl-ME": { "name": "sr-Cyrl-ME", "september": [ "септ" ], - "tuesday": [ - "ут" - ], "wednesday": [ - "ср", "сриједа" ], "sunday": [ @@ -274,18 +377,15 @@ ], "am": [ "прије подне" + ], + "pm": [ + "по подне" ] }, "sr-Cyrl-XK": { "name": "sr-Cyrl-XK", "september": [ "септ" - ], - "tuesday": [ - "ут" - ], - "wednesday": [ - "ср" ] } } diff --git a/dateparser_data/cldr_language_data/date_translation_data/sr-Latn.json b/dateparser_data/cldr_language_data/date_translation_data/sr-Latn.json index 74ce8fd02..46321b6e1 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sr-Latn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sr-Latn.json @@ -75,10 +75,10 @@ "nedelja" ], "am": [ - "pre podne" + "am" ], "pm": [ - "po podne" + "pm" ], "year": [ "g", @@ -86,12 +86,10 @@ "godina" ], "month": [ - "m", "mes", "mesec" ], "week": [ - "n", "ned", "nedelja" ], @@ -101,6 +99,7 @@ ], "hour": [ "sat", + "sati", "č" ], "minute": [ @@ -123,39 +122,54 @@ "ovog minuta" ], "0 month ago": [ + "ovog mes", "ovog meseca" ], "0 second ago": [ "sada" ], "0 week ago": [ + "ove n", + "ove ned", "ove nedelje" ], "0 year ago": [ + "ove g", + "ove god", "ove godine" ], "1 day ago": [ "juče" ], "1 month ago": [ + "prošlog mes", "prošlog meseca" ], "1 week ago": [ + "prošle n", + "prošle ned", "prošle nedelje" ], "1 year ago": [ + "prošle g", + "prošle god", "prošle godine" ], "in 1 day": [ "sutra" ], "in 1 month": [ + "sledećeg mes", "sledećeg meseca" ], "in 1 week": [ + "sledeće n", + "sledeće ned", "sledeće nedelje" ], "in 1 year": [ + "sledeće g", + "sledeće god", "sledeće godine" ] }, @@ -240,14 +254,11 @@ "locale_specific": { "sr-Latn-BA": { "name": "sr-Latn-BA", - "september": [ - "sept" - ], - "tuesday": [ - "ut" + "monday": [ + "ponedjeljak" ], "wednesday": [ - "sr", + "sri", "srijeda" ], "sunday": [ @@ -255,18 +266,110 @@ ], "am": [ "prije podne" - ] + ], + "pm": [ + "po podne" + ], + "month": [ + "mjes", + "mjesec" + ], + "week": [ + "sedm", + "sedmica" + ], + "relative-type": { + "0 month ago": [ + "ovog mjes", + "ovog mjeseca" + ], + "0 week ago": [ + "ove s", + "ove sedm", + "ove sedmice" + ], + "1 month ago": [ + "prošlog mjes", + "prošlog mjeseca" + ], + "1 week ago": [ + "prošle s", + "prošle sedm", + "prošle sedmice" + ], + "in 1 month": [ + "sljedećeg m", + "sljedećeg mjes", + "sljedećeg mjeseca" + ], + "in 1 week": [ + "sljedeće s", + "sljedeće sedm", + "sljedeće sedmice" + ], + "in 1 year": [ + "sljedeće g", + "sljedeće god", + "sljedeće godine" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "prije {0} d", + "prije {0} dana" + ], + "\\1 hour ago": [ + "prije {0} sata", + "prije {0} sati", + "prije {0} č" + ], + "\\1 minute ago": [ + "prije {0} min", + "prije {0} minuta" + ], + "\\1 month ago": [ + "prije {0} m", + "prije {0} mjes", + "prije {0} mjeseca", + "prije {0} mjeseci" + ], + "\\1 second ago": [ + "prije {0} s", + "prije {0} sek", + "prije {0} sekunde", + "prije {0} sekundi" + ], + "\\1 week ago": [ + "prije {0} s", + "prije {0} sedm", + "prije {0} sedmica", + "prije {0} sedmice" + ], + "\\1 year ago": [ + "prije {0} g", + "prije {0} god", + "prije {0} godina", + "prije {0} godine" + ], + "in \\1 month": [ + "za {0} mjes", + "za {0} mjesec", + "za {0} mjeseci" + ], + "in \\1 week": [ + "za {0} s", + "za {0} sedm", + "za {0} sedmica", + "za {0} sedmicu" + ] + } }, "sr-Latn-ME": { "name": "sr-Latn-ME", "september": [ "sept" ], - "tuesday": [ - "ut" - ], "wednesday": [ - "sr", "srijeda" ], "sunday": [ @@ -274,18 +377,15 @@ ], "am": [ "prije podne" + ], + "pm": [ + "po podne" ] }, "sr-Latn-XK": { "name": "sr-Latn-XK", "september": [ "sept" - ], - "tuesday": [ - "ut" - ], - "wednesday": [ - "sr" ] } } diff --git a/dateparser_data/cldr_language_data/date_translation_data/sr.json b/dateparser_data/cldr_language_data/date_translation_data/sr.json index 2ce5041b7..0a0b444f2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sr.json @@ -75,10 +75,10 @@ "недеља" ], "am": [ - "пре подне" + "am" ], "pm": [ - "по подне" + "pm" ], "year": [ "г", @@ -86,12 +86,10 @@ "година" ], "month": [ - "м", "мес", "месец" ], "week": [ - "н", "нед", "недеља" ], @@ -101,6 +99,7 @@ ], "hour": [ "сат", + "сати", "ч" ], "minute": [ @@ -123,39 +122,54 @@ "овог минута" ], "0 month ago": [ + "овог мес", "овог месеца" ], "0 second ago": [ "сада" ], "0 week ago": [ + "ове н", + "ове нед", "ове недеље" ], "0 year ago": [ + "ове г", + "ове год", "ове године" ], "1 day ago": [ "јуче" ], "1 month ago": [ + "прошлог мес", "прошлог месеца" ], "1 week ago": [ + "прошле н", + "прошле нед", "прошле недеље" ], "1 year ago": [ + "прошле г", + "прошле год", "прошле године" ], "in 1 day": [ "сутра" ], "in 1 month": [ + "следећег мес", "следећег месеца" ], "in 1 week": [ + "следеће н", + "следеће нед", "следеће недеље" ], "in 1 year": [ + "следеће г", + "следеће год", "следеће године" ] }, diff --git a/dateparser_data/cldr_language_data/date_translation_data/sv.json b/dateparser_data/cldr_language_data/date_translation_data/sv.json index 89d971787..89dbd3c23 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sv.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sv.json @@ -99,6 +99,7 @@ "hour": [ "h", "tim", + "timmar", "timme" ], "minute": [ @@ -113,7 +114,8 @@ ], "relative-type": { "0 day ago": [ - "i dag" + "i dag", + "idag" ], "0 hour ago": [ "denna timme" @@ -122,8 +124,8 @@ "denna minut" ], "0 month ago": [ - "denna mån", - "denna månad" + "den här månaden", + "denna mån" ], "0 second ago": [ "nu" @@ -136,7 +138,8 @@ "i år" ], "1 day ago": [ - "i går" + "i går", + "igår" ], "1 month ago": [ "förra mån", @@ -150,7 +153,8 @@ "i fjol" ], "in 1 day": [ - "i morgon" + "i morgon", + "imorgon" ], "in 1 month": [ "nästa mån", @@ -178,19 +182,19 @@ "−{0} h" ], "\\1 minute ago": [ - "för {0} min sedan", + "för {0} min sen", "för {0} minut sedan", "för {0} minuter sedan", "−{0} min" ], "\\1 month ago": [ - "för {0} mån sedan", + "för {0} mån sen", "för {0} månad sedan", "för {0} månader sedan", "−{0} mån" ], "\\1 second ago": [ - "för {0} sek sedan", + "för {0} s sen", "för {0} sekund sedan", "för {0} sekunder sedan", "−{0} s" @@ -203,6 +207,7 @@ ], "\\1 year ago": [ "för {0} år sedan", + "för {0} år sen", "−{0} år" ], "in \\1 day": [ @@ -244,8 +249,7 @@ "name": "sv-AX" }, "sv-FI": { - "name": "sv-FI", - "date_order": "DMY" + "name": "sv-FI" } } } \ No newline at end of file diff --git a/dateparser_data/cldr_language_data/date_translation_data/sw.json b/dateparser_data/cldr_language_data/date_translation_data/sw.json index 760d8a5f6..27b3bc67e 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/sw.json +++ b/dateparser_data/cldr_language_data/date_translation_data/sw.json @@ -70,11 +70,9 @@ "jumapili" ], "am": [ - "am", - "asubuhi" + "am" ], "pm": [ - "mchana", "pm" ], "year": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ta.json b/dateparser_data/cldr_language_data/date_translation_data/ta.json index cf3692fb4..214f78241 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ta.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ta.json @@ -74,6 +74,7 @@ "ஞாயிறு" ], "am": [ + "am", "முற்பகல்" ], "pm": [ @@ -98,7 +99,8 @@ ], "hour": [ "ம", - "மணி" + "மணி", + "மணிநேரங்கள்" ], "minute": [ "நிமி", @@ -189,7 +191,7 @@ "{0} வா முன்", "{0} வார முன்", "{0} வாரங்களுக்கு முன்", - "{0} வாரத்திற்கு முன்பு" + "{0} வாரத்திற்கு முன்" ], "\\1 year ago": [ "{0} ஆ முன்", diff --git a/dateparser_data/cldr_language_data/date_translation_data/te.json b/dateparser_data/cldr_language_data/date_translation_data/te.json index cd42b1c92..5383409fd 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/te.json +++ b/dateparser_data/cldr_language_data/date_translation_data/te.json @@ -92,15 +92,15 @@ "వారము" ], "day": [ - "ది", - "దినం" + "దినం", + "రోజు" ], "hour": [ "గం", - "గంట" + "గంట", + "గంటలు" ], "minute": [ - "ని", "నిమి", "నిమిషము" ], @@ -128,6 +128,8 @@ "ఈ వారం" ], "0 year ago": [ + "ఈ సం", + "ఈ సంవ", "ఈ సంవత్సరం" ], "1 day ago": [ @@ -140,6 +142,8 @@ "గత వారం" ], "1 year ago": [ + "గత సం", + "గత సంవ", "గత సంవత్సరం" ], "in 1 day": [ @@ -152,6 +156,8 @@ "తదుపరి వారం" ], "in 1 year": [ + "తదుపరి సం", + "తదుపరి సంవ", "తదుపరి సంవత్సరం" ] }, @@ -209,7 +215,8 @@ "in \\1 second": [ "{0} సెక లో", "{0} సెకనులో", - "{0} సెకన్లలో" + "{0} సెకన్లలో", + "{0} సెకలో" ], "in \\1 week": [ "{0} వారంలో", @@ -217,6 +224,7 @@ ], "in \\1 year": [ "{0} సంలో", + "{0} సంల్లో", "{0} సంవత్సరంలో", "{0} సంవత్సరాల్లో" ] diff --git a/dateparser_data/cldr_language_data/date_translation_data/teo.json b/dateparser_data/cldr_language_data/date_translation_data/teo.json index def3c9aa7..746fa5e16 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/teo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/teo.json @@ -96,7 +96,8 @@ "aparan" ], "hour": [ - "esaa" + "esaa", + "hr" ], "minute": [ "idakika" diff --git a/dateparser_data/cldr_language_data/date_translation_data/th.json b/dateparser_data/cldr_language_data/date_translation_data/th.json index b0e2e20b9..c46029fb2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/th.json +++ b/dateparser_data/cldr_language_data/date_translation_data/th.json @@ -78,9 +78,11 @@ "อา" ], "am": [ + "am", "ก่อนเที่ยง" ], "pm": [ + "pm", "หลังเที่ยง" ], "year": [ @@ -100,7 +102,6 @@ "ชั่วโมง" ], "minute": [ - "น", "นาที" ], "second": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ti.json b/dateparser_data/cldr_language_data/date_translation_data/ti.json index 11ea5f0ee..a519add75 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ti.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ti.json @@ -52,7 +52,6 @@ "ሰኑይ" ], "tuesday": [ - "ሠሉስ", "ሰሉ", "ሰሉስ" ], @@ -62,8 +61,7 @@ ], "thursday": [ "ሓሙ", - "ሓሙስ", - "ኃሙስ" + "ሓሙስ" ], "friday": [ "ዓር", @@ -78,77 +76,124 @@ "ሰንበት" ], "am": [ - "ንጉሆ ሰዓተ" + "ቅቀ" ], "pm": [ - "ድሕር ሰዓት" + "ድቀ" ], "year": [ - "year" + "ዓመት" ], "month": [ - "month" + "ወርሒ" ], "week": [ - "week" + "ሰሙን" ], "day": [ - "day" + "መዓልቲ" ], "hour": [ - "hour" + "hr", + "ሰዓት" ], "minute": [ - "minute" + "ደቒ", + "ደቒቕ" ], "second": [ - "second" + "ካልኢት" ], "relative-type": { "0 day ago": [ - "today" + "ሎሚ" ], "0 hour ago": [ - "this hour" + "ኣብዚ ሰዓት" ], "0 minute ago": [ - "this minute" + "ኣብዚ ደቒቕ" ], "0 month ago": [ - "this month" + "ህሉው ወርሒ" ], "0 second ago": [ - "now" + "ሕጂ" ], "0 week ago": [ - "this week" + "ህሉው ሰሙን" ], "0 year ago": [ - "this year" + "ሎሚ ዓመት" ], "1 day ago": [ - "yesterday" + "ትማሊ" ], "1 month ago": [ - "last month" + "ዝሓለፈ ወርሒ" ], "1 week ago": [ - "last week" + "ዝሓለፈ ሰሙን" ], "1 year ago": [ - "last year" + "ዓሚ" ], "in 1 day": [ - "tomorrow" + "ጽባሕ" ], "in 1 month": [ - "next month" + "ዝመጽእ ወርሒ" ], "in 1 week": [ - "next week" + "ዝመጽእ ሰሙን" ], "in 1 year": [ - "next year" + "ንዓመታ" + ] + }, + "relative-type-regex": { + "\\1 day ago": [ + "ቅድሚ {0} መዓልቲ", + "ኣብ {0} መዓልቲ" + ], + "\\1 hour ago": [ + "ቅድሚ {0} ሰዓት" + ], + "\\1 minute ago": [ + "ቅድሚ {0} ደቒቕ" + ], + "\\1 month ago": [ + "ቅድሚ {0} ወርሒ" + ], + "\\1 second ago": [ + "ቅድሚ {0} ካልኢት" + ], + "\\1 week ago": [ + "ቅድሚ {0} ሰሙን" + ], + "\\1 year ago": [ + "ቅድሚ {0} ዓ" + ], + "in \\1 day": [ + "ኣብ {0} መዓልቲ" + ], + "in \\1 hour": [ + "ኣብ {0} ሰዓት" + ], + "in \\1 minute": [ + "ኣብ {0} ደቒቕ" + ], + "in \\1 month": [ + "ኣብ {0} ወርሒ" + ], + "in \\1 second": [ + "ኣብ {0} ካልኢት" + ], + "in \\1 week": [ + "ኣብ {0} ሰሙን" + ], + "in \\1 year": [ + "ኣብ {0} ዓ" ] }, "locale_specific": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/to.json b/dateparser_data/cldr_language_data/date_translation_data/to.json index 65b8a6029..bb0ac0a4d 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/to.json +++ b/dateparser_data/cldr_language_data/date_translation_data/to.json @@ -33,8 +33,9 @@ "'aokosi" ], "september": [ - "sep", - "sepitema" + "sepitema", + "sēp", + "sēpitema" ], "october": [ "'oka", @@ -77,81 +78,98 @@ "sāpate" ], "am": [ - "am", "hengihengi", "hh" ], "pm": [ "ea", - "efiafi", - "pm" + "efiafi" ], "year": [ + "t", "ta'u" ], "month": [ + "mh", "māhina" ], "week": [ + "ui", "uike" ], "day": [ + "'a", "'aho" ], "hour": [ + "h", "houa" ], "minute": [ + "m", "miniti" ], "second": [ + "s", "sekoni" ], "relative-type": { "0 day ago": [ - "'ahó ni" + "'ahó ni", + "'ani" ], "0 hour ago": [ - "this hour" + "ko e houa 'eni" ], "0 minute ago": [ - "this minute" + "ko e miniti 'eni" ], "0 month ago": [ + "mhni", "māhiná ni" ], "0 second ago": [ "taimí ni" ], "0 week ago": [ - "uiké ni" + "uiké ni", + "uini" ], "0 year ago": [ - "ta'ú ni" + "ta'ú ni", + "tni" ], "1 day ago": [ + "'ane", "'aneafi" ], "1 month ago": [ + "mh'osi", "māhina kuo'osi" ], "1 week ago": [ + "ui'osi", "uike kuo'osi" ], "1 year ago": [ + "t'osi", "ta'u kuo'osi" ], "in 1 day": [ + "'apo", "'apongipongi" ], "in 1 month": [ + "mhha'u", "māhina kaha'u" ], "in 1 week": [ + "uiha'u", "uike kaha'u" ], "in 1 year": [ - "ta'u kaha'u" + "ta'u kaha'u", + "tha'u" ] }, "relative-type-regex": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/tr.json b/dateparser_data/cldr_language_data/date_translation_data/tr.json index a913750d6..fcb835640 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/tr.json +++ b/dateparser_data/cldr_language_data/date_translation_data/tr.json @@ -125,7 +125,8 @@ "şimdi" ], "0 week ago": [ - "bu hafta" + "bu hafta", + "bu hf" ], "0 year ago": [ "bu yıl" @@ -137,7 +138,8 @@ "geçen ay" ], "1 week ago": [ - "geçen hafta" + "geçen hafta", + "geçen hf" ], "1 year ago": [ "geçen yıl" @@ -149,7 +151,8 @@ "gelecek ay" ], "in 1 week": [ - "gelecek hafta" + "gelecek hafta", + "gelecek hf" ], "in 1 year": [ "gelecek yıl" diff --git a/dateparser_data/cldr_language_data/date_translation_data/twq.json b/dateparser_data/cldr_language_data/date_translation_data/twq.json index 4b6409a72..780cb5333 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/twq.json +++ b/dateparser_data/cldr_language_data/date_translation_data/twq.json @@ -94,7 +94,8 @@ "zaari" ], "hour": [ - "guuru" + "guuru", + "hr" ], "minute": [ "miniti" diff --git a/dateparser_data/cldr_language_data/date_translation_data/tzm.json b/dateparser_data/cldr_language_data/date_translation_data/tzm.json index 1c1d4561d..69ec3fcb7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/tzm.json +++ b/dateparser_data/cldr_language_data/date_translation_data/tzm.json @@ -96,6 +96,7 @@ "ass" ], "hour": [ + "hr", "tasragt" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/ug.json b/dateparser_data/cldr_language_data/date_translation_data/ug.json index ffe747a90..a2e1a3b76 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ug.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ug.json @@ -86,6 +86,7 @@ "كۈن" ], "hour": [ + "hr", "سائەت" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/uk.json b/dateparser_data/cldr_language_data/date_translation_data/uk.json index e0f1e321f..df31cb436 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/uk.json +++ b/dateparser_data/cldr_language_data/date_translation_data/uk.json @@ -17,19 +17,16 @@ "березня" ], "april": [ - "кві", "квіт", "квітень", "квітня" ], "may": [ - "тра", "трав", "травень", "травня" ], "june": [ - "чер", "черв", "червень", "червня" @@ -40,7 +37,6 @@ "липня" ], "august": [ - "сер", "серп", "серпень", "серпня" @@ -51,19 +47,16 @@ "вересня" ], "october": [ - "жов", "жовт", "жовтень", "жовтня" ], "november": [ - "лис", "лист", "листопад", "листопада" ], "december": [ - "гру", "груд", "грудень", "грудня" @@ -78,6 +71,7 @@ ], "wednesday": [ "середа", + "середу", "ср" ], "thursday": [ @@ -85,15 +79,18 @@ "чт" ], "friday": [ + "п'ятницю", "п'ятниця", "пт" ], "saturday": [ "сб", - "субота" + "субота", + "суботу" ], "sunday": [ "нд", + "неділю", "неділя" ], "am": [ @@ -107,10 +104,12 @@ "рік" ], "month": [ + "м", "міс", "місяць" ], "week": [ + "т", "тиж", "тиждень" ], @@ -120,7 +119,8 @@ ], "hour": [ "год", - "година" + "година", + "години" ], "minute": [ "хв", @@ -141,6 +141,7 @@ "цієї хвилини" ], "0 month ago": [ + "цього міс", "цього місяця" ], "0 second ago": [ @@ -150,36 +151,43 @@ "цього тижня" ], "0 year ago": [ - "цього року" + "цього року", + "цьогоріч" ], "1 day ago": [ "учора" ], "1 month ago": [ + "мин міс", "минулого місяця" ], "1 week ago": [ + "мин тижня", "минулого тижня" ], "1 year ago": [ + "минулого року", "торік" ], "in 1 day": [ "завтра" ], "in 1 month": [ + "наст міс", "наступного місяця" ], "in 1 week": [ + "наст тижня", "наступного тижня" ], "in 1 year": [ + "наст р", + "наст року", "наступного року" ] }, "relative-type-regex": { "\\1 day ago": [ - "{0} д тому", "{0} день тому", "{0} дн тому", "{0} дня тому" @@ -215,7 +223,7 @@ "{0} рік тому" ], "in \\1 day": [ - "за {0} д", + "за {0} дн", "через {0} день", "через {0} дн", "через {0} дня" diff --git a/dateparser_data/cldr_language_data/date_translation_data/ur.json b/dateparser_data/cldr_language_data/date_translation_data/ur.json index 1d263702d..604b29163 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/ur.json +++ b/dateparser_data/cldr_language_data/date_translation_data/ur.json @@ -38,7 +38,7 @@ "دسمبر" ], "monday": [ - "سوموار" + "پیر" ], "tuesday": [ "منگل" @@ -78,7 +78,8 @@ "دن" ], "hour": [ - "گھنٹہ" + "گھنٹہ", + "گھنٹے" ], "minute": [ "منٹ" @@ -97,6 +98,7 @@ "اس منٹ" ], "0 month ago": [ + "اس ماہ", "اس مہینہ" ], "0 second ago": [ @@ -112,10 +114,12 @@ "گزشتہ کل" ], "1 month ago": [ - "پچھلے مہینہ" + "پچھلے مہینہ", + "گزشتہ ماہ" ], "1 week ago": [ - "پچھلے ہفتہ" + "پچھلے ہفتہ", + "گزشتہ ہفتے" ], "1 year ago": [ "گزشتہ سال" @@ -124,10 +128,13 @@ "آئندہ کل" ], "in 1 month": [ + "اگلا مہینہ", + "اگلے ماہ", "اگلے مہینہ" ], "in 1 week": [ - "اگلے ہفتہ" + "اگلے ہفتہ", + "اگلے ہفتے" ], "in 1 year": [ "اگلے سال" @@ -167,7 +174,6 @@ ], "in \\1 hour": [ "{0} گھنٹوں میں", - "{0} گھنٹہ میں", "{0} گھنٹے میں" ], "in \\1 minute": [ @@ -192,21 +198,9 @@ "locale_specific": { "ur-IN": { "name": "ur-IN", - "monday": [ - "پیر" - ], "relative-type": { - "0 month ago": [ - "اس ماہ" - ], - "1 month ago": [ - "گزشتہ ماہ" - ], "1 week ago": [ "گزشتہ ہفتہ" - ], - "in 1 month": [ - "اگلے ماہ" ] }, "relative-type-regex": { diff --git a/dateparser_data/cldr_language_data/date_translation_data/uz-Arab.json b/dateparser_data/cldr_language_data/date_translation_data/uz-Arab.json index d72c229cf..a45ecc889 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/uz-Arab.json +++ b/dateparser_data/cldr_language_data/date_translation_data/uz-Arab.json @@ -94,7 +94,8 @@ "day" ], "hour": [ - "hour" + "hour", + "hr" ], "minute": [ "minute" diff --git a/dateparser_data/cldr_language_data/date_translation_data/uz-Cyrl.json b/dateparser_data/cldr_language_data/date_translation_data/uz-Cyrl.json index 24f46bebd..5154d79b2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/uz-Cyrl.json +++ b/dateparser_data/cldr_language_data/date_translation_data/uz-Cyrl.json @@ -93,6 +93,7 @@ "кун" ], "hour": [ + "hr", "соат" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/uz-Latn.json b/dateparser_data/cldr_language_data/date_translation_data/uz-Latn.json index f1a957bfb..701beabe1 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/uz-Latn.json +++ b/dateparser_data/cldr_language_data/date_translation_data/uz-Latn.json @@ -116,12 +116,14 @@ "shu daqiqada" ], "0 month ago": [ + "bu oy", "shu oy" ], "0 second ago": [ "hozir" ], "0 week ago": [ + "bu hafta", "shu hafta" ], "0 year ago": [ @@ -138,7 +140,7 @@ "o‘tgan hafta" ], "1 year ago": [ - "o'tgan yil", + "o‘'tgan yil", "o‘tgan yil" ], "in 1 day": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/uz.json b/dateparser_data/cldr_language_data/date_translation_data/uz.json index 220e5cf7e..5c0cdae17 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/uz.json +++ b/dateparser_data/cldr_language_data/date_translation_data/uz.json @@ -116,12 +116,14 @@ "shu daqiqada" ], "0 month ago": [ + "bu oy", "shu oy" ], "0 second ago": [ "hozir" ], "0 week ago": [ + "bu hafta", "shu hafta" ], "0 year ago": [ @@ -138,7 +140,7 @@ "o‘tgan hafta" ], "1 year ago": [ - "o'tgan yil", + "o‘'tgan yil", "o‘tgan yil" ], "in 1 day": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/vun.json b/dateparser_data/cldr_language_data/date_translation_data/vun.json index 821accca1..91754d8b7 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/vun.json +++ b/dateparser_data/cldr_language_data/date_translation_data/vun.json @@ -95,6 +95,7 @@ "mfiri" ], "hour": [ + "hr", "saa" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/wae.json b/dateparser_data/cldr_language_data/date_translation_data/wae.json index 11f6f0837..347c280b8 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/wae.json +++ b/dateparser_data/cldr_language_data/date_translation_data/wae.json @@ -96,7 +96,8 @@ "tag" ], "hour": [ - "schtund" + "schtund", + "stunde" ], "minute": [ "mínütta" diff --git a/dateparser_data/cldr_language_data/date_translation_data/xog.json b/dateparser_data/cldr_language_data/date_translation_data/xog.json index b2eb9eaa5..9a06bb987 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/xog.json +++ b/dateparser_data/cldr_language_data/date_translation_data/xog.json @@ -96,7 +96,8 @@ "olunaku" ], "hour": [ - "essawa" + "essawa", + "hr" ], "minute": [ "edakiika" diff --git a/dateparser_data/cldr_language_data/date_translation_data/yav.json b/dateparser_data/cldr_language_data/date_translation_data/yav.json index 2dec2f135..aad395626 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/yav.json +++ b/dateparser_data/cldr_language_data/date_translation_data/yav.json @@ -96,6 +96,7 @@ "puɔ́sɛ́" ], "hour": [ + "hr", "kisikɛl," ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/yi.json b/dateparser_data/cldr_language_data/date_translation_data/yi.json index c193cd56f..fc6b4f77c 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/yi.json +++ b/dateparser_data/cldr_language_data/date_translation_data/yi.json @@ -85,6 +85,7 @@ "טאָג" ], "hour": [ + "hr", "שעה" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/yo.json b/dateparser_data/cldr_language_data/date_translation_data/yo.json index 656657a63..54a0defce 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/yo.json +++ b/dateparser_data/cldr_language_data/date_translation_data/yo.json @@ -3,75 +3,106 @@ "date_order": "DMY", "january": [ "oṣù ṣẹ́rẹ́", + "ṣẹ́", + "ṣẹ́r", "ṣẹ́rẹ́" ], "february": [ "oṣù èrèlè", + "èr", + "èrèl", "èrèlè" ], "march": [ "oṣù ẹrẹ̀nà", + "ẹr", + "ẹrẹ̀n", "ẹrẹ̀nà" ], "april": [ "oṣù ìgbé", + "ìg", + "ìgb", "ìgbé" ], "may": [ "oṣù ẹ̀bibi", + "ẹ̀b", + "ẹ̀bi", "ẹ̀bibi" ], "june": [ "oṣù òkúdu", + "òk", + "òkú", "òkúdu" ], "july": [ + "ag", + "agẹ", "agẹmọ", "oṣù agẹmọ" ], "august": [ "oṣù ògún", + "òg", + "ògú", "ògún" ], "september": [ + "ow", + "owe", "owewe", "oṣù owewe" ], "october": [ "oṣù ọ̀wàrà", + "ọ̀w", + "ọ̀wà", "ọ̀wàrà" ], "november": [ + "bé", + "bél", "bélú", "oṣù bélú" ], "december": [ "oṣù ọ̀pẹ̀", + "ọ̀p", + "ọ̀pẹ", "ọ̀pẹ̀" ], "monday": [ + "aj", "ajé", "ọjọ́ ajé" ], "tuesday": [ + "ìsẹ́g", "ìsẹ́gun", "ọjọ́ ìsẹ́gun" ], "wednesday": [ + "ọjọ́r", "ọjọ́rú" ], "thursday": [ + "ọjọ́b", "ọjọ́bọ" ], "friday": [ + "ẹt", "ẹtì", "ọjọ́ ẹtì" ], "saturday": [ + "àbám", "àbámẹ́ta", "ọjọ́ àbámẹ́ta" ], "sunday": [ + "àìk", "àìkú", "ọjọ́ àìkú" ], @@ -85,15 +116,17 @@ "ọdún" ], "month": [ - "osù" + "osù", + "oṣù" ], "week": [ - "ọ̀sè" + "ọ̀sẹ̀" ], "day": [ "ọjọ́" ], "hour": [ + "wkt", "wákàtí" ], "minute": [ @@ -113,40 +146,43 @@ "this minute" ], "0 month ago": [ - "this month" + "oṣù yìí" ], "0 second ago": [ "now" ], "0 week ago": [ - "this week" + "ọ̀sẹ̀ yìí" ], "0 year ago": [ - "this year" + "ọdún yìí", + "ọdúnǹí" ], "1 day ago": [ "àná" ], "1 month ago": [ - "last month" + "óṣù tó kọjá" ], "1 week ago": [ - "last week" + "ọ̀sẹ̀ tó kọjá" ], "1 year ago": [ - "last year" + "èṣín", + "ọdún tó kọjá" ], "in 1 day": [ "ọ̀la" ], "in 1 month": [ - "next month" + "óṣù tó ń bọ̀," ], "in 1 week": [ - "next week" + "ọ́sẹ̀ tó ń bọ̀" ], "in 1 year": [ - "next year" + "àmọ́dún", + "ọdún tó ńbọ̀" ] }, "locale_specific": { @@ -154,6 +190,8 @@ "name": "yo-BJ", "january": [ "oshù shɛ́rɛ́", + "shɛ́", + "shɛ́r", "shɛ́rɛ́" ], "february": [ @@ -161,6 +199,8 @@ ], "march": [ "oshù ɛrɛ̀nà", + "ɛr", + "ɛrɛ̀n", "ɛrɛ̀nà" ], "april": [ @@ -168,12 +208,15 @@ ], "may": [ "oshù ɛ̀bibi", + "ɛ̀b", + "ɛ̀bi", "ɛ̀bibi" ], "june": [ "oshù òkúdu" ], "july": [ + "agɛ", "agɛmɔ", "oshù agɛmɔ" ], @@ -185,6 +228,8 @@ ], "october": [ "oshù ɔ̀wàrà", + "ɔ̀w", + "ɔ̀wà", "ɔ̀wàrà" ], "november": [ @@ -192,23 +237,29 @@ ], "december": [ "oshù ɔ̀pɛ̀", + "ɔ̀p", + "ɔ̀pɛ", "ɔ̀pɛ̀" ], "monday": [ "ɔjɔ́ ajé" ], "tuesday": [ + "ìsɛ́g", "ìsɛ́gun", "ɔjɔ́ ìsɛ́gun" ], "wednesday": [ + "ɔjɔ́r", "ɔjɔ́rú" ], "thursday": [ + "ɔjɔ́b", "ɔjɔ́bɔ" ], "friday": [ "ɔjɔ́ ɛtì", + "ɛt", "ɛtì" ], "saturday": [ @@ -227,8 +278,11 @@ "year": [ "ɔdún" ], + "month": [ + "oshù" + ], "week": [ - "ɔ̀sè" + "ɔ̀sɛ̀" ], "day": [ "ɔjɔ́" @@ -240,8 +294,38 @@ "ìsɛ́jú ààyá" ], "relative-type": { + "0 month ago": [ + "oshù yìí" + ], + "0 week ago": [ + "ɔ̀sɛ̀ yìí" + ], + "0 year ago": [ + "ɔdún yìí", + "ɔdúnǹí" + ], + "1 month ago": [ + "óshù tó kɔjá" + ], + "1 week ago": [ + "ɔ̀sɛ̀ tó kɔjá" + ], + "1 year ago": [ + "èshín", + "ɔdún tó kɔjá" + ], "in 1 day": [ "ɔ̀la" + ], + "in 1 month": [ + "óshù tó ń bɔ̀," + ], + "in 1 week": [ + "ɔ́sɛ̀ tó ń bɔ̀" + ], + "in 1 year": [ + "àmɔ́dún", + "ɔdún tó ńbɔ̀" ] } } diff --git a/dateparser_data/cldr_language_data/date_translation_data/yue.json b/dateparser_data/cldr_language_data/date_translation_data/yue.json index f6e9b0923..922a8d819 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/yue.json +++ b/dateparser_data/cldr_language_data/date_translation_data/yue.json @@ -38,32 +38,25 @@ "12月" ], "monday": [ - "星期一", - "週一" + "星期一" ], "tuesday": [ - "星期二", - "週二" + "星期二" ], "wednesday": [ - "星期三", - "週三" + "星期三" ], "thursday": [ - "星期四", - "週四" + "星期四" ], "friday": [ - "星期五", - "週五" + "星期五" ], "saturday": [ - "星期六", - "週六" + "星期六" ], "sunday": [ - "星期日", - "週日" + "星期日" ], "am": [ "上午" diff --git a/dateparser_data/cldr_language_data/date_translation_data/zgh.json b/dateparser_data/cldr_language_data/date_translation_data/zgh.json index 39cfb14c1..ed0eb0e72 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/zgh.json +++ b/dateparser_data/cldr_language_data/date_translation_data/zgh.json @@ -96,6 +96,7 @@ "ⴰⵙⵙ" ], "hour": [ + "hr", "ⵜⴰⵙⵔⴰⴳⵜ" ], "minute": [ diff --git a/dateparser_data/cldr_language_data/date_translation_data/zh-Hant.json b/dateparser_data/cldr_language_data/date_translation_data/zh-Hant.json index f6a313957..cf6f7b9b2 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/zh-Hant.json +++ b/dateparser_data/cldr_language_data/date_translation_data/zh-Hant.json @@ -212,9 +212,6 @@ "1 day ago": [ "昨日" ], - "1 month ago": [ - "上月" - ], "1 week ago": [ "上星期" ], @@ -224,9 +221,6 @@ "in 1 day": [ "明日" ], - "in 1 month": [ - "下月" - ], "in 1 week": [ "下星期" ], @@ -253,7 +247,7 @@ ], "\\1 week ago": [ "{0} 星期前", - "{0}週前" + "{0}星期前" ], "\\1 year ago": [ "{0}年前" @@ -276,7 +270,7 @@ ], "in \\1 week": [ "{0} 星期後", - "{0}週後" + "{0}星期後" ], "in \\1 year": [ "{0}年後" @@ -311,9 +305,6 @@ "1 day ago": [ "昨日" ], - "1 month ago": [ - "上月" - ], "1 week ago": [ "上星期" ], @@ -323,9 +314,6 @@ "in 1 day": [ "明日" ], - "in 1 month": [ - "下月" - ], "in 1 week": [ "下星期" ], @@ -352,7 +340,7 @@ ], "\\1 week ago": [ "{0} 星期前", - "{0}週前" + "{0}星期前" ], "\\1 year ago": [ "{0}年前" @@ -375,7 +363,7 @@ ], "in \\1 week": [ "{0} 星期後", - "{0}週後" + "{0}星期後" ], "in \\1 year": [ "{0}年後" diff --git a/dateparser_data/cldr_language_data/date_translation_data/zu.json b/dateparser_data/cldr_language_data/date_translation_data/zu.json index 3dc90ca99..5a1daccc4 100644 --- a/dateparser_data/cldr_language_data/date_translation_data/zu.json +++ b/dateparser_data/cldr_language_data/date_translation_data/zu.json @@ -3,8 +3,7 @@ "date_order": "MDY", "january": [ "jan", - "januwari", - "umasingana" + "januwari" ], "february": [ "feb", @@ -97,6 +96,7 @@ "usuku" ], "hour": [ + "amahora", "ihora" ], "minute": [ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/af.yaml b/dateparser_data/supplementary_language_data/date_translation_data/af.yaml new file mode 100644 index 000000000..115674aaa --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/af.yaml @@ -0,0 +1,10 @@ +second: + - sek +relative-type: + 0 week ago: + - vandeesweek +relative-type-regex: + \1 second ago: + - (\d+[.,]?\d*) sek gelede + in \1 second: + - oor (\d+[.,]?\d*) sek diff --git a/dateparser_data/supplementary_language_data/date_translation_data/am.yaml b/dateparser_data/supplementary_language_data/date_translation_data/am.yaml new file mode 100644 index 000000000..0f1c379ed --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/am.yaml @@ -0,0 +1,6 @@ +january: + - ጃንዩ + - ጃንዩወሪ +february: + - ፌብሩ + - ፌብሩወሪ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml index 3c31b7223..c5c39284f 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml @@ -1,4 +1,8 @@ -sentence_splitter_group : 6 +locale_specific: + ar-IQ: + october: + - تشرین الأول +sentence_splitter_group: 6 skip: ["الساعة", "في", "مساءً", "هـ"] diff --git a/dateparser_data/supplementary_language_data/date_translation_data/as.yaml b/dateparser_data/supplementary_language_data/date_translation_data/as.yaml new file mode 100644 index 000000000..bbb2ca974 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/as.yaml @@ -0,0 +1,42 @@ +thursday: + - বৃহষ্পতি + - বৃহষ্পতিবাৰ +sunday: + - ৰবি +may: + - মে +september: + - সেপ্ট +november: + - নভে +december: + - ডিসে +am: + - পূৰ্বাহ্ণ +pm: + - অপৰাহ্ণ +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/az-Latn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/az-Latn.yaml new file mode 100644 index 000000000..f992f847b --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/az-Latn.yaml @@ -0,0 +1,4 @@ +june: + - i̇yun +july: + - i̇yul diff --git a/dateparser_data/supplementary_language_data/date_translation_data/az.yaml b/dateparser_data/supplementary_language_data/date_translation_data/az.yaml new file mode 100644 index 000000000..f992f847b --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/az.yaml @@ -0,0 +1,4 @@ +june: + - i̇yun +july: + - i̇yul diff --git a/dateparser_data/supplementary_language_data/date_translation_data/be.yaml b/dateparser_data/supplementary_language_data/date_translation_data/be.yaml index fba72dd8f..c2e1fca27 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/be.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/be.yaml @@ -1,6 +1,11 @@ +relative-type-regex: + \1 day ago: + - (\d+[.,]?\d*) д таму + in \1 day: + - праз (\d+[.,]?\d*) д skip: ["каля", "у", "і", "ў"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - Пнд diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml index f8388135b..0e8775658 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml @@ -1,6 +1,6 @@ skip: ["върху", "до", "на", "около", "от", "под"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - пон @@ -29,6 +29,7 @@ year: month: - мес - месеци + - м week: - с - сед @@ -60,6 +61,7 @@ relative-type: - след 1 десетилетие 1 week ago: - преди седмица + - миналата седмица 2 day ago: - онзи ден 1 day ago: diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bn.yaml index e2a169010..d689886ab 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/bn.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/bn.yaml @@ -1,6 +1,11 @@ +thursday: + - বৃহষ্পতিবার +relative-type-regex: + \1 minute ago: + - (\d+[.,]?\d*) মিনিট পূর্বে skip: ["ই", "এবং", "টা", "প্রায়", "লা", "শে"] -sentence_splitter_group : 3 +sentence_splitter_group: 3 january: - জানুয়ারি diff --git a/dateparser_data/supplementary_language_data/date_translation_data/br.yaml b/dateparser_data/supplementary_language_data/date_translation_data/br.yaml new file mode 100644 index 000000000..08e7da7eb --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/br.yaml @@ -0,0 +1,7 @@ +december: + - ker +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute diff --git a/dateparser_data/supplementary_language_data/date_translation_data/brx.yaml b/dateparser_data/supplementary_language_data/date_translation_data/brx.yaml new file mode 100644 index 000000000..4c71c74db --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/brx.yaml @@ -0,0 +1,60 @@ +wednesday: + - बुद + - बुदबार +thursday: + - बिसथि + - बिसथिबार +saturday: + - सुनि + - सुनिबार +february: + - फेब्रुवारी +march: + - मार्स +april: + - एफ्रिल +july: + - जुलाइ +august: + - आगस्थ +september: + - सेबथेज्ब़र +october: + - अखथबर +november: + - नबेज्ब़र +december: + - दिसेज्ब़र +week: + - सबथा/हबथा +hour: + - रिंगा +minute: + - मिनिथ +second: + - सेखेन्द +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml index 9953707f7..aee54b750 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/bs-Cyrl.yaml @@ -1,3 +1,6 @@ +august: + - авг + - август am: - пријеподне pm: @@ -5,9 +8,11 @@ pm: monday: - понедјељак + - понедељак sunday: - недјеља + - недеља year: - г @@ -19,14 +24,17 @@ month: - мјесец - мјесеци - мјесеца + - месец week: - сед - седмица - седмице + - недеља hour: - сат + - час minute: - мин @@ -40,55 +48,79 @@ second: relative-type: 0 hour ago: - овај сат + - this hour 0 minute ago: - ова минута + - this minute 0 month ago: - овај мјесец + - овог месеца 0 second ago: - сада + - now 0 week ago: - ове седмице + - ове недеље 1 month ago: - прошли мјесец + - прошлог месеца 1 week ago: - прошле седмице + - прошле недеље in 1 month: - сљедећи мјесец + - следећег месеца in 1 week: - сљедеће седмице + - следеће недеље in 1 year: - сљедеће године + - следеће године relative-type-regex: \1 day ago: - прије (\d+[.,]?\d*) дан - прије (\d+[.,]?\d*) дана + - пре (\d+[.,]?\d*) дан + - пре (\d+[.,]?\d*) дана \1 hour ago: - прије (\d+[.,]?\d*) сат - прије (\d+[.,]?\d*) сати + - пре (\d+[.,]?\d*) сат + - пре (\d+[.,]?\d*) сати \1 minute ago: - прије (\d+[.,]?\d*) мин - прије (\d+[.,]?\d*) минута - прије (\d+[.,]?\d*) минуту + - пре (\d+[.,]?\d*) минут + - пре (\d+[.,]?\d*) минута \1 month ago: - прије (\d+[.,]?\d*) мј - прије (\d+[.,]?\d*) мјесец - прије (\d+[.,]?\d*) мјесеца - прије (\d+[.,]?\d*) мјесеци + - пре (\d+[.,]?\d*) месец + - пре (\d+[.,]?\d*) месеци \1 second ago: - прије (\d+[.,]?\d*) сек - прије (\d+[.,]?\d*) секунда - прије (\d+[.,]?\d*) секунду + - пре (\d+[.,]?\d*) секунд + - пре (\d+[.,]?\d*) секунди \1 week ago: - прије (\d+[.,]?\d*) сед - прије (\d+[.,]?\d*) седмица - прије (\d+[.,]?\d*) седмице - прије (\d+[.,]?\d*) седмицу + - пре (\d+[.,]?\d*) недеља + - пре (\d+[.,]?\d*) недељу \1 year ago: - прије (\d+[.,]?\d*) г - прије (\d+[.,]?\d*) год - прије (\d+[.,]?\d*) година - прије (\d+[.,]?\d*) годину + - пре (\d+[.,]?\d*) година + - пре (\d+[.,]?\d*) годину in \1 minute: - за (\d+[.,]?\d*) мин @@ -99,6 +131,8 @@ relative-type-regex: - за (\d+[.,]?\d*) мјесец - за (\d+[.,]?\d*) мјесеца - за (\d+[.,]?\d*) мјесеци + - за (\d+[.,]?\d*) месец + - за (\d+[.,]?\d*) месеци in \1 second: - за (\d+[.,]?\d*) сек - за (\d+[.,]?\d*) секунда @@ -108,6 +142,8 @@ relative-type-regex: - за (\d+[.,]?\d*) седмица - за (\d+[.,]?\d*) седмицу - за (\d+[.,]?\d*) седмице + - за (\d+[.,]?\d*) недеља + - за (\d+[.,]?\d*) недељу in \1 year: - за (\d+[.,]?\d*) г - за (\d+[.,]?\d*) год diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bs-Latn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bs-Latn.yaml new file mode 100644 index 000000000..28a5480b0 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/bs-Latn.yaml @@ -0,0 +1,3 @@ +august: + - avg + - avgust diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bs.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bs.yaml new file mode 100644 index 000000000..28a5480b0 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/bs.yaml @@ -0,0 +1,3 @@ +august: + - avg + - avgust diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ca.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ca.yaml index 49dd68f5a..b5ed1f2ff 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ca.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ca.yaml @@ -23,7 +23,14 @@ relative-type: - la setmana vinent - la pròxima setmana - la propera setmana + - setm vinent + 1 month ago: + - mes passat + 1 week ago: + - setm passada + in 1 month: + - mes vinent simplifications: - una: '1' - un: '1' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ce.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ce.yaml new file mode 100644 index 000000000..0200c7c82 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ce.yaml @@ -0,0 +1,21 @@ +monday: + - оршотан де +tuesday: + - шинарин де +wednesday: + - кхаарин де +thursday: + - еарин де +friday: + - пӏераскан де +saturday: + - шот де +sunday: + - кӏиранан де +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 second ago: + - now diff --git a/dateparser_data/supplementary_language_data/date_translation_data/chr.yaml b/dateparser_data/supplementary_language_data/date_translation_data/chr.yaml new file mode 100644 index 000000000..e4d3aea1c --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/chr.yaml @@ -0,0 +1,16 @@ +relative-type-regex: + \1 hour ago: + - ꮎꮏ (\d+[.,]?\d*) ꮡꮯ ꮵꭸꮢ + \1 minute ago: + - ꮎꮏ (\d+[.,]?\d*) ꭲꮿꮤ ꮵꭸꮢ + - ꮎꮏ (\d+[.,]?\d*) ꭲꮿꮤꮼꮝꮤꮕ ꮵꭸꮢ + \1 month ago: + - ꮎꮏ (\d+[.,]?\d*) ꭷꮈ ꮵꭸꮢ + - ꮎꮏ (\d+[.,]?\d*) ꭷꮈꭲ ꮵꭸꮢ + - ꮎꮏ (\d+[.,]?\d*) ꮧꭷꮈꭲ ꮵꭸꮢ + \1 week ago: + - ꮎꮏ (\d+[.,]?\d*) ꭲᏻꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ + - ꮎꮏ (\d+[.,]?\d*) ꮢꮎ ꮵꭸꮢ + - ꮎꮏ (\d+[.,]?\d*) ꮢꮎꮩꮣꮖꮝꮧ ꮵꭸꮢ + \1 year ago: + - ꮎꮏ (\d+[.,]?\d*) ꭴꮥ ꮵꭸꮢ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/cy.yaml b/dateparser_data/supplementary_language_data/date_translation_data/cy.yaml new file mode 100644 index 000000000..501338c41 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/cy.yaml @@ -0,0 +1,2 @@ +day: + - dydd diff --git a/dateparser_data/supplementary_language_data/date_translation_data/da.yaml b/dateparser_data/supplementary_language_data/date_translation_data/da.yaml index 9d8dbcea4..2448417b4 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/da.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/da.yaml @@ -1,6 +1,15 @@ -skip: ["cirka", "d.", "kl", "kl."] +tuesday: + - tir +thursday: + - tor +relative-type: + 0 hour ago: + - i den kommende time + 0 minute ago: + - i det kommende minut +skip: ["cirka", "d.", "den", "kl", "kl."] -sentence_splitter_group : 1 +sentence_splitter_group: 1 month: - måneder @@ -27,10 +36,15 @@ relative-type-regex: \1 minute ago: - for (\d+[.,]?\d*)\s*m - for (\d+[.,]?\d*) minutter + - for (\d+[.,]?\d*) min siden \1 second ago: - for (\d+[.,]?\d*)\s*s - for (\d+[.,]?\d*) sekunder + - for (\d+[.,]?\d*) sek siden + \1 month ago: + - for (\d+[.,]?\d*) md siden + - for (\d+[.,]?\d*) mdr siden simplifications: - en: '1' - et: '1' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/de.yaml b/dateparser_data/supplementary_language_data/date_translation_data/de.yaml index fd2372e3a..3d3159cc4 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/de.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/de.yaml @@ -1,6 +1,10 @@ +am: + - vorm +pm: + - nachm skip: ["etwa", "uhr", "um", "und"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - Mon diff --git a/dateparser_data/supplementary_language_data/date_translation_data/dsb.yaml b/dateparser_data/supplementary_language_data/date_translation_data/dsb.yaml new file mode 100644 index 000000000..80bb9285f --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/dsb.yaml @@ -0,0 +1,9 @@ +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 1 month ago: + - slědny mjasec + 1 week ago: + - slědny tyźeń diff --git a/dateparser_data/supplementary_language_data/date_translation_data/el.yaml b/dateparser_data/supplementary_language_data/date_translation_data/el.yaml new file mode 100644 index 000000000..d3fa5578a --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/el.yaml @@ -0,0 +1,14 @@ +hour: + - ώρ +relative-type: + 0 hour ago: + - αυτήν την ώρα + 0 minute ago: + - αυτό το λεπτό + 0 week ago: + - αυτήν την εβδομάδα +relative-type-regex: + \1 hour ago: + - πριν από (\d+[.,]?\d*) ώρ + in \1 hour: + - σε (\d+[.,]?\d*) ώρ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index a4e9a1ad8..743d5e04b 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -76,6 +76,9 @@ relative-type: - till date relative-type-regex: + in \1 week: + - in {0} weeks time + - "in {0} weeks' time" in \1 decade: - in (\d+[.,]?\d*) decades? \1 decade ago: @@ -103,3 +106,8 @@ simplifications: - ten: '10' - eleven: '11' - twelve: '12' + +locale_specific: + en-US: + name: en-US + date_order: MDY diff --git a/dateparser_data/supplementary_language_data/date_translation_data/es.yaml b/dateparser_data/supplementary_language_data/date_translation_data/es.yaml index e83ef7a55..3e2226d64 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/es.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/es.yaml @@ -1,7 +1,66 @@ skip: ["a las", "cerca", "de", "del", "en", "y"] pertain: ["de", "del"] +locale_specific: + es-419: + september: + - sep + es-AR: + september: + - sep + es-BO: + september: + - sep + es-BR: + september: + - sep + es-BZ: + september: + - sep + es-CL: + september: + - sep + es-CO: + september: + - sep + es-CR: + september: + - sep + es-CU: + september: + - sep + es-DO: + september: + - sep + es-EC: + september: + - sep + es-GT: + september: + - sep + es-HN: + september: + - sep + es-MX: + relative-type-regex: + in \1 minute: + - en (\d+[.,]?\d*) min + es-NI: + september: + - sep + es-PA: + september: + - sep + es-PR: + september: + - sep + es-SV: + september: + - sep + es-US: + september: + - sep -sentence_splitter_group : 2 +sentence_splitter_group: 2 monday: - Lu diff --git a/dateparser_data/supplementary_language_data/date_translation_data/eu.yaml b/dateparser_data/supplementary_language_data/date_translation_data/eu.yaml new file mode 100644 index 000000000..73ff8a013 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/eu.yaml @@ -0,0 +1,13 @@ +relative-type: + 0 month ago: + - hilabete hau + 0 week ago: + - aste hau + 1 month ago: + - aurreko hilabetea + 1 week ago: + - aurreko astea + in 1 month: + - hurrengo hilabetea + in 1 week: + - hurrengo astea diff --git a/dateparser_data/supplementary_language_data/date_translation_data/fa.yaml b/dateparser_data/supplementary_language_data/date_translation_data/fa.yaml index eb938a5e5..06986fe1a 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/fa.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/fa.yaml @@ -1,4 +1,7 @@ -sentence_splitter_group : 6 +relative-type: + 1 month ago: + - ماه پیش +sentence_splitter_group: 6 tuesday: - سهشنبه diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ff.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ff.yaml new file mode 100644 index 000000000..f93beebd6 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ff.yaml @@ -0,0 +1,7 @@ +locale_specific: + ff-CM: + name: ff-CM + ff-GN: + name: ff-GN + ff-MR: + name: ff-MR diff --git a/dateparser_data/supplementary_language_data/date_translation_data/fil.yaml b/dateparser_data/supplementary_language_data/date_translation_data/fil.yaml new file mode 100644 index 000000000..de34e0e6a --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/fil.yaml @@ -0,0 +1,5 @@ +relative-type-regex: + \1 hour ago: + - (\d+[.,]?\d*) oras nakalipas + \1 second ago: + - (\d+[.,]?\d*) seg nakalipas diff --git a/dateparser_data/supplementary_language_data/date_translation_data/fr.yaml b/dateparser_data/supplementary_language_data/date_translation_data/fr.yaml index 6e469ee5c..acd8f96f0 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/fr.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/fr.yaml @@ -1,6 +1,13 @@ +relative-type-regex: + \1 hour ago: + - il y a (\d+[.,]?\d*)h + \1 minute ago: + - il y a (\d+[.,]?\d*)min + in \1 hour: + - dans (\d+[.,]?\d*)h skip: ["environ", "er", "et", "le", "à"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - lu diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ga.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ga.yaml new file mode 100644 index 000000000..9caaa2ac5 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ga.yaml @@ -0,0 +1,11 @@ +am: + - am +pm: + - pm +relative-type: + 0 year ago: + - an bhl seo + - an bhliain seo +relative-type-regex: + in \1 year: + - i gceann (\d+[.,]?\d*) bhliain diff --git a/dateparser_data/supplementary_language_data/date_translation_data/gd.yaml b/dateparser_data/supplementary_language_data/date_translation_data/gd.yaml new file mode 100644 index 000000000..a98389fdc --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/gd.yaml @@ -0,0 +1,5 @@ +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute diff --git a/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml new file mode 100644 index 000000000..ba215dcb7 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml @@ -0,0 +1,38 @@ +year: + - a +month: + - m +day: + - d +relative-type: + 0 hour ago: + - nesta hora + 0 minute ago: + - neste minuto + 0 month ago: + - este m + 1 month ago: + - m pasado + 1 week ago: + - sem pasada + 1 year ago: + - ano pasado + in 1 month: + - m seguinte + in 1 week: + - sem seguinte + in 1 year: + - seguinte ano +relative-type-regex: + \1 day ago: + - hai (\d+[.,]?\d*) d + \1 month ago: + - hai (\d+[.,]?\d*) m + \1 year ago: + - hai (\d+[.,]?\d*) a + in \1 day: + - en (\d+[.,]?\d*) d + in \1 month: + - en (\d+[.,]?\d*) m + in \1 year: + - en (\d+[.,]?\d*) a diff --git a/dateparser_data/supplementary_language_data/date_translation_data/gu.yaml b/dateparser_data/supplementary_language_data/date_translation_data/gu.yaml new file mode 100644 index 000000000..95469fa2b --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/gu.yaml @@ -0,0 +1,3 @@ +relative-type-regex: + \1 year ago: + - (\d+[.,]?\d*) વર્ષ પહેલા diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ha.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ha.yaml new file mode 100644 index 000000000..adf846938 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ha.yaml @@ -0,0 +1,29 @@ +am: + - am +pm: + - pm +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/he.yaml b/dateparser_data/supplementary_language_data/date_translation_data/he.yaml index dcb4fab94..fab67828f 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/he.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/he.yaml @@ -1,4 +1,9 @@ -sentence_splitter_group : 1 +relative-type-regex: + \1 day ago: + - לפני (\d+[.,]?\d*) ימ׳ + in \1 day: + - בעוד (\d+[.,]?\d*) ימ׳ +sentence_splitter_group: 1 skip: ["ב-", "בסביבות", "בערך", "בקירוב", "בשעה", "ה-"] diff --git a/dateparser_data/supplementary_language_data/date_translation_data/hi.yaml b/dateparser_data/supplementary_language_data/date_translation_data/hi.yaml index 4047c7e8a..bf4e9392a 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/hi.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/hi.yaml @@ -1,6 +1,12 @@ +minute: + - मि +am: + - पूर्वाह्न +pm: + - अपराह्न skip: ["के", "को", "बजे", "सन्", "से"] -sentence_splitter_group : 3 +sentence_splitter_group: 3 september: - सितम्बर @@ -24,6 +30,7 @@ day: - दिवस hour: - घंटे + - घं ago: - पहले @@ -47,3 +54,15 @@ relative-type-regex: - (\d+[.,]?\d*) दशक पहले + \1 hour ago: + - (\d+[.,]?\d*) घं पहले + \1 minute ago: + - (\d+[.,]?\d*) मि पहले + \1 second ago: + - (\d+[.,]?\d*) से पहले + in \1 hour: + - (\d+[.,]?\d*) घं में + in \1 minute: + - (\d+[.,]?\d*) मि में + in \1 second: + - (\d+[.,]?\d*) से में diff --git a/dateparser_data/supplementary_language_data/date_translation_data/hsb.yaml b/dateparser_data/supplementary_language_data/date_translation_data/hsb.yaml new file mode 100644 index 000000000..a98389fdc --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/hsb.yaml @@ -0,0 +1,5 @@ +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute diff --git a/dateparser_data/supplementary_language_data/date_translation_data/hy.yaml b/dateparser_data/supplementary_language_data/date_translation_data/hy.yaml new file mode 100644 index 000000000..d6fe69e29 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/hy.yaml @@ -0,0 +1,9 @@ +am: + - կա +pm: + - կհ +relative-type: + 0 second ago: + - այժմ + 1 month ago: + - անցյալ ամիս diff --git a/dateparser_data/supplementary_language_data/date_translation_data/id.yaml b/dateparser_data/supplementary_language_data/date_translation_data/id.yaml index d02ada75c..05c13c00b 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/id.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/id.yaml @@ -1,12 +1,13 @@ skip: ["pukul", "tanggal", "yang"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 sunday: - Ahad august: - Agu + - agt september: - Sept @@ -29,6 +30,8 @@ relative-type: 0 second ago: - baru saja + in 1 month: + - bulan berikutnya relative-type-regex: \1 week ago: - (\d+[.,]?\d*) minggu lalu diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ig.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ig.yaml new file mode 100644 index 000000000..146090270 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ig.yaml @@ -0,0 +1,34 @@ +sunday: + - mbọsị ụka + - ụka +april: + - eprel +second: + - nkejinta +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - nnyaafụ + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/is.yaml b/dateparser_data/supplementary_language_data/date_translation_data/is.yaml new file mode 100644 index 000000000..633d07c0a --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/is.yaml @@ -0,0 +1,7 @@ +day: + - d +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute diff --git a/dateparser_data/supplementary_language_data/date_translation_data/it.yaml b/dateparser_data/supplementary_language_data/date_translation_data/it.yaml index f05e8fbdb..e10f98656 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/it.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/it.yaml @@ -1,6 +1,6 @@ skip: ["circa", "e", "alle"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 year: - anni @@ -14,8 +14,10 @@ hour: - ore minute: - minuti + - m second: - secondi + - sec ago: - fa @@ -27,5 +29,5 @@ relative-type: - altro ieri simplifications: - - (\d+[.,]?\d*)\s+ora: \1 ore + - (\d+[.,]?\d*)\s+ora: \1 ore - \bun[' ]ora\b: 1 ore diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml index 604d907b7..b8ecf50fa 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml @@ -1,6 +1,6 @@ no_word_spacing: "True" -sentence_splitter_group : 4 +sentence_splitter_group: 4 skip: ["約"] @@ -78,6 +78,12 @@ relative-type: in 2 day: - 明後日 + in 1 month: + - 翌月 + in 1 week: + - 翌週 + in 1 year: + - 翌年 simplifications: - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日: \1-\2-\3 - (\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日: \1-\2 diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ka.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ka.yaml index 6736b5b54..6d3642179 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ka.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ka.yaml @@ -1,6 +1,8 @@ +pm: + - შუადღ შემდეგ skip: ["და", "დაახლოებით", "ზე", "ის"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 year: - წლის diff --git a/dateparser_data/supplementary_language_data/date_translation_data/kea.yaml b/dateparser_data/supplementary_language_data/date_translation_data/kea.yaml new file mode 100644 index 000000000..863153037 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/kea.yaml @@ -0,0 +1,11 @@ +saturday: + - sabadu +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 second ago: + - now + in 1 day: + - manha diff --git a/dateparser_data/supplementary_language_data/date_translation_data/kl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/kl.yaml new file mode 100644 index 000000000..87e4bf430 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/kl.yaml @@ -0,0 +1,29 @@ +sunday: + - sab + - sabaat +january: + - januari +february: + - feb + - februari +march: + - martsi +april: + - aprili +may: + - maji +june: + - juni +july: + - juli +august: + - augustusi +september: + - sep + - septemberi +october: + - oktoberi +november: + - novemberi +december: + - decemberi diff --git a/dateparser_data/supplementary_language_data/date_translation_data/kok.yaml b/dateparser_data/supplementary_language_data/date_translation_data/kok.yaml new file mode 100644 index 000000000..6463f6771 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/kok.yaml @@ -0,0 +1,78 @@ +monday: + - सोम + - सोमवार +tuesday: + - मंगळ +wednesday: + - बुध +thursday: + - गुरु + - गुरुवार +friday: + - शुक्र + - शुक्रवार +saturday: + - शनि + - शनिवार +sunday: + - आदित्यवार + - रवि +april: + - एप्रिल +july: + - जुलै +august: + - ओगस्ट +september: + - सेप्टेंबर +october: + - ओक्टोबर +year: + - year +month: + - month +week: + - week +day: + - day +hour: + - hour +minute: + - minute +second: + - second +am: + - मपू +pm: + - मनं +relative-type: + 0 day ago: + - today + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - yesterday + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 day: + - tomorrow + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ks.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ks.yaml new file mode 100644 index 000000000..ddc642713 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ks.yaml @@ -0,0 +1,34 @@ +monday: + - ژٔنٛدرٕروار + - ژٔنٛدٕروار +tuesday: + - بوٚموار +thursday: + - برٛٮ۪سوار +may: + - میٔ +month: + - رٮ۪تھ +hour: + - گٲنٛٹہٕ +second: + - سٮ۪کَنڑ +relative-type: + 0 month ago: + - this month + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ky.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ky.yaml new file mode 100644 index 000000000..1261bedd9 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ky.yaml @@ -0,0 +1,3 @@ +relative-type: + in 1 day: + - эртеӊ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/lo.yaml b/dateparser_data/supplementary_language_data/date_translation_data/lo.yaml new file mode 100644 index 000000000..896078855 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/lo.yaml @@ -0,0 +1,3 @@ +relative-type-regex: + in \1 minute: + - (\d+[.,]?\d*) ໃນອີກ 0 ນາທີ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml b/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml new file mode 100644 index 000000000..bb4ecc8a8 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml @@ -0,0 +1,15 @@ +tuesday: + - вт +september: + - септ +november: + - ноем +am: + - претпладне +pm: + - попладне +relative-type: + 1 year ago: + - минатата година + in 1 year: + - следната година diff --git a/dateparser_data/supplementary_language_data/date_translation_data/mn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/mn.yaml new file mode 100644 index 000000000..896f91244 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/mn.yaml @@ -0,0 +1,13 @@ +june: + - зургадугаар сар +july: + - долдугаар сар +week: + - 7х +relative-type-regex: + \1 week ago: + - (\d+[.,]?\d*) 7х-ийн өмнө + in \1 day: + - (\d+[.,]?\d*) өдөрт + in \1 week: + - (\d+[.,]?\d*) 7х-ийн дараа diff --git a/dateparser_data/supplementary_language_data/date_translation_data/mr.yaml b/dateparser_data/supplementary_language_data/date_translation_data/mr.yaml new file mode 100644 index 000000000..ae6202bce --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/mr.yaml @@ -0,0 +1,4 @@ +am: + - मपू +pm: + - मउ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ms.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ms.yaml new file mode 100644 index 000000000..896d9c2ea --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ms.yaml @@ -0,0 +1,7 @@ +relative-type: + 0 week ago: + - mng ini + 1 week ago: + - mng lepas + in 1 week: + - mng depan diff --git a/dateparser_data/supplementary_language_data/date_translation_data/mt.yaml b/dateparser_data/supplementary_language_data/date_translation_data/mt.yaml new file mode 100644 index 000000000..c7391ae42 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/mt.yaml @@ -0,0 +1,14 @@ +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 second ago: + - now + 1 day ago: + - ilbieraħ + 1 year ago: + - is-sena li għaddiet +relative-type-regex: + \1 year ago: + - (\d+[.,]?\d*) snin ilu diff --git a/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml b/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml index e9fe0ed04..18853f703 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/nb.yaml @@ -24,6 +24,8 @@ relative-type-regex: \1 day ago: - for (\d+[.,]?\d*) dager siden + \1 year ago: + - –(\d+[.,]?\d*) år simplifications: - en: '1' - ett: '1' @@ -35,4 +37,4 @@ simplifications: - sju: '7' - åtte: '8' - ni: '9' - - ti: '10' \ No newline at end of file + - ti: '10' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ne.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ne.yaml new file mode 100644 index 000000000..8c883c9d3 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ne.yaml @@ -0,0 +1,18 @@ +may: + - मई +year: + - बर्ष +relative-type: + 0 hour ago: + - यो घडीमा + 0 second ago: + - अब + in 1 week: + - आउने हप्ता + in 1 year: + - अर्को वर्ष +relative-type-regex: + \1 second ago: + - (\d+[.,]?\d*) सेकेण्ड पहिले + in \1 second: + - (\d+[.,]?\d*) सेकेण्डमा diff --git a/dateparser_data/supplementary_language_data/date_translation_data/nn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/nn.yaml new file mode 100644 index 000000000..d7aeb8543 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/nn.yaml @@ -0,0 +1,61 @@ +am: + - formiddag +pm: + - ettermiddag +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year +relative-type-regex: + \1 day ago: + - for (\d+[.,]?\d*) døgn siden + \1 hour ago: + - for (\d+[.,]?\d*) time siden + - for (\d+[.,]?\d*) timer siden + \1 minute ago: + - for (\d+[.,]?\d*) minutt siden + - for (\d+[.,]?\d*) minutter siden + \1 month ago: + - for (\d+[.,]?\d*) måned siden + - for (\d+[.,]?\d*) måneder siden + \1 second ago: + - for (\d+[.,]?\d*) sekund siden + - for (\d+[.,]?\d*) sekunder siden + \1 week ago: + - for (\d+[.,]?\d*) uke siden + - for (\d+[.,]?\d*) uker siden + \1 year ago: + - for (\d+[.,]?\d*) år siden + in \1 hour: + - om (\d+[.,]?\d*) timer + in \1 minute: + - om (\d+[.,]?\d*) minutter + in \1 month: + - om (\d+[.,]?\d*) måned + - om (\d+[.,]?\d*) måneder + in \1 second: + - om (\d+[.,]?\d*) sekunder + in \1 week: + - om (\d+[.,]?\d*) uke + - om (\d+[.,]?\d*) uker diff --git a/dateparser_data/supplementary_language_data/date_translation_data/or.yaml b/dateparser_data/supplementary_language_data/date_translation_data/or.yaml new file mode 100644 index 000000000..25ee94973 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/or.yaml @@ -0,0 +1,45 @@ +year: + - year +month: + - month +week: + - week +day: + - day +hour: + - hour +minute: + - minute +second: + - second +relative-type: + 0 day ago: + - today + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - yesterday + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 day: + - tomorrow + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml index 609c8412a..e0aaa0830 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml @@ -1,4 +1,7 @@ -sentence_splitter_group : 1 +relative-type-regex: + \1 month ago: + - –(\d+[.,]?\d*) mies +sentence_splitter_group: 1 skip: ["i", "o", "r.", "roku", "w"] diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ps.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ps.yaml new file mode 100644 index 000000000..1a5a33d94 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ps.yaml @@ -0,0 +1,57 @@ +monday: + - دوشنبه +tuesday: + - سه‌شنبه +wednesday: + - چهارشنبه +thursday: + - پنجشنبه +saturday: + - شنبه +sunday: + - یکشنبه +year: + - year +month: + - month +week: + - week +day: + - day +hour: + - hour +minute: + - minute +second: + - second +relative-type: + 0 day ago: + - today + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - yesterday + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 day: + - tomorrow + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml b/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml index 48952b704..547b5cee1 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml @@ -1,7 +1,14 @@ +relative-type-regex: + \1 minute ago: + - há (\d+[.,]?\d*) mins + in \1 minute: + - em (\d+[.,]?\d*) mins + in \1 second: + - em (\d+[.,]?\d*) segs skip: ["cerca", "de", "e", "às"] pertain: ["de"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - Segunda @@ -31,8 +38,10 @@ hour: - horas minute: - minutos + - m second: - segundos + - s ago: - atrás diff --git a/dateparser_data/supplementary_language_data/date_translation_data/qu.yaml b/dateparser_data/supplementary_language_data/date_translation_data/qu.yaml new file mode 100644 index 000000000..fdf6188f3 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/qu.yaml @@ -0,0 +1,65 @@ +january: + - qul + - qulla puquy +february: + - hat + - hatun puquy +march: + - pau + - pauqar waray +april: + - ayr + - ayriwa +may: + - aym + - aymuray +june: + - int + - inti raymi +july: + - ant + - anta sitwa +august: + - qha + - qhapaq sitwa +september: + - uma + - uma raymi +october: + - kan + - kantaray +november: + - aya + - ayamarq'a +december: + - kap + - kapaq raymi +relative-type: + 0 day ago: + - today + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - yesterday + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 day: + - tomorrow + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/rm.yaml b/dateparser_data/supplementary_language_data/date_translation_data/rm.yaml new file mode 100644 index 000000000..93081f9ca --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/rm.yaml @@ -0,0 +1,9 @@ +day: + - tag +relative-type: + 0 year ago: + - this year + 1 year ago: + - last year + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ro.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ro.yaml index f8767b40e..dd2e3c61d 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ro.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ro.yaml @@ -1,6 +1,13 @@ +relative-type-regex: + \1 day ago: + - acum (\d+[.,]?\d*) zile + in \1 day: + - peste (\d+[.,]?\d*) zile + in \1 year: + - peste (\d+[.,]?\d*) ani skip: ["de", "la"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 wednesday: - Mi diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ru.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ru.yaml index a9d6b0557..2d2878fc0 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ru.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ru.yaml @@ -1,6 +1,15 @@ +am: + - дп +pm: + - пп +relative-type-regex: + \1 day ago: + - (\d+[.,]?\d*) д назад + in \1 day: + - через (\d+[.,]?\d*) д skip: ["в", "во", "и", "около", "примерно"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - пнд @@ -71,6 +80,8 @@ relative-type: in 3 day: - послепослезавтра + 0 hour ago: + - в этом часе simplifications: - од(ин|на|ну|ни|ной|ною|но|ного|ному|ним|нем): '1' - перв(ой|ого|ому|ым|ом|ая|ую|ое|ые|ых|ыми): '1' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/rw.yaml b/dateparser_data/supplementary_language_data/date_translation_data/rw.yaml new file mode 100644 index 000000000..9fcb71d19 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/rw.yaml @@ -0,0 +1,2 @@ +may: + - gicuransi diff --git a/dateparser_data/supplementary_language_data/date_translation_data/se.yaml b/dateparser_data/supplementary_language_data/date_translation_data/se.yaml new file mode 100644 index 000000000..ba69fb3cf --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/se.yaml @@ -0,0 +1,20 @@ +locale_specific: + se-FI: + monday: + - vuossárgga + tuesday: + - maŋŋebárgga + wednesday: + - gaskavahku + thursday: + - duorastaga + friday: + - bearjadaga + saturday: + - lávvardaga + relative-type: + 1 year ago: + - mannan jagi + relative-type-regex: + \1 year ago: + - (\d+[.,]?\d*) jagi árat diff --git a/dateparser_data/supplementary_language_data/date_translation_data/si.yaml b/dateparser_data/supplementary_language_data/date_translation_data/si.yaml new file mode 100644 index 000000000..4242f07fa --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/si.yaml @@ -0,0 +1,6 @@ +hour: + - පැ +minute: + - මි +second: + - ත diff --git a/dateparser_data/supplementary_language_data/date_translation_data/so.yaml b/dateparser_data/supplementary_language_data/date_translation_data/so.yaml new file mode 100644 index 000000000..f62f88c4a --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/so.yaml @@ -0,0 +1,77 @@ +tuesday: + - tal +wednesday: + - arb +thursday: + - kha +friday: + - jim +saturday: + - sab +january: + - kob +february: + - lab +march: + - sad +april: + - afr +may: + - sha +june: + - lix +july: + - tod +august: + - sid +september: + - sag +october: + - tob +november: + - kit +december: + - lit +year: + - year +month: + - month +week: + - week +day: + - day +hour: + - hour +minute: + - minute +second: + - second +am: + - sn +pm: + - gn +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sq.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sq.yaml new file mode 100644 index 000000000..4ae8bf635 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sq.yaml @@ -0,0 +1,4 @@ +july: + - kor +august: + - gsh diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sr-Cyrl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sr-Cyrl.yaml new file mode 100644 index 000000000..43f0301b1 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sr-Cyrl.yaml @@ -0,0 +1,26 @@ +month: + - м +week: + - н +am: + - пре подне +pm: + - по подне +locale_specific: + sr-Cyrl-BA: + tuesday: + - ут + wednesday: + - ср + september: + - септ + sr-Cyrl-ME: + tuesday: + - ут + wednesday: + - ср + sr-Cyrl-XK: + tuesday: + - ут + wednesday: + - ср diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sr-Latn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sr-Latn.yaml new file mode 100644 index 000000000..c547b6eeb --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sr-Latn.yaml @@ -0,0 +1,26 @@ +month: + - m +week: + - n +am: + - pre podne +pm: + - po podne +locale_specific: + sr-Latn-BA: + tuesday: + - ut + wednesday: + - sr + september: + - sept + sr-Latn-ME: + tuesday: + - ut + wednesday: + - sr + sr-Latn-XK: + tuesday: + - ut + wednesday: + - sr diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sr.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sr.yaml new file mode 100644 index 000000000..fca5ee98c --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sr.yaml @@ -0,0 +1,8 @@ +month: + - м +week: + - н +am: + - пре подне +pm: + - по подне diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml index 9bd0b2ad4..945174493 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml @@ -1,6 +1,13 @@ +relative-type-regex: + \1 minute ago: + - för (\d+[.,]?\d*) min sedan + \1 month ago: + - för (\d+[.,]?\d*) mån sedan + \1 second ago: + - för (\d+[.,]?\d*) sek sedan skip: ["den", "på"] -sentence_splitter_group : 1 +sentence_splitter_group: 1 monday: - Månd @@ -59,6 +66,8 @@ relative-type: in 1 day: - imorgon + 0 month ago: + - denna månad simplifications: - en: '1' - två: '2' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sw.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sw.yaml new file mode 100644 index 000000000..97ee0433e --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sw.yaml @@ -0,0 +1,4 @@ +am: + - asubuhi +pm: + - mchana diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ta.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ta.yaml new file mode 100644 index 000000000..464ca9d0b --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ta.yaml @@ -0,0 +1,3 @@ +relative-type-regex: + \1 week ago: + - (\d+[.,]?\d*) வாரத்திற்கு முன்பு diff --git a/dateparser_data/supplementary_language_data/date_translation_data/te.yaml b/dateparser_data/supplementary_language_data/date_translation_data/te.yaml new file mode 100644 index 000000000..bea41b68c --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/te.yaml @@ -0,0 +1,4 @@ +day: + - ది +minute: + - ని diff --git a/dateparser_data/supplementary_language_data/date_translation_data/th.yaml b/dateparser_data/supplementary_language_data/date_translation_data/th.yaml index 7047680a7..7da2a9bc2 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/th.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/th.yaml @@ -1,4 +1,6 @@ -sentence_splitter_group : 5 +minute: + - น +sentence_splitter_group: 5 skip: ["น.", "เมื่อ ", "เวลา"] diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ti.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ti.yaml new file mode 100644 index 000000000..49c487948 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ti.yaml @@ -0,0 +1,53 @@ +tuesday: + - ሠሉስ +thursday: + - ኃሙስ +year: + - year +month: + - month +week: + - week +day: + - day +hour: + - hour +minute: + - minute +second: + - second +am: + - ንጉሆ ሰዓተ +pm: + - ድሕር ሰዓት +relative-type: + 0 day ago: + - today + 0 hour ago: + - this hour + 0 minute ago: + - this minute + 0 month ago: + - this month + 0 second ago: + - now + 0 week ago: + - this week + 0 year ago: + - this year + 1 day ago: + - yesterday + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 day: + - tomorrow + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year diff --git a/dateparser_data/supplementary_language_data/date_translation_data/to.yaml b/dateparser_data/supplementary_language_data/date_translation_data/to.yaml new file mode 100644 index 000000000..25b3b3940 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/to.yaml @@ -0,0 +1,11 @@ +september: + - sep +am: + - am +pm: + - pm +relative-type: + 0 hour ago: + - this hour + 0 minute ago: + - this minute diff --git a/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml b/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml index 9bfae097f..ae68cc782 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml @@ -39,10 +39,23 @@ sunday: march: - берез +april: + - кві +may: + - тра +june: + - чер +august: + - сер september: - верес +october: + - жов november: - листоп + - лис +december: + - гру year: - р @@ -146,12 +159,16 @@ relative-type: - післязавтра relative-type-regex: + \1 day ago: + - (\d+[.,]?\d*) д тому \1 hour ago: - (\d+[.,]?\d*) година тому \1 minute ago: - (\d+[.,]?\d*) хвилина тому \1 second ago: - (\d+[.,]?\d*) секунда тому + in \1 day: + - за (\d+[.,]?\d*) д simplifications: - од(на|ну|ні|ної|нієї|ин|ній): '1' @@ -185,4 +202,4 @@ simplifications: - кілька секунд: 44 секунди - кілька хвилин: 2 хвилини - опів на: 30 хвилин - - за чверть: 15 хвилин \ No newline at end of file + - за чверть: 15 хвилин diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ur.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ur.yaml new file mode 100644 index 000000000..8a799fa15 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/ur.yaml @@ -0,0 +1,5 @@ +monday: + - سوموار +relative-type-regex: + in \1 hour: + - (\d+[.,]?\d*) گھنٹہ میں diff --git a/dateparser_data/supplementary_language_data/date_translation_data/uz-Latn.yaml b/dateparser_data/supplementary_language_data/date_translation_data/uz-Latn.yaml new file mode 100644 index 000000000..666e50391 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/uz-Latn.yaml @@ -0,0 +1,3 @@ +relative-type: + 1 year ago: + - o'tgan yil diff --git a/dateparser_data/supplementary_language_data/date_translation_data/uz.yaml b/dateparser_data/supplementary_language_data/date_translation_data/uz.yaml new file mode 100644 index 000000000..666e50391 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/uz.yaml @@ -0,0 +1,3 @@ +relative-type: + 1 year ago: + - o'tgan yil diff --git a/dateparser_data/supplementary_language_data/date_translation_data/yo.yaml b/dateparser_data/supplementary_language_data/date_translation_data/yo.yaml new file mode 100644 index 000000000..26076d8fe --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/yo.yaml @@ -0,0 +1,25 @@ +week: + - ọ̀sè +relative-type: + 0 month ago: + - this month + 0 week ago: + - this week + 0 year ago: + - this year + 1 month ago: + - last month + 1 week ago: + - last week + 1 year ago: + - last year + in 1 month: + - next month + in 1 week: + - next week + in 1 year: + - next year +locale_specific: + yo-BJ: + week: + - ɔ̀sè diff --git a/dateparser_data/supplementary_language_data/date_translation_data/yue.yaml b/dateparser_data/supplementary_language_data/date_translation_data/yue.yaml index 9af8bed55..cf666fcdd 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/yue.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/yue.yaml @@ -1,3 +1,17 @@ +monday: + - 週一 +tuesday: + - 週二 +wednesday: + - 週三 +thursday: + - 週四 +friday: + - 週五 +saturday: + - 週六 +sunday: + - 週日 no_word_spacing: "True" -sentence_splitter_group : 4 +sentence_splitter_group: 4 diff --git a/dateparser_data/supplementary_language_data/date_translation_data/zh-Hant.yaml b/dateparser_data/supplementary_language_data/date_translation_data/zh-Hant.yaml index 9af8bed55..dffd770bf 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/zh-Hant.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/zh-Hant.yaml @@ -1,3 +1,26 @@ +locale_specific: + zh-Hant-HK: + relative-type: + 1 month ago: + - 上月 + in 1 month: + - 下月 + relative-type-regex: + \1 week ago: + - (\d+[.,]?\d*)週前 + in \1 week: + - (\d+[.,]?\d*)週後 + zh-Hant-MO: + relative-type: + 1 month ago: + - 上月 + in 1 month: + - 下月 + relative-type-regex: + \1 week ago: + - (\d+[.,]?\d*)週前 + in \1 week: + - (\d+[.,]?\d*)週後 no_word_spacing: "True" -sentence_splitter_group : 4 +sentence_splitter_group: 4 diff --git a/dateparser_data/supplementary_language_data/date_translation_data/zu.yaml b/dateparser_data/supplementary_language_data/date_translation_data/zu.yaml new file mode 100644 index 000000000..f7d5b27c4 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/zu.yaml @@ -0,0 +1,2 @@ +january: + - umasingana diff --git a/dateparser_scripts/get_cldr_data.py b/dateparser_scripts/get_cldr_data.py index 2e5b77185..ff3c0cded 100644 --- a/dateparser_scripts/get_cldr_data.py +++ b/dateparser_scripts/get_cldr_data.py @@ -5,7 +5,7 @@ import regex as re from dateparser_scripts.order_languages import _get_language_locale_dict -from dateparser_scripts.utils import get_dict_difference, get_raw_data +from dateparser_scripts.utils import get_dict_difference, get_raw_data, CLDR_JSON_DIR APOSTROPHE_LOOK_ALIKE_CHARS = [ "\N{RIGHT SINGLE QUOTATION MARK}", # '\u2019' @@ -29,8 +29,6 @@ PM_PATTERN = re.compile(r"^\s*[Pp]\s*\.?\s*[Mm]\s*\.?\s*$") PARENTHESIS_PATTERN = re.compile(r"[\(\)]") -cldr_dates_full_dir = "../raw_data/cldr_dates_full/main/" - def _filter_relative_string(relative_string): return ( @@ -45,18 +43,27 @@ def _filter_month_name(month_name): def _retrieve_locale_data(locale): - ca_gregorian_file = cldr_dates_full_dir + locale + "/ca-gregorian.json" - dateFields_file = cldr_dates_full_dir + locale + "/dateFields.json" - with open(ca_gregorian_file) as f: - cldr_gregorian_data = json.load(f) + def load(scope, file_id): + file_path = ( + CLDR_JSON_DIR + / "cldr-json" + / f"cldr-{scope}-full" + / "main" + / locale + / f"{file_id}.json" + ) + with file_path.open() as f: + return json.load(f) - with open(dateFields_file) as g: - cldr_datefields_data = json.load(g) + cldr_gregorian_data = load("dates", "ca-gregorian") + cldr_datefields_data = load("dates", "dateFields") + _units = load("units", "units") gregorian_dict = cldr_gregorian_data["main"][locale]["dates"]["calendars"][ "gregorian" ] date_fields_dict = cldr_datefields_data["main"][locale]["dates"]["fields"] + units = _units["main"][locale]["units"]["long"] json_dict = {} @@ -286,6 +293,9 @@ def _retrieve_locale_data(locale): json_dict["day"] = [date_fields_dict[key]["displayName"] for key in day_keys] json_dict["hour"] = [date_fields_dict[key]["displayName"] for key in hour_keys] + hour_unit = units["duration-hour"]["displayName"] + if hour_unit not in json_dict["hour"]: + json_dict["hour"].append(hour_unit) json_dict["minute"] = [date_fields_dict[key]["displayName"] for key in minute_keys] diff --git a/dateparser_scripts/order_languages.py b/dateparser_scripts/order_languages.py index bdf67d7a7..14b32d163 100644 --- a/dateparser_scripts/order_languages.py +++ b/dateparser_scripts/order_languages.py @@ -5,23 +5,174 @@ import requests from parsel import Selector -from dateparser_scripts.utils import get_raw_data +from dateparser_scripts.utils import get_raw_data, CLDR_JSON_DIR os.chdir(os.path.dirname(os.path.abspath(__file__))) # Languages with insufficient translation data are excluded avoid_languages = {"cu", "kkj", "nds", "prg", "tk", "vai", "vai-Latn", "vai-Vaii", "vo"} +# Locales that CLDR 44 introduced but which dateparser does not enable yet: enabling +# them expands language auto-detection (and, for many, requires supplementary data), +# so they are handled separately from this data refresh to keep the supported set +# stable. This keeps the generated data limited to the locales already shipped. +cldr_44_new_languages = { + "aa", + "ab", + "an", + "ann", + "apc", + "arn", + "az-Arab", + "ba", + "bal", + "bal-Arab", + "bal-Latn", + "be-tarask", + "bew", + "bgc", + "bgn", + "bho", + "blo", + "blt", + "bm-Nkoo", + "bss", + "byn", + "ca-ES-valencia", + "cad", + "cch", + "ccp", + "ceb", + "cho", + "cic", + "co", + "csw", + "cv", + "doi", + "dv", + "el-polyton", + "en-Dsrt", + "en-Shaw", + "ff-Adlm", + "ff-Latn", + "frr", + "gaa", + "gez", + "gn", + "ha-Arab", + "hi-Latn", + "hnj", + "hnj-Hmnp", + "ia", + "ie", + "io", + "iu", + "iu-Latn", + "jbo", + "jv", + "kaj", + "kcg", + "ken", + "kgp", + "kpe", + "ks-Arab", + "ks-Deva", + "ku", + "kxv", + "kxv-Deva", + "kxv-Latn", + "kxv-Orya", + "kxv-Telu", + "la", + "lij", + "lmo", + "mai", + "mdf", + "mi", + "mic", + "mn-Mong", + "mni", + "mni-Beng", + "mni-Mtei", + "moh", + "ms-Arab", + "mus", + "myv", + "no", + "nqo", + "nr", + "nso", + "nv", + "ny", + "oc", + "osa", + "pap", + "pcm", + "pis", + "quc", + "raj", + "rhg", + "rhg-Rohg", + "rif", + "sa", + "sat", + "sat-Deva", + "sat-Olck", + "sc", + "scn", + "sd", + "sd-Arab", + "sd-Deva", + "sdh", + "shn", + "sid", + "skr", + "sma", + "smj", + "sms", + "ss", + "ssy", + "st", + "su", + "su-Latn", + "syr", + "szl", + "tg", + "tig", + "tn", + "tok", + "tpi", + "trv", + "trw", + "ts", + "tt", + "tyv", + "und", + "ve", + "vec", + "vmw", + "wa", + "wal", + "wbp", + "wo", + "xh", + "xnr", + "yrl", + "yue-Hans", + "yue-Hant", + "za", +} +avoid_languages |= cldr_44_new_languages + def _get_language_locale_dict(): - cldr_dates_full_dir = "../raw_data/cldr_dates_full/main/" + cldr_dates_full_dir = CLDR_JSON_DIR / "cldr-json/cldr-dates-full/main/" available_locale_names = os.listdir(cldr_dates_full_dir) available_language_names = [ shortname for shortname in available_locale_names if not re.search(r"-[A-Z0-9]+$", shortname) ] - available_language_names.remove("root") language_locale_dict = {} for language_name in available_language_names: language_locale_dict[language_name] = [] @@ -105,7 +256,9 @@ def get_most_common_locales(): return old_common_locales return new_most_common_locales - territory_info_file = "../raw_data/cldr_core/supplemental/territoryInfo.json" + territory_info_file = ( + CLDR_JSON_DIR / "cldr-json/cldr-core/supplemental/territoryInfo.json" + ) with open(territory_info_file) as f: territory_content = json.load(f) territory_info_data = territory_content["supplemental"]["territoryInfo"] diff --git a/dateparser_scripts/utils.py b/dateparser_scripts/utils.py index feae9fb3a..020689175 100644 --- a/dateparser_scripts/utils.py +++ b/dateparser_scripts/utils.py @@ -1,37 +1,21 @@ import os import shutil +from pathlib import Path from git import Repo -def get_raw_data(): - cldr_version = "31.0.1" - raw_data_directory = "../raw_data" +CLDR_JSON_DIR = (Path(__file__).parent / "../cldr-json").resolve() - cldr_data = { - "dates_full": { - "url": "https://github.com/unicode-cldr/cldr-dates-full.git", - "dir": "{}/cldr_dates_full/".format(raw_data_directory), - }, - "core": { - "url": "https://github.com/unicode-cldr/cldr-core.git", - "dir": "{}/cldr_core/".format(raw_data_directory), - }, - "rbnf": { - "url": "https://github.com/unicode-cldr/cldr-rbnf.git", - "dir": "{}/cldr_rbnf/".format(raw_data_directory), - }, - } - if os.path.isdir(raw_data_directory): - # remove current raw data - shutil.rmtree(raw_data_directory) - os.mkdir(raw_data_directory) +def get_raw_data(): + cldr_version = "44.1.0" + url = "https://github.com/unicode-org/cldr-json.git" + if os.path.isdir(CLDR_JSON_DIR): + shutil.rmtree(CLDR_JSON_DIR) - for name, data in cldr_data.items(): - print('Clonning "{}" from: {}'.format(name, data["url"])) - repo = Repo.clone_from(data["url"], data["dir"], branch="master") - repo.git.co(cldr_version) + print(f"Clonning {url} @ {cldr_version} on {CLDR_JSON_DIR}...") + Repo.clone_from(url, CLDR_JSON_DIR, branch=cldr_version, depth=1) def get_dict_difference(parent_dict, child_dict): diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index b888b31be..39c991f90 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -1,6 +1,7 @@ import json import os import shutil +from pathlib import Path import regex as re from ruamel.yaml import YAML @@ -8,15 +9,15 @@ from dateparser_scripts.order_languages import avoid_languages from dateparser_scripts.utils import combine_dicts -cldr_date_directory = "../dateparser_data/cldr_language_data/date_translation_data/" -supplementary_directory = "../dateparser_data/supplementary_language_data/" +root = Path(__file__).parent.parent + +cldr_date_directory = root / "dateparser_data/cldr_language_data/date_translation_data" +supplementary_directory = root / "dateparser_data/supplementary_language_data" supplementary_date_directory = ( - "../dateparser_data/supplementary_language_data/date_translation_data/" + root / "dateparser_data/supplementary_language_data/date_translation_data" ) -translation_data_directory = "../dateparser/data/" -date_translation_directory = "../dateparser/data/date_translation_data/" - -os.chdir(os.path.dirname(os.path.abspath(__file__))) +translation_data_directory = root / "dateparser/data" +date_translation_directory = root / "dateparser/data/date_translation_data" cldr_languages = list( set(map(lambda x: x[:-5], os.listdir(cldr_date_directory))) - avoid_languages @@ -85,10 +86,10 @@ def _get_complete_date_translation_data(language): cldr_data = {} supplementary_data = {} if language in cldr_languages: - with open(cldr_date_directory + language + ".json") as f: + with open(cldr_date_directory / f"{language}.json") as f: cldr_data = json.load(f) if language in supplementary_languages: - with open(supplementary_date_directory + language + ".yaml") as g: + with open(supplementary_date_directory / f"{language}.yaml") as g: yaml = YAML() supplementary_data = dict(yaml.load(g)) complete_data = combine_dicts(cldr_data, supplementary_data) @@ -122,7 +123,7 @@ def write_complete_data(in_memory=False): shutil.rmtree(date_translation_directory) os.mkdir(date_translation_directory) - with open(supplementary_directory + "base_data.yaml") as f: + with open(supplementary_directory / "base_data.yaml") as f: yaml = YAML() base_data = yaml.load(f) @@ -136,7 +137,7 @@ def write_complete_data(in_memory=False): ) out_text = ("info = " + translation_data + "\n").encode("utf-8") _write_file( - date_translation_directory + language + ".py", + date_translation_directory / f"{language}.py", out_text, "wb", in_memory, @@ -145,18 +146,19 @@ def write_complete_data(in_memory=False): init_text = ( "from dateparser.data import date_translation_data\n" - "from .languages_info import language_order, language_locale_dict\n" + "\n" + "from .languages_info import language_locale_dict, language_order\n" ) _write_file( - translation_data_directory + "__init__.py", + translation_data_directory / "__init__.py", init_text, "w", False, in_memory_result, ) _write_file( - date_translation_directory + "__init__.py", "", "w", False, in_memory_result + date_translation_directory / "__init__.py", "", "w", False, in_memory_result ) return in_memory_result diff --git a/tests/test_clean_api.py b/tests/test_clean_api.py index 5f75f81d9..3d5b60583 100644 --- a/tests/test_clean_api.py +++ b/tests/test_clean_api.py @@ -111,6 +111,20 @@ def test_dates_which_match_locales_are_parsed( self.when_date_is_parsed(date_string, locales=locales) self.then_parsed_date_is(expected_date) + @parameterized.expand( + [ + param(date_string="6 yar 2019", locales=["ff-CM"]), + param(date_string="6 yar 2019", locales=["ff-GN"]), + param(date_string="6 yar 2019", locales=["ff-MR"]), + ] + ) + def test_locales_dropped_in_cldr_44_remain_supported(self, date_string, locales): + # ff-CM/ff-GN/ff-MR were standalone locales up to CLDR 31 but were dropped in + # CLDR 44 (regional data moved under ff-Latn). They remain valid locale codes + # and resolve to the base `ff` data, so existing callers keep working. + self.when_date_is_parsed(date_string, locales=locales) + self.then_parsed_date_is(date(2019, 10, 6)) + @parameterized.expand( [ param( diff --git a/tests/test_languages.py b/tests/test_languages.py index 88fcb1f4b..757460c55 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1474,6 +1474,8 @@ def test_translation(self, shortname, datetime_string, expected_translation): param("bs", "ovaj sat", "0 hour ago"), # ca param("ca", "d'aquí a 22 hores", "in 22 hour"), + # standalone hour unit, added from the CLDR "duration-hour" unit data + param("ca", "2 hores", "2 hour"), param("ca", "fa 17 anys", "17 year ago"), param("ca", "el mes passat", "1 month ago"), param("ca", "la pròxima setmana", "in 1 week"), diff --git a/tests/test_search.py b/tests/test_search.py index eea9360f0..1d6993d27 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -259,8 +259,10 @@ def test_search_date_string(self, shortname, datetime_string): "Krigen i Europa begyndte den 1. september 1939, da Nazi-Tyskland invaderede Polen, " "og endte med Nazi-Tysklands betingelsesløse overgivelse den 8. maj 1945.", [ - ("1. september 1939", datetime.datetime(1939, 9, 1, 0, 0)), - ("8. maj 1945", datetime.datetime(1945, 5, 8, 0, 0)), + # "den" is a Danish skip word (as in "den 8. maj"), so it is + # included in the matched substring, like "de" in Spanish. + ("den 1. september 1939", datetime.datetime(1939, 9, 1, 0, 0)), + ("den 8. maj 1945", datetime.datetime(1945, 5, 8, 0, 0)), ], settings={"RELATIVE_BASE": datetime.datetime(2000, 1, 1)}, ), From cf6d3e541c01ebb5f5249ed2c8ed97b60d5dd59d Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 22 Jul 2026 10:59:52 +0200 Subject: [PATCH 042/107] Add "ngram" search strategy to search_dates (#1351) The new strategy tokenizes the text on characters that never occur inside a date expression and tries to parse token n-grams, longest first, so that the most complete date is found. Compared to the default translation-based "split" strategy it produces more predictable results on noisy real-world text. The strategy is exposed through the new "strategy" parameter of search_dates and defaults to the existing behavior. --- dateparser/search/__init__.py | 9 +++ dateparser/search/ngram_search.py | 107 +++++++++++++++++++++++++++ dateparser/search/search.py | 52 ++++++++++---- tests/test_search.py | 115 ++++++++++++++++++++++++++++++ 4 files changed, 271 insertions(+), 12 deletions(-) create mode 100644 dateparser/search/ngram_search.py diff --git a/dateparser/search/__init__.py b/dateparser/search/__init__.py index a1707b679..7016c6fcd 100644 --- a/dateparser/search/__init__.py +++ b/dateparser/search/__init__.py @@ -9,6 +9,7 @@ def search_dates( settings=None, add_detected_language=False, detect_languages_function=None, + strategy="split", ): """Find all substrings of the given string which represent date and/or time and parse them. @@ -35,6 +36,13 @@ def search_dates( Note: detect_languages_function is only uses if `languages` are not provided. :type detect_languages_function: function + :param strategy: + The search strategy to use: "split" (default) translates the text and splits it + into chunks that are likely to contain dates, while "ngram" tries to parse the + longest possible sequences of tokens as dates. The "ngram" strategy tends to + produce more predictable results, at the cost of more parse attempts. + :type strategy: str + :return: Returns list of tuples containing: substrings representing date and/or time, corresponding :mod:`datetime.datetime` object and detected language if *add_detected_language* is True. @@ -64,6 +72,7 @@ def search_dates( languages=languages, settings=settings, detect_languages_function=detect_languages_function, + strategy=strategy, ) dates = result.get("Dates") if dates: diff --git a/dateparser/search/ngram_search.py b/dateparser/search/ngram_search.py new file mode 100644 index 000000000..56957a7f7 --- /dev/null +++ b/dateparser/search/ngram_search.py @@ -0,0 +1,107 @@ +"""Date search based on parsing token n-grams. + +This module implements an alternative strategy for +:func:`dateparser.search.search_dates` that looks for the longest sequences +of tokens that can be parsed as dates. It originates from a production date +extraction pipeline where it consistently produced more predictable results +than the translation-based search. +""" + +import logging + +import regex as re + +from dateparser.date import DateDataParser + +logger = logging.getLogger(__name__) + +# Characters that never occur inside a date expression and can therefore be +# used to split a text into tokens. Unlike whitespace, ",", "|", "(", ")" +# and "@", characters such as ".", "/", "-" and ":" *can* be part of a date +# (e.g. "1.10.2020", "2020-10-01", "10:30") and must not be split on. +_TOKEN_RE = re.compile(r"[^\s,|()@]+") + +# Words that often connect a date to the surrounding text and cause +# annoying false positives; dropping them allows parsing token sequences +# such as "on May 6th 2004" or "6 of October". +_NOISE_TOKENS = frozenset(["on", "at", "of", "a"]) + +# Whole candidates that are blacklisted because they are known to produce +# false positives. They can still be parsed as part of a longer candidate. +_BAD_CANDIDATE_RE = re.compile( + "^(" + + "|".join( + [ + r"\d{1,3}", # bare numbers of less than 4 digits + r"#\d+", # sequence numbers + r"[-/.]+", # bare separators, parsed as the current date + r"\w\.?", # single letters, with an optional dot + "an", # parsed as a year in some languages + ] + ) + + ")$" +) + +# Punctuation stripped from the returned substrings, matching the behavior +# of the translation-based search strategy. +_STRIP_CHARS = " .,:()[]-'" + + +class _NgramDateSearch: + """Search for dates by trying to parse token n-grams, longest first. + + The text is split into tokens using characters that never occur inside + a date expression as separators. The tokens are then scanned left to + right; at each position the longest n-gram (up to ``max_tokens`` + tokens) is tried first, so that the most complete date is parsed. + Whenever an n-gram is parsed successfully, the scan continues after it, + so the reported dates never overlap. + """ + + def __init__(self, max_tokens=7): + self.max_tokens = max_tokens + + def search_parse(self, languages, text, settings): + """Find all dates in ``text`` and return ``(substring, date)`` pairs. + + ``languages`` are tried in the given order for every candidate + n-gram. + """ + parser = DateDataParser( + languages=languages, use_given_order=True, settings=settings + ) + tokens = [ + token + for token in _TOKEN_RE.finditer(text) + if token.group() not in _NOISE_TOKENS + ] + results = [] + index = 0 + while index < len(tokens): + for size in range(min(self.max_tokens, len(tokens) - index), 0, -1): + ngram = tokens[index : index + size] + candidate = " ".join(token.group() for token in ngram) + if _BAD_CANDIDATE_RE.match(candidate): + continue + date_obj = self._parse_candidate(parser, candidate, languages) + if date_obj is not None: + substring = text[ngram[0].start() : ngram[-1].end()] + results.append((substring.strip(_STRIP_CHARS), date_obj)) + index += size + break + else: + index += 1 + return results + + @staticmethod + def _parse_candidate(parser, candidate, languages): + try: + return parser.get_date_data(candidate).date_obj + except Exception: + logger.warning( + "Failed to parse %r (languages=%r)", + candidate, + languages, + exc_info=True, + ) + return None diff --git a/dateparser/search/search.py b/dateparser/search/search.py index 6d39c7570..873598f02 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -7,6 +7,7 @@ from dateparser.custom_language_detection.language_mapping import map_languages from dateparser.date import DateDataParser from dateparser.languages.loader import LocaleDataLoader +from dateparser.search.ngram_search import _NgramDateSearch from dateparser.search.text_detection import FullTextLanguageDetector from dateparser.utils.time_spans import detect_time_span, generate_time_span @@ -17,6 +18,19 @@ def date_is_relative(translation): return re.search(RELATIVE_REG, translation) is not None +def _add_time_span_results(results, text, settings): + """Append time span start/end dates if RETURN_TIME_SPAN is enabled.""" + if getattr(settings, "RETURN_TIME_SPAN", False): + span_info = detect_time_span(text) + if span_info: + base_date = getattr(settings, "RELATIVE_BASE", None) or datetime.now() + start_date, end_date = generate_time_span(span_info, base_date, settings) + matched_text = span_info["matched_text"] + results.append((matched_text + " (start)", start_date)) + results.append((matched_text + " (end)", end_date)) + return results + + class _ExactLanguageSearch: def __init__(self, loader): self.loader = loader @@ -190,17 +204,7 @@ def search_parse(self, shortname, text, settings): results = list(zip(substrings, [i[0]["date_obj"] for i in parsed])) - if getattr(settings, "RETURN_TIME_SPAN", False): - span_info = detect_time_span(text) - if span_info: - base_date = getattr(settings, "RELATIVE_BASE", None) or datetime.now() - start_date, end_date = generate_time_span( - span_info, base_date, settings - ) - - matched_text = span_info["matched_text"] - results.append((matched_text + " (start)", start_date)) - results.append((matched_text + " (end)", end_date)) + _add_time_span_results(results, text, settings) parser._settings = Settings() return results @@ -217,6 +221,7 @@ def __init__(self): self.loader = LocaleDataLoader() self.available_language_map = self.loader.get_locale_map() self.search = _ExactLanguageSearch(self.loader) + self.ngram_search = _NgramDateSearch() def _get_candidate_languages(self, detected_language, languages): candidates = [] @@ -279,7 +284,12 @@ def detect_language( @apply_settings def search_dates( - self, text, languages=None, settings=None, detect_languages_function=None + self, + text, + languages=None, + settings=None, + detect_languages_function=None, + strategy="split", ): """ Find all substrings of the given string which represent date and/or time and parse them. @@ -302,6 +312,13 @@ def search_dates( returns a list of detected language codes. :type detect_languages_function: function + :param strategy: + The search strategy to use: "split" (default) translates the text and splits it + into chunks that are likely to contain dates, while "ngram" tries to parse the + longest possible sequences of tokens as dates. The "ngram" strategy tends to + produce more predictable results, at the cost of more parse attempts. + :type strategy: str + :return: a dict mapping keys to two letter language code and a list of tuples of pairs: substring representing date expressions and corresponding :mod:`datetime.datetime` object. For example: @@ -310,6 +327,10 @@ def search_dates( {'Language': None, 'Dates': None} :raises: ValueError - Unknown Language """ + if strategy not in ("split", "ngram"): + raise ValueError( + 'strategy must be "split" or "ngram" (%r given)' % strategy + ) check_settings(settings) @@ -326,6 +347,13 @@ def search_dates( if not candidate_languages: return {"Language": None, "Dates": None} + if strategy == "ngram": + dates = self.ngram_search.search_parse( + candidate_languages, text, settings=settings + ) + _add_time_span_results(dates, text, settings) + return {"Language": language_shortname, "Dates": dates} + for candidate_language in candidate_languages: dates = self.search.search_parse( candidate_language, text, settings=settings diff --git a/tests/test_search.py b/tests/test_search.py index 1d6993d27..1428e9e14 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1341,3 +1341,118 @@ def test_search_dates_time_span_disabled_by_default(self): if result: span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] self.assertEqual(len(span_results), 0) + + +class TestNgramSearch(BaseTestCase): + def setUp(self): + super().setUp() + self.search_with_detection = DateSearchWithDetection() + + @parameterized.expand( + [ + # noise words ("on") are not part of the returned substring and + # trailing punctuation is stripped + param( + "en", + text="The first artificial Earth satellite was launched" + " on 4 October 1957.", + expected=[("4 October 1957", datetime.datetime(1957, 10, 4))], + ), + # all non-overlapping dates are returned, longest match first + param( + "en", + text="The client arrived to the office for the first time" + " in March 3rd, 2004 and got serviced, after a couple of months," + " on May 6th 2004, the customer returned indicating a defect on" + " the part", + expected=[ + ("in March 3rd, 2004 and", datetime.datetime(2004, 3, 3)), + ("May 6th 2004, the", datetime.datetime(2004, 5, 6)), + ], + ), + # bare small numbers are blacklisted and do not produce dates + param("en", text="Chapter 12, page 3", expected=[]), + # French + param( + "fr", + text="Publié le 11 juillet 2016", + expected=[("le 11 juillet 2016", datetime.datetime(2016, 7, 11))], + ), + param( + "fr", + text="Le premier satellite artificiel, lancé le 4 octobre 1957," + " pesait 83 kg", + expected=[("le 4 octobre 1957", datetime.datetime(1957, 10, 4))], + ), + # Russian + param( + "ru", + text="веб-страница обновлена 11 июля 2016 года", + expected=[("11 июля 2016 года", datetime.datetime(2016, 7, 11))], + ), + ] + ) + def test_ngram_search(self, shortname, text, expected): + result = self.search_with_detection.search_dates( + text, languages=[shortname], strategy="ngram" + ) + self.assertEqual(result["Language"], shortname) + self.assertEqual(result["Dates"], expected) + + def test_ngram_search_with_relative_base(self): + result = self.search_with_detection.search_dates( + "posted 10 minutes ago", + languages=["en"], + settings={"RELATIVE_BASE": datetime.datetime(2020, 1, 1, 12, 0)}, + strategy="ngram", + ) + self.assertEqual( + result["Dates"], + [("10 minutes ago", datetime.datetime(2020, 1, 1, 11, 50))], + ) + + def test_ngram_search_returns_time_spans(self): + result = self.search_with_detection.search_dates( + "messages received for the past week", + languages=["en"], + settings={ + "RETURN_TIME_SPAN": True, + "RELATIVE_BASE": datetime.datetime(2025, 2, 15, 12, 0), + }, + strategy="ngram", + ) + self.assertEqual( + result["Dates"], + [ + ("for the past week (start)", datetime.datetime(2025, 2, 3, 12, 0)), + ("for the past week (end)", datetime.datetime(2025, 2, 9, 12, 0)), + ], + ) + + def test_search_dates_with_ngram_strategy(self): + result = search_dates( + "launched on 4 October 1957", languages=["en"], strategy="ngram" + ) + self.assertEqual(result, [("4 October 1957", datetime.datetime(1957, 10, 4))]) + + def test_search_dates_with_ngram_strategy_and_detected_language(self): + result = search_dates( + "launched on 4 October 1957", + languages=["en"], + strategy="ngram", + add_detected_language=True, + ) + self.assertEqual( + result, [("4 October 1957", datetime.datetime(1957, 10, 4), "en")] + ) + + def test_search_dates_ngram_strategy_returns_none_when_no_dates_found(self): + self.assertIsNone( + search_dates( + "Hello world nothing here at all", languages=["en"], strategy="ngram" + ) + ) + + def test_unknown_strategy_raises_error(self): + with self.assertRaisesRegex(ValueError, "strategy must be"): + search_dates("4 October 1957", languages=["en"], strategy="unknown") From 315e396b35cf131df1b8df15144fe2d60aa6d74a Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 23 Jul 2026 14:34:36 +0200 Subject: [PATCH 043/107] Fix ISO8601 parsing with explicit languages (#1352) Close #360 --- dateparser/parser.py | 18 +++++++++++++++++- tests/test_date_parser.py | 26 ++++++++++++++++++++++++++ 2 files changed, 43 insertions(+), 1 deletion(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 54bde2ceb..1f56515fc 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -633,7 +633,23 @@ def set_and_return(token, type, component, dateobj, skip_date_order=False): def parse_number(token, skip_component=None): type = 0 - for component, directives in self.ordered_num_directives.items(): + num_directives = self.ordered_num_directives + if ( + skip_component == "year" + and self.day is None + and self.month is None + and "DATE_ORDER" not in self.settings._mod_settings + ): + # The date string starts with a four-digit year (e.g. an + # ISO 8601 date like "2017-06-22"), so the remaining numeric + # components are expected in month-day order, regardless of + # the locale date order, unless the caller explicitly set + # DATE_ORDER (#360). + num_directives = { + k: self.num_directives[k] for k in ("month", "day", "year") + } + + for component, directives in num_directives.items(): if skip_component == component: continue for directive in directives: diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 4bbf36c55..012c8a956 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -929,6 +929,32 @@ def test_iso_datestamp_format_should_always_parse( self.result["date_obj"] = self.result["date_obj"].replace(tzinfo=None) self.then_date_obj_exactly_is(expected) + @parameterized.expand( + [ + param("2017-06-22", languages=["it"], expected=datetime(2017, 6, 22)), + param("2017-06-10", languages=["it"], expected=datetime(2017, 6, 10)), + param("2017-06-22", languages=["fr"], expected=datetime(2017, 6, 22)), + param( + "2015-05-02T10:20:19+0000", + languages=["fr"], + expected=datetime(2015, 5, 2, 10, 20, 19), + ), + ] + ) + def test_iso_datestamp_format_should_parse_with_locale_date_order( + self, date_string, languages, expected + ): + # Regression test for #360: dates starting with a four-digit year + # (e.g. ISO 8601 dates) must parse even when the locale date order + # is not year-first (Italian and French use DMY), without needing + # the PREFER_LOCALE_DATE_ORDER=False workaround. + self.given_local_tz_offset(0) + self.given_parser(languages=languages) + self.when_date_is_parsed(date_string) + self.then_date_was_parsed_by_date_parser() + self.result["date_obj"] = self.result["date_obj"].replace(tzinfo=None) + self.then_date_obj_exactly_is(expected) + @parameterized.expand( [ # Epoch timestamps. From 06ca032deff4d5eec281af4030f34b46e9fe7adc Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 29 Jul 2026 10:06:11 +0200 Subject: [PATCH 044/107] Do not read the day as a two-digit year after the year position (#1358) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Improve Czech (cs) language data (#1172) - Add month locative/dative forms (lednu, únoru, březnu, dubnu, květnu, červnu, červenci, srpnu, říjnu, prosinci) for dates like "v lednu 2023" - Add July abbreviation "črv" - Fix "za měsíc/týden/rok" not parsing: add accusative simplification patterns (previous patterns only matched instrumental -em forms) - Add tests covering the new expressions Co-Authored-By: Claude Sonnet 4.6 (1M context) * Do not read the day as a two-digit year after the year position (Close #519) In year-first date orders (e.g. YMD, used by the Japanese locale), parse_number tried the %y directive on every two-digit number, so in "4月20日 18:10" the day 20 was consumed as the year 2020 and the day was silently filled from the current date. If a component that the date order places after the year has already been found, the year position in the date string has already been passed, so a two-digit number is now read as a year only if it cannot be any other component (e.g. 99 in "4-99"). --------- Co-authored-by: Claude Sonnet 4.6 (1M context) --- dateparser/parser.py | 70 +++++++++++++++++++++++++-------------- tests/test_date_parser.py | 51 ++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+), 24 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 1f56515fc..1f3e4719c 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -649,31 +649,53 @@ def parse_number(token, skip_component=None): k: self.num_directives[k] for k in ("month", "day", "year") } - for component, directives in num_directives.items(): - if skip_component == component: - continue - for directive in directives: - try: - do = self._get_date_obj(token, directive) - prev_value = getattr(self, component, None) - if not prev_value: - return set_and_return(token, type, component, do) - else: - try: - prev_token, prev_type = getattr( - self, "_token_%s" % component - ) - if prev_type == type: - do = self._get_date_obj(prev_token, directive) - except ValueError: - self.unset_tokens.append( - (prev_token, prev_type, component) - ) + def try_directives(skip_directive=None): + for component, directives in num_directives.items(): + if skip_component == component: + continue + for directive in directives: + if directive == skip_directive: + continue + try: + do = self._get_date_obj(token, directive) + prev_value = getattr(self, component, None) + if not prev_value: return set_and_return(token, type, component, do) - except ValueError: - pass - else: - raise ValueError("Unable to parse: %s" % token) + else: + try: + prev_token, prev_type = getattr( + self, "_token_%s" % component + ) + if prev_type == type: + do = self._get_date_obj(prev_token, directive) + except ValueError: + self.unset_tokens.append( + (prev_token, prev_type, component) + ) + return set_and_return(token, type, component, do) + except ValueError: + pass + else: + raise ValueError("Unable to parse: %s" % token) + + order = list(self.ordered_num_directives) + components_after_year = order[order.index("year") + 1 :] + year_position_already_passed = any( + getattr(self, component) is not None + for component in components_after_year + ) + if year_position_already_passed: + # A component that the date order places after the year has + # already been found, so the year position in the date string + # has already been passed and this number cannot be a + # two-digit year: in "4月20日" ("April 20"), 20 is the day, + # not the year 2020 (#519). Read it as a two-digit year only + # if it cannot be anything else (e.g. 99 in "4-99"). + try: + return try_directives(skip_directive="%y") + except ValueError: + pass + return try_directives() def parse_alpha(token, skip_component=None): type = 1 diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 012c8a956..b879017c0 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1186,6 +1186,57 @@ def test_order(self, date_string, expected=None, order=None): self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) + @parameterized.expand( + [ + # Japanese dates without a year: the day must not be read as + # a two-digit year just because the year comes first (#519). + param( + "4月20日 18:10", + expected=datetime(2019, 4, 20, 18, 10), + languages=["ja"], + ), + param( + "3月8日", + expected=datetime(2019, 3, 8, 0, 0), + languages=["ja"], + ), + # The root cause is locale-independent: any year-first date + # order must not consume the day as a year either. + param( + "4-20 18:10", + expected=datetime(2019, 4, 20, 18, 10), + settings={"DATE_ORDER": "YMD"}, + ), + # A number that cannot be a day is still parsed as a year. + param( + "4-99", + expected=datetime(1999, 4, 27, 0, 0), + settings={"DATE_ORDER": "YMD"}, + ), + # Fully specified dates keep their meaning. + param( + "2020年4月20日 18:10", + expected=datetime(2020, 4, 20, 18, 10), + languages=["ja"], + ), + param( + "19年4月20日", + expected=datetime(2019, 4, 20, 0, 0), + languages=["ja"], + ), + ] + ) + def test_two_digit_day_is_not_confused_with_year( + self, date_string, expected=None, languages=None, settings=None + ): + self.given_parser( + languages=languages, + settings={"RELATIVE_BASE": datetime(2019, 6, 27), **(settings or {})}, + ) + self.when_date_is_parsed(date_string) + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(expected) + @parameterized.expand( [ param("201508", expected=datetime(2015, 8, 20, 0, 0), order="DYM"), From d886e231f40e91f6bcb046dc4986e7e7efeaf937 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Mon, 3 Aug 2026 13:05:42 +0200 Subject: [PATCH 045/107] Parse dates wrapped in harmless extra text (Close #518) (#1356) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Parse dates wrapped in harmless extra text dateparser.parse() returned None for strings such as "Actualisé le 17 avril 2019" (fr) or "Published on 16 April 2019" (en): an unrecognised leading/trailing word makes the whole string fail the locale applicability check (Dictionary.are_tokens_valid), so no locale is ever tried and parsing gives up before it starts. When strict parsing of the whole string finds nothing and the language is known (given or detected), retry after stripping unrecognised words from the leading/trailing edges. Stripping is applied only when the surviving core is still a valid date for that locale AND it contains a month, weekday or relative expression, so genuine non-dates and bare numbers are not rescued and interior noise still fails. The fallback lives in dateparser.parse() only; get_date_data(), translation, applicability and search_dates() are left untouched, so language detection and date search keep their existing strictness. Related to #521: its search_dates facet is a separate translate_search chunking behaviour and is not addressed here; its parse facet ("Il giorno ...") additionally needs handling of a dangling unit word ("giorno" -> "day") and is left as a known limitation. Close #518 Co-Authored-By: Claude Opus 4.8 * Rework #518 fix as an opt-in IGNORE_SURROUNDING_TEXT setting Address review feedback on #1356: - Implement the fallback inside DateDataParser.get_date_data() behind a new IGNORE_SURROUNDING_TEXT setting (default off), so parse() and get_date_data() agree and every language hint source (languages, locales, region, DEFAULT_LANGUAGES, detect_languages_function, or none at all) behaves consistently. search_dates and language detection are unaffected by default. - Strip unknown edge tokens inside Locale.translate()/is_applicable() instead of re-joining raw tokens and re-entering the pipeline, so numerals translation, normalization and simplifications run exactly once and no fragile "".join() is needed. - Drop the month/weekday anchor heuristic and the magic KNOWN_WORD_TOKENS[:19] slice: the setting is explicit opt-in, so purely numeric dates, date_formats and relative expressions work too. - Parameterise _get_applicable_locales() instead of duplicating the locale enumeration; delete the dead code paths flagged in review (unreachable TypeError, no-op previous_locales write, dead default parameter). - Move parse()-level tests to test_clean_api.py, add locale-level tests to test_languages.py and parser-level tests to test_date.py; lock in that get_date_data and search_dates stay strict by default. - Document the new setting in docs/settings.rst. Co-Authored-By: Claude Fable 5 * Keep recognized trailing timezones when IGNORE_SURROUNDING_TEXT strips edges Follow-up to the review of #1356 (issue #518). When IGNORE_SURROUNDING_TEXT retries parsing after dropping unrecognized tokens from the edges of the string, Dictionary._strip_unknown_edge_tokens() judged a token "known" via token.isdigit(), a relative-expression match, or membership in the locale dictionary. The only timezone-shaped strings the dictionary lists are ["am", "pm", "UTC", "GMT", "Z"], so every other recognized zone abbreviation (EST, PST, CET, ...) was treated as noise and stripped off the trailing edge before translation. As a result parse('Updated 23 March 2000 1:21 PM EST', settings={'IGNORE_SURROUNDING_TEXT': True}) silently dropped the timezone, while the same string without the leading "Updated " kept it -- a silent correctness bug, not a missing feature. - Add dateparser.timezone_parser.is_timezone_token(): a case-insensitive *full* match on the stripped token, unlike the case-sensitive, unanchored prefix match of word_is_tz(). Edge tokens reaching _strip_unknown_edge_tokens are already lowercased and may carry embedded whitespace (e.g. " est"), and a fullmatch keeps a noise word such as "actualise" from spuriously matching the ACT zone. - Keep a recognized timezone at the trailing edge only: a timezone follows the date it qualifies and does not precede it, so the leading edge keeps stripping unconditionally. The choice, and the limitation that the timezone is kept only when it is the final token (trailing prose after it merges the tokens and drops it), are stated in the method docstring, inline comments and the docs. - are_tokens_valid() now calls the shared _is_known_token() helper instead of restating the same per-token condition, so the two cannot drift. - Document the actual stripping rule in docs/settings.rst: stripping stops at the first token the locale recognizes as a number, relative expression or dictionary word, so an incidental edge number blocks the feature (e.g. 'invoice 12345 paid on 3 March 2019' -> None); point such input at search_dates(). Clarify in the warning that a trailing timezone is applied only as the last token, while a leading, trailing-followed-by-text, or unrecognized one is dropped. - Tests: assert a wrapped trailing timezone (EST, PST, JST, and a parenthesized GMT) yields the same tz-aware instant as the bare date, checking the timezone *name* so a case cannot pass by the dropped offset coinciding with the local timezone; pin that only the trailing edge keeps a timezone; lock both the "trailing timezone followed by more text is dropped" and "edge number blocks stripping" limitations; unit-test is_timezone_token against lowercased, space-padded and look-alike tokens. Refs #518, #1356 Co-Authored-By: Claude Opus 4.8 (1M context) --------- Co-authored-by: Claude Opus 4.8 --- dateparser/conf.py | 2 + dateparser/date.py | 70 +++++-- dateparser/languages/dictionary.py | 61 +++++- dateparser/languages/locale.py | 33 ++- dateparser/timezone_parser.py | 16 ++ dateparser_data/settings.py | 1 + docs/settings.rst | 44 ++++ tests/test_clean_api.py | 315 ++++++++++++++++++++++++++++- tests/test_date.py | 36 ++++ tests/test_languages.py | 76 +++++++ tests/test_timezone_parser.py | 36 ++++ 11 files changed, 667 insertions(+), 23 deletions(-) diff --git a/dateparser/conf.py b/dateparser/conf.py index 6f80b72a1..fb533fa76 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -24,6 +24,7 @@ class Settings: * `RELATIVE_BASE` * `STRICT_PARSING` * `REQUIRE_PARTS` + * `IGNORE_SURROUNDING_TEXT` * `SKIP_TOKENS` * `NORMALIZE` * `RETURN_TIME_AS_PERIOD` @@ -209,6 +210,7 @@ def check_settings(settings): "type": datetime }, "STRICT_PARSING": {"type": bool}, + "IGNORE_SURROUNDING_TEXT": {"type": bool}, "REQUIRE_PARTS": { # "values" covered by the 'extra_check' "type": list, diff --git a/dateparser/date.py b/dateparser/date.py index 74806fea1..28aacbdf6 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -255,7 +255,14 @@ def parse_with_formats(date_string, date_formats, settings): class _DateLocaleParser: - def __init__(self, locale, date_string, date_formats, settings=None): + def __init__( + self, + locale, + date_string, + date_formats, + settings=None, + ignore_surrounding_text=False, + ): self._settings = settings if not (date_formats is None or isinstance(date_formats, (list, tuple, Set))): raise TypeError("Date formats should be list, tuple or set of strings") @@ -263,6 +270,7 @@ def __init__(self, locale, date_string, date_formats, settings=None): self.locale = locale self.date_string = date_string self.date_formats = date_formats + self._ignore_surrounding_text = ignore_surrounding_text self._translated_date = None self._translated_date_with_formatting = None self._parsers = { @@ -275,8 +283,17 @@ def __init__(self, locale, date_string, date_formats, settings=None): } @classmethod - def parse(cls, locale, date_string, date_formats=None, settings=None): - instance = cls(locale, date_string, date_formats, settings) + def parse( + cls, + locale, + date_string, + date_formats=None, + settings=None, + ignore_surrounding_text=False, + ): + instance = cls( + locale, date_string, date_formats, settings, ignore_surrounding_text + ) return instance._parse() def _parse(self): @@ -372,14 +389,20 @@ def _try_given_formats(self): def _get_translated_date(self): if self._translated_date is None: self._translated_date = self.locale.translate( - self.date_string, keep_formatting=False, settings=self._settings + self.date_string, + keep_formatting=False, + settings=self._settings, + ignore_surrounding_text=self._ignore_surrounding_text, ) return self._translated_date def _get_translated_date_with_formatting(self): if self._translated_date_with_formatting is None: self._translated_date_with_formatting = self.locale.translate( - self.date_string, keep_formatting=True, settings=self._settings + self.date_string, + keep_formatting=True, + settings=self._settings, + ignore_surrounding_text=self._ignore_surrounding_text, ) return self._translated_date_with_formatting @@ -580,17 +603,37 @@ def get_date_data(self, date_string, date_formats=None): date_string = sanitize_date(date_string) - for locale in self._get_applicable_locales(date_string): + parsed_date = self._parse_using_applicable_locales(date_string, date_formats) + if not parsed_date and self._settings.IGNORE_SURROUNDING_TEXT: + # The whole string could not be parsed as a date. Retry, ignoring + # unrecognized words at the edges of the string, so that a date + # wrapped in harmless extra text is still parsed (issue #518), + # e.g. "Actualisé le 17 avril 2019". Strings that can be parsed as + # a whole never reach this fallback, so they are unaffected. + parsed_date = self._parse_using_applicable_locales( + date_string, date_formats, ignore_surrounding_text=True + ) + return parsed_date or DateData(date_obj=None, period="day", locale=None) + + def _parse_using_applicable_locales( + self, date_string, date_formats, ignore_surrounding_text=False + ): + for locale in self._get_applicable_locales( + date_string, ignore_surrounding_text=ignore_surrounding_text + ): parsed_date = _DateLocaleParser.parse( - locale, date_string, date_formats, settings=self._settings + locale, + date_string, + date_formats, + settings=self._settings, + ignore_surrounding_text=ignore_surrounding_text, ) if parsed_date: parsed_date["locale"] = locale.shortname if self.try_previous_locales: self.previous_locales[locale] = None return parsed_date - else: - return DateData(date_obj=None, period="day", locale=None) + return None def get_date_tuple(self, *args, **kwargs): date_data = self.get_date_data(*args, **kwargs) @@ -598,7 +641,7 @@ def get_date_tuple(self, *args, **kwargs): date_tuple = collections.namedtuple("DateData", fields) return date_tuple(**date_data.__dict__) - def _get_applicable_locales(self, date_string): + def _get_applicable_locales(self, date_string, ignore_surrounding_text=False): # The given order is preserved if requested either through the # ``use_given_order`` constructor argument or the # ``USE_GIVEN_LANGUAGE_ORDER`` setting (which also reaches the @@ -630,7 +673,7 @@ def date_strings(): if self.try_previous_locales: for locale in self.previous_locales.keys(): for s in date_strings(): - if self._is_applicable_locale(locale, s): + if self._is_applicable_locale(locale, s, ignore_surrounding_text): yield locale if self.detect_languages_function and not self.languages and not self.locales: @@ -648,7 +691,7 @@ def date_strings(): use_given_order=use_given_order, ): for s in date_strings(): - if self._is_applicable_locale(locale, s): + if self._is_applicable_locale(locale, s, ignore_surrounding_text): yield locale if self._settings.DEFAULT_LANGUAGES: @@ -660,11 +703,12 @@ def date_strings(): ): yield locale - def _is_applicable_locale(self, locale, date_string): + def _is_applicable_locale(self, locale, date_string, ignore_surrounding_text=False): return locale.is_applicable( date_string, strip_timezone=False, # it is stripped outside settings=self._settings, + ignore_surrounding_text=ignore_surrounding_text, ) @classmethod diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index fa14c42fb..2249645c4 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -3,6 +3,7 @@ import regex as re +from dateparser.timezone_parser import is_timezone_token from dateparser.utils import normalize_unicode PARSER_HARDCODED_TOKENS = [":", ".", " ", "-", "/"] @@ -142,13 +143,59 @@ def are_tokens_valid(self, tokens): if has_only_keep_tokens: return False match_relative_regex = self._get_match_relative_regex_cache() - for token in tokens: - if token.isdigit() or match_relative_regex.match(token) or token in self: - continue - else: - return False - else: - return True + return all( + self._is_known_token(token, match_relative_regex) for token in tokens + ) + + def _is_known_token(self, token, match_relative_regex): + """Whether ``token`` is recognised by this locale: a number, a relative + expression, or a dictionary word (the same per-token check that + :meth:`are_tokens_valid` applies).""" + return bool( + token.isdigit() or match_relative_regex.match(token) or token in self + ) + + def _strip_unknown_edge_tokens(self, tokens): + """Return ``tokens`` without the leading and trailing tokens that this + locale does not recognise (neither digits, relative expressions, nor + dictionary words), along with any whitespace those removals leave at + the edges. Interior tokens are left untouched. Used when the + ``IGNORE_SURROUNDING_TEXT`` setting is enabled. + + A timezone abbreviation that is the final token (e.g. a trailing + ``"EST"``) is kept even though the locale dictionary does not list it, + so that the offset is applied rather than silently discarded. It + survives translation and is popped later by + :func:`~dateparser.timezone_parser.pop_tz_offset_from_string`. The + timezone is kept only when it is the last token: if further + unrecognized text follows it, the tokenizer merges the two and the + timezone is dropped together with that text, like any other edge noise. + + This timezone exception is deliberately made at the trailing edge + only: a timezone conventionally follows the date it qualifies + (``"... 1:21 PM EST"``) and does not precede it, so the leading edge + keeps stripping unrecognized tokens unconditionally.""" + match_relative_regex = self._get_match_relative_regex_cache() + + def is_extra_text(token): + return token.isspace() or not self._is_known_token( + token, match_relative_regex + ) + + start, end = 0, len(tokens) + # Leading edge: drop every unrecognized token. A timezone does not + # precede the date it qualifies, so no timezone exception is made here. + while start < end and is_extra_text(tokens[start]): + start += 1 + # Trailing edge: drop unrecognized tokens, but keep a recognized + # timezone abbreviation (e.g. ``" est"``) so its offset is applied. + while ( + end > start + and is_extra_text(tokens[end - 1]) + and not is_timezone_token(tokens[end - 1]) + ): + end -= 1 + return tokens[start:end] def split(self, string, keep_formatting=False): """ diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 553a54609..0da76dc4f 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -54,7 +54,13 @@ def __init__(self, shortname, language_info): self.info = combine_dicts(language_info, locale_specific_info) self.info.pop("locale_specific", None) - def is_applicable(self, date_string, strip_timezone=False, settings=None): + def is_applicable( + self, + date_string, + strip_timezone=False, + settings=None, + ignore_surrounding_text=False, + ): """ Check if the locale is applicable to translate date string. @@ -66,6 +72,11 @@ def is_applicable(self, date_string, strip_timezone=False, settings=None): If True, timezone is stripped from date string. :type strip_timezone: bool + :param ignore_surrounding_text: + If True, tokens that the locale does not recognise are ignored at + the edges of the date string (``IGNORE_SURROUNDING_TEXT`` setting). + :type ignore_surrounding_text: bool + :return: boolean value representing if the locale is applicable for the date string or not. """ if strip_timezone: @@ -77,6 +88,8 @@ def is_applicable(self, date_string, strip_timezone=False, settings=None): date_string = self._simplify(date_string, settings=settings) dictionary = self._get_dictionary(settings) date_tokens = dictionary.split(date_string) + if ignore_surrounding_text: + date_tokens = dictionary._strip_unknown_edge_tokens(date_tokens) return dictionary.are_tokens_valid(date_tokens) def count_applicability(self, text, strip_timezone=False, settings=None): @@ -116,7 +129,13 @@ def clean_dictionary(dictionary, threshold=2): del dictionary[del_key] return dictionary - def translate(self, date_string, keep_formatting=False, settings=None): + def translate( + self, + date_string, + keep_formatting=False, + settings=None, + ignore_surrounding_text=False, + ): """ Translate the date string to its English equivalent. @@ -128,6 +147,12 @@ def translate(self, date_string, keep_formatting=False, settings=None): If True, retain formatting of the date string after translation. :type keep_formatting: bool + :param ignore_surrounding_text: + If True, tokens that the locale does not recognise are dropped from + the edges of the date string before translation + (``IGNORE_SURROUNDING_TEXT`` setting). + :type ignore_surrounding_text: bool + :return: translated date string. """ date_string = self._translate_numerals(date_string) @@ -136,6 +161,10 @@ def translate(self, date_string, keep_formatting=False, settings=None): date_string = self._simplify(date_string, settings=settings) dictionary = self._get_dictionary(settings) date_string_tokens = dictionary.split(date_string, keep_formatting) + if ignore_surrounding_text: + date_string_tokens = dictionary._strip_unknown_edge_tokens( + date_string_tokens + ) relative_translations = self._get_relative_translations(settings=settings) diff --git a/dateparser/timezone_parser.py b/dateparser/timezone_parser.py index 0f879ddcc..04d412f99 100644 --- a/dateparser/timezone_parser.py +++ b/dateparser/timezone_parser.py @@ -50,6 +50,22 @@ def word_is_tz(word): return bool(_search_regex.match(word)) +def is_timezone_token(token): + """Whether ``token`` is, on its own, a recognized timezone abbreviation. + + Unlike :func:`word_is_tz` (a case-sensitive prefix match used while + scanning original-cased text), this trims surrounding whitespace and does a + case-insensitive *full* match, so it recognizes an already-lowercased, + space-padded token such as ``" est"``. Because the match is anchored, an + ordinary word that merely begins with a timezone abbreviation is not + treated as a timezone (e.g. ``"actualisé"`` is not the ``ACT`` zone). This + is used only on single edge tokens, so the trailing ``.*`` in the UTC/GMT + numeric-offset patterns (which a full match would otherwise let absorb + following text) is not a concern here. + """ + return bool(_search_regex_ignorecase.fullmatch(token.strip())) + + def convert_to_local_tz(datetime_obj, datetime_tz_offset): return datetime_obj - datetime_tz_offset + local_tz_offset diff --git a/dateparser_data/settings.py b/dateparser_data/settings.py index 833aff105..89aad5a6e 100644 --- a/dateparser_data/settings.py +++ b/dateparser_data/settings.py @@ -34,5 +34,6 @@ # Other settings "RETURN_TIME_AS_PERIOD": False, "PARSERS": default_parsers, + "IGNORE_SURROUNDING_TEXT": False, "CACHE_SIZE_LIMIT": 1000, } diff --git a/docs/settings.rst b/docs/settings.rst index 7a8f558a4..d50a753fd 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -155,6 +155,50 @@ For example, assuming current date is `June 16, 2019`: >>> parse('March 12, 2012', settings={'REQUIRE_PARTS': ['day', 'month', 'year']}) datetime.datetime(2012, 3, 12, 0, 0) +``IGNORE_SURROUNDING_TEXT``: defaults to ``False``. By default, the whole input string +must be a date, so a date wrapped in surrounding text is not parsed. When this setting +is enabled and the whole string could not be parsed as a date, dateparser retries +ignoring the words at the beginning and at the end of the string that the tried +language does not recognize as date-related: + + >>> parse('Actualisé le 17 avril 2019', languages=['fr']) + None + >>> parse('Actualisé le 17 avril 2019', languages=['fr'], settings={'IGNORE_SURROUNDING_TEXT': True}) + datetime.datetime(2019, 4, 17, 0, 0) + >>> parse('Published on 16/04/2019', settings={'IGNORE_SURROUNDING_TEXT': True}) + datetime.datetime(2019, 4, 16, 0, 0) + +Only the edges of the string are affected. An unrecognized word inside the date still +prevents parsing, and strings that can be parsed as a whole are parsed exactly as if +the setting was disabled: + + >>> parse('17 foobar avril 2019', languages=['fr'], settings={'IGNORE_SURROUNDING_TEXT': True}) + None + +Stripping stops at the first token the language *does* recognize, and a number counts +as recognized. So surrounding text that contains a number of its own (an id, a page +number, a count) is not ignored, and the string is not parsed: + + >>> parse('invoice 12345 paid on 3 March 2019', settings={'IGNORE_SURROUNDING_TEXT': True}) + None + +To extract a date out of arbitrary text that does not follow this shape, use +:func:`dateparser.search.search_dates` instead, which scans the whole string rather +than only trimming its edges. + +.. warning:: When this setting is enabled, discarded edge text is dropped even if it + could have changed the meaning of the date, and what remains is parsed as if it + were the whole input. As a result, strings that merely contain date-like words can + produce a date, e.g. ``'Chapter 12 March of the Penguins'``. A recognized timezone is + kept and applied only when it is the last token of the string (e.g. + ``'... 1:21 PM EST'``); a timezone before the date, one followed by further + unrecognized text, or any timezone name the parser does not recognize, is discarded + with the rest of the surrounding text (use + :func:`dateparser.search.search_dates` for such input). Enable this setting only when + the input is expected to contain a date, and consider combining it with + ``STRICT_PARSING`` or ``REQUIRE_PARTS`` to discard remainders that are not complete + dates. + Language Detection ++++++++++++++++++ diff --git a/tests/test_clean_api.py b/tests/test_clean_api.py index 3d5b60583..324141f6b 100644 --- a/tests/test_clean_api.py +++ b/tests/test_clean_api.py @@ -1,9 +1,10 @@ -from datetime import date, datetime +from datetime import date, datetime, timedelta from parameterized import param, parameterized from pytz import utc import dateparser +from dateparser.search import search_dates from tests import BaseTestCase @@ -285,3 +286,315 @@ def then_parsed_date_and_time_is(self, expected_date): def then_date_was_not_parsed(self): self.assertIsNone(self.result) + + +class TestIgnoreSurroundingTextSetting(BaseTestCase): + """Tests for the opt-in ``IGNORE_SURROUNDING_TEXT`` setting (issue #518).""" + + def setUp(self): + super().setUp() + self.result = NotImplemented + + @parameterized.expand( + [ + # Issue #518: dates wrapped in harmless extra text. + param( + date_string="Actualisé le 17 avril 2019", + languages=["fr"], + expected_datetime=datetime(2019, 4, 17), + ), + param( + date_string="Publié le 16 avril 2019", + languages=["fr"], + expected_datetime=datetime(2019, 4, 16), + ), + # The behavior is not French-specific. + param( + date_string="Published on 16 April 2019", + languages=["en"], + expected_datetime=datetime(2019, 4, 16), + ), + # Purely numeric dates do not need a month name to survive. + param( + date_string="published 2019-04-16 ok", + languages=["en"], + expected_datetime=datetime(2019, 4, 16), + ), + param( + date_string="xx 16/04/2019 yy", + languages=["en"], + expected_datetime=datetime(2019, 4, 16), + ), + # No language hint is needed: locales are tried as usual. + param( + date_string="Actualisé le 17 avril 2019", + languages=None, + expected_datetime=datetime(2019, 4, 17), + ), + # Strings that parse as a whole are parsed exactly as before. + param( + date_string="le 17 avril 2019", + languages=["fr"], + expected_datetime=datetime(2019, 4, 17), + ), + param( + date_string="17 avril 2019", + languages=["fr"], + expected_datetime=datetime(2019, 4, 17), + ), + ] + ) + def test_dates_with_surrounding_text_are_parsed( + self, date_string, languages, expected_datetime + ): + self.when_date_is_parsed( + date_string, + languages=languages, + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_parsed_datetime_is(expected_datetime) + + @parameterized.expand( + [ + param(date_string="Actualisé le 17 avril 2019", languages=["fr"]), + param(date_string="Publié le 16 avril 2019", languages=["fr"]), + param(date_string="Published on 16 April 2019", languages=["en"]), + ] + ) + def test_dates_with_surrounding_text_are_not_parsed_by_default( + self, date_string, languages + ): + self.when_date_is_parsed(date_string, languages=languages) + self.then_date_was_not_parsed() + + @parameterized.expand( + [ + # An unrecognized word inside the date still prevents parsing. + param(date_string="17 foobar avril 2019", languages=["fr"]), + # A string without any date content is still not parsed. + param(date_string="hello world", languages=["en"]), + ] + ) + def test_non_dates_are_not_parsed_even_when_enabled(self, date_string, languages): + self.when_date_is_parsed( + date_string, + languages=languages, + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_date_was_not_parsed() + + def test_surrounding_text_ignored_with_locales_argument(self): + self.when_date_is_parsed( + "Actualisé le 17 avril 2019", + locales=["fr-CA"], + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + + def test_surrounding_text_ignored_with_region_argument(self): + self.when_date_is_parsed( + "Actualisé le 17 avril 2019", + languages=["fr"], + region="CA", + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + + def test_surrounding_text_ignored_with_default_languages_setting(self): + self.when_date_is_parsed( + "Actualisé le 17 avril 2019", + settings={"IGNORE_SURROUNDING_TEXT": True, "DEFAULT_LANGUAGES": ["fr"]}, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + + def test_surrounding_text_ignored_with_detected_language(self): + self.when_date_is_parsed( + "Actualisé le 17 avril 2019", + detect_languages_function=lambda text, confidence_threshold: ["fr"], + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + + def test_surrounding_text_ignored_with_date_formats(self): + self.when_date_is_parsed( + "Published on 16/04/2019", + date_formats=["%d/%m/%Y"], + languages=["en"], + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 16)) + + def test_relative_date_with_surrounding_text(self): + self.when_date_is_parsed( + "asdf 3 hours ago asdf", + languages=["en"], + settings={ + "IGNORE_SURROUNDING_TEXT": True, + "RELATIVE_BASE": datetime(2019, 4, 17, 12, 0), + }, + ) + self.then_parsed_datetime_is(datetime(2019, 4, 17, 9, 0)) + + def test_strict_parsing_rejects_incomplete_remainder(self): + # The remainder is parsed as if it were the whole input, so settings + # such as STRICT_PARSING apply to it as usual. + self.when_date_is_parsed( + "Page 3", + languages=["en"], + settings={"IGNORE_SURROUNDING_TEXT": True, "STRICT_PARSING": True}, + ) + self.then_date_was_not_parsed() + + def test_surrounding_text_can_turn_non_dates_into_dates(self): + # Documented caveat: with the setting enabled, a string that merely + # contains date-like words produces a date. + self.when_date_is_parsed( + "Chapter 12 March of the Penguins", + languages=["en"], + settings={ + "IGNORE_SURROUNDING_TEXT": True, + "RELATIVE_BASE": datetime(2026, 7, 27), + }, + ) + self.then_parsed_datetime_is(datetime(2026, 3, 12)) + + def test_search_dates_is_not_affected_by_default(self): + # search_dates keeps relying on the strict behavior of get_date_data. + self.result = search_dates("Actualisé le 17 avril 2019", languages=["fr"]) + self.assertEqual([("le 17 avril 2019", datetime(2019, 4, 17))], self.result) + + def test_trailing_timezone_is_preserved(self): + # A recognized timezone at the trailing edge must not be discarded with + # the surrounding text: wrapping a date in extra text yields the same + # instant as parsing the bare date, timezone included. + settings = {"IGNORE_SURROUNDING_TEXT": True, "RETURN_AS_TIMEZONE_AWARE": True} + wrapped = dateparser.parse( + "Updated 23 March 2000 1:21 PM EST", languages=["en"], settings=settings + ) + unwrapped = dateparser.parse( + "23 March 2000 1:21 PM EST", + languages=["en"], + settings={"RETURN_AS_TIMEZONE_AWARE": True}, + ) + self.assertEqual(timedelta(hours=-5), wrapped.utcoffset()) + self.assertEqual(unwrapped, wrapped) + + @parameterized.expand( + [ + # Abbreviations that are not dictionary words, so they are kept via + # is_timezone_token rather than the plain known-word branch. Their + # names and offsets are chosen not to coincide with a plausible + # local timezone (in particular not UTC or CET), so a reversion of + # the trailing-tz exception is caught on any machine rather than + # only under a non-local timezone. + param( + wrapped="Updated 23 March 2000 1:21 PM PST", + bare="23 March 2000 1:21 PM PST", + tzname="PST", + utcoffset=timedelta(hours=-8), + ), + param( + wrapped="Updated 23 March 2000 1:21 PM JST", + bare="23 March 2000 1:21 PM JST", + tzname="JST", + utcoffset=timedelta(hours=9), + ), + ] + ) + def test_more_trailing_timezones_are_preserved( + self, wrapped, bare, tzname, utcoffset + ): + # Like test_trailing_timezone_is_preserved, for further abbreviations: + # wrapping the date in extra text yields the same tz-aware instant as + # parsing the bare date. The timezone *name* is asserted (not only the + # offset) so the test cannot pass by the dropped timezone happening to + # match the machine's local offset. + settings = {"IGNORE_SURROUNDING_TEXT": True, "RETURN_AS_TIMEZONE_AWARE": True} + wrapped_result = dateparser.parse(wrapped, languages=["en"], settings=settings) + bare_result = dateparser.parse( + bare, languages=["en"], settings={"RETURN_AS_TIMEZONE_AWARE": True} + ) + self.assertEqual(tzname, wrapped_result.tzname()) + self.assertEqual(utcoffset, wrapped_result.utcoffset()) + self.assertEqual(bare_result, wrapped_result) + + def test_parenthesized_trailing_timezone_is_applied(self): + # A parenthesized trailing timezone is applied end to end. GMT is a + # dictionary token, so the parentheses are split off and it is kept via + # the ordinary known-word branch, not via is_timezone_token (which the + # PST/JST cases above exercise). A parenthesized abbreviation that is + # *not* a dictionary word stays glued to its parentheses and is dropped + # like any other unrecognized edge token, so GMT is used here. + settings = {"IGNORE_SURROUNDING_TEXT": True, "RETURN_AS_TIMEZONE_AWARE": True} + wrapped = dateparser.parse( + "Last updated: 12 March 2019 at 10:30 (GMT)", + languages=["en"], + settings=settings, + ) + bare = dateparser.parse( + "12 March 2019 at 10:30 (GMT)", + languages=["en"], + settings={"RETURN_AS_TIMEZONE_AWARE": True}, + ) + self.assertEqual("GMT", wrapped.tzname()) + self.assertEqual(timedelta(0), wrapped.utcoffset()) + self.assertEqual(bare, wrapped) + + def test_only_trailing_timezone_is_preserved(self): + # tz-recognition when stripping edge tokens is deliberately applied to + # the trailing edge only: a timezone that follows the date is kept and + # applied, while the same abbreviation before the date is treated as + # ordinary surrounding text and dropped. + settings = {"IGNORE_SURROUNDING_TEXT": True, "RETURN_AS_TIMEZONE_AWARE": True} + trailing = dateparser.parse( + "23 March 2000 1:21 PM EST", languages=["en"], settings=settings + ) + leading = dateparser.parse( + "EST 23 March 2000 1:21 PM", languages=["en"], settings=settings + ) + without_tz = dateparser.parse( + "23 March 2000 1:21 PM", + languages=["en"], + settings={"RETURN_AS_TIMEZONE_AWARE": True}, + ) + # Trailing EST is applied... + self.assertEqual(timedelta(hours=-5), trailing.utcoffset()) + # ...leading EST is not: the result matches the same string with no + # timezone at all, and does not carry the EST offset. + self.assertEqual(without_tz, leading) + self.assertNotEqual(trailing, leading) + + def test_trailing_timezone_followed_by_more_text_is_dropped(self): + # Known limitation: a trailing timezone is kept only when it is the + # final token. If unrecognized text follows it, the tokenizer merges + # the two, so the timezone is stripped together with that text and its + # offset is not applied (use search_dates for such input). The date is + # still parsed -- only the timezone is lost. + settings = {"IGNORE_SURROUNDING_TEXT": True, "RETURN_AS_TIMEZONE_AWARE": True} + result = dateparser.parse( + "Updated 23 March 2000 1:21 PM EST reportedly", + languages=["en"], + settings=settings, + ) + self.assertEqual(datetime(2000, 3, 23, 13, 21), result.replace(tzinfo=None)) + self.assertNotEqual(timedelta(hours=-5), result.utcoffset()) + + def test_leading_numeric_noise_is_not_ignored(self): + # Documented limitation: stripping stops at the first recognized token, + # and a number counts as recognized, so leading text that contains a + # number of its own blocks parsing. search_dates covers this shape. + self.when_date_is_parsed( + "invoice 12345 paid on 3 March 2019", + languages=["en"], + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.then_date_was_not_parsed() + + def when_date_is_parsed(self, date_string, **kwargs): + self.result = dateparser.parse(date_string, **kwargs) + + def then_parsed_datetime_is(self, expected_datetime): + self.assertEqual(expected_datetime, self.result) + + def then_date_was_not_parsed(self): + self.assertIsNone(self.result) diff --git a/tests/test_date.py b/tests/test_date.py index d2bd2987e..688b6b665 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -712,6 +712,39 @@ def test_get_date_data_should_not_strip_timezone_info(self, date_string): self.then_date_was_parsed() self.then_parsed_date_has_timezone() + def test_ignore_surrounding_text_setting_parses_wrapped_date(self): + # Issue #518: a date wrapped in harmless extra text is parsed when the + # ``IGNORE_SURROUNDING_TEXT`` setting is enabled. + self.given_parser( + restrict_to_languages=["fr"], settings={"IGNORE_SURROUNDING_TEXT": True} + ) + self.when_date_string_is_parsed("Actualisé le 17 avril 2019") + self.then_date_was_parsed() + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + self.then_detected_locale("fr") + self.then_period_is("day") + + def test_get_date_data_ignores_surrounding_text_only_when_enabled(self): + # The safety property of the ``IGNORE_SURROUNDING_TEXT`` setting: by + # default, ``get_date_data`` keeps requiring the whole string to be a + # date, so language detection and ``search_dates`` are unaffected. + self.given_parser(restrict_to_languages=["fr"]) + self.when_date_string_is_parsed("Actualisé le 17 avril 2019") + self.then_date_was_not_parsed() + + def test_ignore_surrounding_text_with_try_previous_locales(self): + self.given_parser( + restrict_to_languages=["fr", "en"], + try_previous_locales=True, + settings={"IGNORE_SURROUNDING_TEXT": True}, + ) + self.when_date_string_is_parsed("Actualisé le 17 avril 2019") + self.then_parsed_datetime_is(datetime(2019, 4, 17)) + self.then_previous_locales_is(["fr"]) + self.when_date_string_is_parsed("Publié le 16 avril 2019") + self.then_parsed_datetime_is(datetime(2019, 4, 16)) + self.then_previous_locales_is(["fr"]) + @parameterized.expand( [ param( @@ -955,6 +988,9 @@ def when_get_date_tuple_is_called(self, date_string): def then_date_was_parsed(self): self.assertIsNotNone(self.result["date_obj"]) + def then_date_was_not_parsed(self): + self.assertIsNone(self.result["date_obj"]) + def then_date_locale(self): self.assertIsNotNone(self.result["locale"]) diff --git a/tests/test_languages.py b/tests/test_languages.py index 757460c55..783af3654 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -2438,6 +2438,67 @@ def test_not_applicable_languages(self, shortname, datetime_string, strip_timezo self.when_datetime_string_checked_if_applicable(strip_timezone) self.then_language_is_not_applicable() + @parameterized.expand( + [ + # Dates wrapped in text the locale does not recognize (issue #518). + param("fr", "actualisé le 17 avril 2019"), + param("fr", "publié le 16 avril 2019"), + param("en", "published on 16 april 2019"), + param("en", "xx 16/04/2019 yy"), + ] + ) + def test_applicable_languages_when_ignoring_surrounding_text( + self, shortname, datetime_string + ): + self.given_settings() + self.given_bundled_language(shortname) + self.given_string(datetime_string) + self.when_datetime_string_checked_if_applicable_ignoring_surrounding_text() + self.then_language_is_applicable() + + @parameterized.expand( + [ + # An unrecognized token inside the date keeps the locale + # inapplicable: only the edges may be ignored. + param("fr", "17 foobar avril 2019"), + # Nothing is left when every token is unrecognized. + param("en", "hello world"), + ] + ) + def test_not_applicable_languages_when_ignoring_surrounding_text( + self, shortname, datetime_string + ): + self.given_settings() + self.given_bundled_language(shortname) + self.given_string(datetime_string) + self.when_datetime_string_checked_if_applicable_ignoring_surrounding_text() + self.then_language_is_not_applicable() + + @parameterized.expand( + [ + # The result is the same as translating the date without the + # surrounding text. + param("fr", "actualisé le 17 avril 2019", " 17 april 2019"), + param("en", "published on 16 april 2019", " 16 april 2019"), + param("en", "xx 16/04/2019 yy", "16/04/2019"), + # A recognized timezone at the trailing edge is kept, so the offset + # is not discarded; the result matches the unwrapped translation. + param( + "en", + "updated 23 march 2000 1:21 pm est", + "23 march 2000 1:21 pm est", + ), + ] + ) + def test_translation_when_ignoring_surrounding_text( + self, shortname, datetime_string, expected_translation + ): + self.given_settings() + self.given_bundled_language(shortname) + self.given_string(datetime_string) + self.when_datetime_string_translated_ignoring_surrounding_text() + self.then_string_translated_to(expected_translation) + @apply_settings def given_settings(self, settings=None): self.settings = settings @@ -2465,6 +2526,21 @@ def when_datetime_string_checked_if_applicable(self, strip_timezone): self.datetime_string, strip_timezone, settings=self.settings ) + def when_datetime_string_checked_if_applicable_ignoring_surrounding_text(self): + self.result = self.language.is_applicable( + self.datetime_string, + strip_timezone=False, + settings=self.settings, + ignore_surrounding_text=True, + ) + + def when_datetime_string_translated_ignoring_surrounding_text(self): + self.translation = self.language.translate( + self.datetime_string, + settings=self.settings, + ignore_surrounding_text=True, + ) + def then_string_translated_to(self, expected_string): self.assertEqual(expected_string, self.translation) diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index 5279fa622..0a9e47436 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -11,7 +11,9 @@ from dateparser.timezone_parser import ( StaticTzInfo, get_local_tz_offset, + is_timezone_token, pop_tz_offset_from_string, + word_is_tz, ) from tests import BaseTestCase @@ -240,3 +242,37 @@ def when_date_is_localized(self, given_date): def then_localized_date_is(self, expected_date, expected_tzname): self.assertEqual(self.localized_date.date(), expected_date.date()) self.assertEqual(self.localized_date.tzname(), expected_tzname) + + +class TestIsTimezoneToken(BaseTestCase): + """Unit tests for ``is_timezone_token``, used to keep a trailing timezone + when ``IGNORE_SURROUNDING_TEXT`` strips edge tokens.""" + + @parameterized.expand( + [ + param(token="EST", expected=True), + # Already-lowercased and space-padded tokens (as produced by the + # translation pipeline) are recognized too. + param(token="est", expected=True), + param(token=" est", expected=True), + param(token="cet", expected=True), + param(token="pst", expected=True), + param(token="utc", expected=True), + # A longer word that merely starts with a timezone abbreviation must + # not be treated as a timezone. + param(token="actualisé", expected=False), + param(token="ACTUALISÉ", expected=False), + param(token="updated", expected=False), + param(token="", expected=False), + param(token=" ", expected=False), + ] + ) + def test_is_timezone_token(self, token, expected): + self.assertEqual(expected, is_timezone_token(token)) + + def test_anchored_match_unlike_word_is_tz(self): + # word_is_tz prefix-matches ("ACT" of "ACTUALISÉ"); is_timezone_token is + # anchored, so it does not — this is what keeps a noise word from + # surviving as a timezone when edges are stripped. + self.assertTrue(word_is_tz("ACTUALISÉ")) + self.assertFalse(is_timezone_token("ACTUALISÉ")) From ff3dcb99f3cd4d4b9c727ceca7f83d8b4b4bc9d3 Mon Sep 17 00:00:00 2001 From: Laurie O Date: Mon, 3 Aug 2026 21:13:43 +1000 Subject: [PATCH 046/107] Specify README header content as RST (#1360) --- README.rst | 28 ++++++++++++++++++++-------- docs/index.rst | 1 + 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/README.rst b/README.rst index aca3a0fd5..a0b69ecc8 100644 --- a/README.rst +++ b/README.rst @@ -2,15 +2,27 @@ .. raw:: html - +
+ + +.. image:: artwork/dateparser-logo.png + :alt: Dateparser + :width: 500 + :target: https://github.com/scrapinghub/dateparser + -

Python parser for human readable dates

+**Python parser for human readable dates** + + +.. raw:: html + +
+ + +.. docs-include-marker + + +.. raw:: html

diff --git a/docs/index.rst b/docs/index.rst index 54c646594..c3e8bb058 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,6 +3,7 @@ dateparser -- python parser for human readable dates ==================================================== .. include:: ../README.rst + :start-after: docs-include-marker Indices and tables ------------------ From b1f603e9b562156ea97aa6b2da08dd69266bbd47 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Tue, 4 Aug 2026 14:05:17 +0200 Subject: [PATCH 047/107] 1.4.2 release (#1361) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 1.4.2 release notes Co-Authored-By: Claude Opus 4.8 (1M context) * Bump version: 1.4.1 → 1.4.2 --------- Co-authored-by: Claude Opus 4.8 (1M context) --- HISTORY.rst | 41 +++++++++++++++++++++++++++++++++++++++++ dateparser/__init__.py | 2 +- pyproject.toml | 2 +- 3 files changed, 43 insertions(+), 2 deletions(-) diff --git a/HISTORY.rst b/HISTORY.rst index f5eddaff5..de6c8b6d9 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,6 +3,47 @@ History ======= +1.4.2 (2026-08-04) +------------------ + +New features: + +- Add an ``IGNORE_SURROUNDING_TEXT`` setting that, when enabled, retries + parsing after ignoring the leading and trailing words the language does + not recognize, so a date wrapped in extra text such as "Published on + 16/04/2019" is parsed (#1356) +- Add a ``strategy`` argument to ``search_dates()`` to choose the search + strategy: the default ``"split"`` keeps the current behavior, while the + new ``"ngram"`` strategy parses the longest sequences of tokens as dates + for more predictable results on noisy text (#1351) + +Fixes: + +- Do not read a two-digit number as a year once a later component has been + found in year-first date orders, so the day in Japanese dates such as + "4月20日" is no longer consumed as the year (#1358) +- Parse ISO 8601 dates (those starting with a four-digit year) in month-day + order even when an explicit day-first language such as ``it`` or ``fr`` is + given, without needing to set ``PREFER_LOCALE_DATE_ORDER`` to ``False`` + (#1352) +- Honor ``PREFER_DATES_FROM`` and ``RELATIVE_BASE`` when parsing with custom + ``date_formats`` that use a two-digit year (``%y``) (#1342) +- Honor the ``%j`` (day of year) directive in ``date_formats`` instead of + overwriting the parsed month and day with the current date (#1345) + +Improvements: + +- Update the bundled CLDR locale data to 44.1.0, adding many newly + recognized date forms across locales and a standalone hour/duration unit + (e.g. Catalan "2 hores"), while keeping previously supported forms + parseable (#1343) +- Add the Italian expressions "un ora fa" and "un'ora fa", and skip "alle" + so phrases like "oggi alle 11:00" parse (#1049) +- Expand Czech date translations with month locative/dative forms (e.g. "v + lednu 2023"), the July abbreviation "črv", and relative expressions such + as "za týden", "za měsíc" and "za rok" (#1172) +- Specify the README header content as RST rather than raw HTML (#1360) + 1.4.1 (2026-06-15) ------------------ diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 36e2b45fd..b43021910 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,4 +1,4 @@ -__version__ = "1.4.1" +__version__ = "1.4.2" from .conf import apply_settings from .date import DateDataParser diff --git a/pyproject.toml b/pyproject.toml index 0600ea6e2..71e6a8d61 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ requires = [ [project] name = "dateparser" -version = "1.4.1" +version = "1.4.2" description = "Date parsing library designed to parse dates from HTML pages" authors = [ { name = "Scrapinghub", email = "opensource@zyte.com" }, From 764091d174abc38ac2fbadbe686fdf734352aead Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 12 Aug 2026 14:52:39 +0200 Subject: [PATCH 048/107] Fix timezone ambiguity using tz database (#1322) (#1366) dateparser/timezones.py maps each timezone abbreviation to a single UTC offset. Unrelated zones often share the same letters, and because the table was scraped from Wikipedia, a few abbreviations ended up with a meaning no tz database zone has. "BST" resolved to +11, although the only zones named "BST" today are the UK ones, at +1 (#1321). Rather than patching that one value, compare the whole table against the tz database and fix every abbreviation it disagrees with: - BST: 39600 -> 3600 (British Summer Time) - HDT: -34200 -> -32400 (Hawaii-Aleutian Daylight Time, America/Adak) Abbreviations the tz database names with several offsets, such as CST, IST and PST, are left alone, because there is no single offset to prefer. Abbreviations no zone is named after any more, such as AHST and LMT, are kept so historical text still parses. The comparison lives in dateparser_scripts/tz_abbreviation_conflicts.py and uses pytz, already a dependency, whose bundled copy of the tz database gives the same answer on every platform; zoneinfo would depend on OS-provided data that Windows lacks without the tzdata package. Parsing is unchanged and still uses the static table. Fixes #1322 Co-authored-by: Claude Opus 5 (1M context) --- CONTRIBUTING.rst | 21 ++ dateparser/timezones.py | 11 +- .../tz_abbreviation_conflicts.py | 193 ++++++++++++++++++ tests/test_timezone_parser.py | 190 +++++++++++++++++ 4 files changed, 413 insertions(+), 2 deletions(-) create mode 100644 dateparser_scripts/tz_abbreviation_conflicts.py diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index 0015e83ff..ff08dc1f6 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -179,3 +179,24 @@ Whenever the content of the corresponding documentation table:: dateparser_scripts/update_supported_languages_and_locales.py + +Updating Timezone Abbreviations +------------------------------- + +``dateparser/timezones.py`` maps each timezone abbreviation to a single UTC +offset. Unrelated zones often share the same letters, so to check that those +offsets still match the tz database, run:: + + python -m dateparser_scripts.tz_abbreviation_conflicts + +It reports every abbreviation whose offset no tz database zone uses, and exits +non-zero when it finds any. ``tests/test_timezone_parser.py`` runs the same +check, so a clean test run means the table is in sync. + +Abbreviations the tz database resolves to several offsets, such as ``CST``, are +left alone: there is no single answer to prefer, so dateparser keeps its +long-standing choice. + +When refreshing the table, slide ``REFERENCE_YEARS`` forward rather than +widening it. Reaching further back re-admits abbreviations the tz database has +since dropped and reports them as current. diff --git a/dateparser/timezones.py b/dateparser/timezones.py index 9ac35dafd..592c1d70c 100644 --- a/dateparser/timezones.py +++ b/dateparser/timezones.py @@ -2,6 +2,13 @@ # As well as http://en.wikipedia.org/wiki/List_of_time_zone_abbreviations # As well as https://github.com/scrapinghub/dateparser/pull/4 # As well as http://en.wikipedia.org/wiki/List_of_UTC_time_offsets +# +# The IANA tz database names several zones with the same abbreviation at +# different UTC offsets (e.g. "CST", "IST", "PST"), and gives no preferred +# meaning for those, so one offset was picked arbitrarily per abbreviation. +# Where the tz database names only one offset for an abbreviation, this table +# has to agree with it: "BST" and "HDT" did not, and were corrected in #1322. +# Run dateparser_scripts/tz_abbreviation_conflicts.py to re-check the table. timezone_info_list = [ { @@ -123,7 +130,7 @@ ("BOT", -14400), ("BRST", -7200), ("BRT", -10800), - ("BST", 39600), + ("BST", 3600), ("BTT", 21600), ("BURT", 23400), ("CANT", -3600), @@ -218,7 +225,7 @@ ("HAST", -36000), ("HAT", -9000), ("HAY", -28800), - ("HDT", -34200), + ("HDT", -32400), ("HKST", 32400), ("HKT", 28800), ("HLV", -16200), diff --git a/dateparser_scripts/tz_abbreviation_conflicts.py b/dateparser_scripts/tz_abbreviation_conflicts.py new file mode 100644 index 000000000..f5ccfc067 --- /dev/null +++ b/dateparser_scripts/tz_abbreviation_conflicts.py @@ -0,0 +1,193 @@ +"""Cross-check dateparser's timezone-abbreviation table against the tz database. + +Many timezone abbreviations are genuinely ambiguous: several IANA tz database +zones use the same letters for different UTC offsets ("CST" is both US Central +Standard Time and China Standard Time). The tz database provides no preferred +answer for those, so ``dateparser/timezones.py`` keeps one arbitrary offset per +abbreviation, originally taken from a Wikipedia scrape. + +Some abbreviations are *not* ambiguous, though: every zone the tz database +names with those letters agrees on a single UTC offset. When dateparser's table +disagrees with that offset, its value is not "another valid reading" -- no zone +goes by that name at that offset. That was the case for "BST", which resolved +to +11 although the only zones named "BST" today are the UK ones, at +1 (see +#1321 and #1322). This script finds every such case generically, so the table +can be kept in sync without a one-off patch per abbreviation. + +Two kinds of conflict are reported: + +``unambiguous`` + The tz database maps the abbreviation to exactly one offset and dateparser + disagrees. The tz database offset should be preferred. +``unsupported`` + The tz database maps the abbreviation to several offsets and dateparser's + value is none of them. There is no single offset to prefer, so this needs a + human decision, but the current value is still unsupported by any zone. + +Zone data comes from ``pytz``, which is already a dateparser dependency and +bundles its own copy of the tz database. That keeps results identical on every +platform, unlike the standard library ``zoneinfo`` module, whose data comes +from the operating system and is missing entirely on Windows unless the +separate ``tzdata`` package is installed. + +What this can and cannot see +---------------------------- + +Only the abbreviations the tz database still prints are checked, around 50 of +the 400-odd in dateparser's table. The rest are invisible here and are left to +dateparser: + +* Modern tz database releases name a zone after its offset ("+11", "-0930") + unless the abbreviation is in common English use, so a zone can drop out of + this comparison without the abbreviation falling out of use. "BST" for + Bougainville is exactly that: the zone now prints "+11". What the check + really shows is that no zone *is named* "BST" at +11 any more, which is the + practical question for a parser. +* Abbreviations no zone uses in the reference window at all, such as ``AHST`` + or ``LMT``, are kept by dateparser so that historical text still parses. +* pytz ships ``MET`` as a copy of ``CET``, so it prints "CET"/"CEST" and the + ``MET``/``MEST`` abbreviations never reach this comparison. + +Run it to print a report; it exits non-zero when it finds anything:: + + python -m dateparser_scripts.tz_abbreviation_conflicts +""" + +from collections import namedtuple +from datetime import datetime + +import pytz +import regex as re + +from dateparser.timezones import timezone_info_list + +# Years sampled to determine what an abbreviation means *today*. Both bounds +# are load-bearing, and the window is pinned deliberately, like the CLDR +# version in ``dateparser_scripts/utils.py``. +# +# The upper bound stays in settled years: the tz database records future +# daylight-saving rules as predictions that change between releases, so +# sampling them would make the result depend on the installed tz database +# version rather than on real usage. +# +# The lower bound keeps retired meanings out. Slide this window forward when +# refreshing the table, and do not widen it backwards: reaching further back +# re-admits abbreviations the tz database has since dropped and reports them as +# if they were current. Reaching back to 1999 picks up Guam's old "GST", which +# would report dateparser's "GST" (+4, Gulf Standard Time) as an unambiguous +# conflict against +10, even though Guam has used "ChST" since 2000. +REFERENCE_YEARS = range(2021, 2026) + +# Sampling January, April, July and October catches both the standard-time and +# the daylight-saving abbreviation of every zone, in either hemisphere. +REFERENCE_MONTHS = (1, 4, 7, 10) + +# The tz database uses names such as "+11" or "-0930" for zones that have no +# real abbreviation. They are not abbreviations, and dateparser matches numeric +# offsets through separate UTC/GMT patterns, so they are ignored here. +_NUMERIC_ZONE_NAME = re.compile(r"[+-]\d{2,4}") + +Conflict = namedtuple( + "Conflict", ["abbreviation", "kind", "dateparser_offset", "tz_database_offsets"] +) + + +def static_tz_abbreviations(): + """Return ``{abbreviation: offset_in_seconds}`` as dateparser resolves it. + + A few abbreviations are listed more than once in ``timezone_info_list`` + (``LMT`` appears four times with four different offsets). Only the first + entry can ever win: ``build_tz_offsets`` keeps the table order and + ``pop_tz_offset_from_string`` returns the first pattern that matches. So + the first entry, not the set of all of them, is what this comparison has + to use -- otherwise a wrong first entry would be masked by a correct later + one. + + Keys are upper-cased because dateparser matches abbreviations + case-insensitively, so a differently-cased entry such as ``ChST`` is the + same abbreviation and has to be compared as one. + """ + effective = {} + for group in timezone_info_list: + for name, offset in group["timezones"]: + effective.setdefault(name.upper(), offset) + return effective + + +def tz_database_abbreviations(): + """Return ``{abbreviation: {offset_in_seconds, ...}}`` from the tz database. + + Every zone is sampled, including the deprecated aliases (``US/Pacific``, + ``Asia/Calcutta``) that ``pytz.all_timezones`` lists alongside canonical + zones. Aliases resolve to the same rules as the zones they link to, so they + only ever repeat offsets a canonical zone already contributed; including + them costs nothing and keeps the scan independent of how pytz classifies + any individual zone. + """ + samples = [ + datetime(year, month, 15, 12, 0, 0) + for year in REFERENCE_YEARS + for month in REFERENCE_MONTHS + ] + abbreviations = {} + for zone_name in pytz.all_timezones: + zone = pytz.timezone(zone_name) + for naive in samples: + localized = zone.localize(naive) + abbreviation = localized.tzname() + if not abbreviation or _NUMERIC_ZONE_NAME.fullmatch(abbreviation): + continue + offset = int(localized.utcoffset().total_seconds()) + abbreviations.setdefault(abbreviation.upper(), set()).add(offset) + return abbreviations + + +def find_conflicts(static=None, tz_database=None): + """Return the sorted list of :class:`Conflict` between both tables. + + ``static`` and ``tz_database`` default to the real tables and are only + meant to be passed in by the tests. + + Abbreviations the tz database no longer uses at all are skipped: dateparser + deliberately keeps obsolete abbreviations such as ``AHST`` or ``LMT`` so + that historical text still parses, and the tz database has nothing to say + about them. + """ + static = static_tz_abbreviations() if static is None else static + tz_database = tz_database_abbreviations() if tz_database is None else tz_database + + conflicts = [] + for abbreviation, tz_database_offsets in tz_database.items(): + if abbreviation not in static: + continue + dateparser_offset = static[abbreviation] + if dateparser_offset in tz_database_offsets: + continue + kind = "unambiguous" if len(tz_database_offsets) == 1 else "unsupported" + conflicts.append( + Conflict(abbreviation, kind, dateparser_offset, sorted(tz_database_offsets)) + ) + return sorted(conflicts) + + +def main(): + found = find_conflicts() + if not found: + print( + "No conflicts: every abbreviation dateparser shares with the tz " + "database resolves to an offset some zone actually uses." + ) + return 0 + for conflict in found: + if conflict.kind == "unambiguous": + detail = f"the tz database only ever uses {conflict.tz_database_offsets[0]}" + else: + detail = f"no zone uses it; options are {conflict.tz_database_offsets}" + print( + f"{conflict.abbreviation}: dateparser uses {conflict.dateparser_offset}, {detail}" + ) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index 0a9e47436..7b7fa6bc7 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -276,3 +276,193 @@ def test_anchored_match_unlike_word_is_tz(self): # surviving as a timezone when edges are stripped. self.assertTrue(word_is_tz("ACTUALISÉ")) self.assertFalse(is_timezone_token("ACTUALISÉ")) + + +class TestTzDatabasePreference(BaseTestCase): + """Tests for #1322: prefer the tz database for conflicting abbreviations. + + ``dateparser/timezones.py`` maps every timezone abbreviation to a single UTC + offset, and unrelated zones often share the same letters. The table was + scraped from Wikipedia, so a few abbreviations ended up with a meaning no tz + database zone has: "BST" resolved to +11, although the only zone named "BST" + today is British Summer Time at +1 (#1321). + + The rule pinned down here is that when the tz database names exactly one + offset for an abbreviation, dateparser has to use it, and when the tz + database names several, dateparser's existing choice is left alone. + + The tests that exercise the comparison itself run against + ``FROZEN_TZ_DATABASE`` so that they keep testing the same logic as the tz + database changes; the two that check dateparser's actual data are the ones + that read the installed tz database. + """ + + # A stand-in for the tz database: "BST"/"HDT" named by one offset each, + # "CST" by three (US Central, Cuba, China). + FROZEN_TZ_DATABASE = { + "BST": {3600}, + "HDT": {-32400}, + "CST": {-21600, -18000, 28800}, + } + + @classmethod + def setUpClass(cls): + super().setUpClass() + from dateparser_scripts import tz_abbreviation_conflicts + + cls.checker = tz_abbreviation_conflicts + # Sampling every zone takes a moment, so it is done once for the class. + cls.tz_database = tz_abbreviation_conflicts.tz_database_abbreviations() + + def offset_of(self, date_string): + _, timezone_offset = pop_tz_offset_from_string(date_string) + self.assertIsNotNone(timezone_offset, f"no timezone found in {date_string!r}") + return timezone_offset.utcoffset(None) + + @parameterized.expand( + [ + # British Summer Time, the case reported in #1321. + param("13 August 2026 10:00 BST", +1, "BST"), + # Hawaii-Aleutian Daylight Time (America/Adak). The table used + # -9:30, which is what Pacific/Honolulu called "HDT" back when + # Hawaii kept -10:30; no zone has been named that since. + param("13 August 2026 10:00 HDT", -9, "HDT"), + ] + ) + def test_unambiguous_abbreviation_uses_tz_database_offset( + self, date_string, expected_offset, abbreviation + ): + self.assertEqual(timedelta(hours=expected_offset), self.offset_of(date_string)) + # And the tz database really does name only that one offset. + self.assertEqual({int(expected_offset * 3600)}, self.tz_database[abbreviation]) + + @parameterized.expand( + [ + param("13 August 2026 10:00 BST", +1, "BST"), + param("13 August 2026 10:00 HDT", -9, "HDT"), + ] + ) + def test_unambiguous_abbreviation_parses_end_to_end( + self, date_string, expected_offset, abbreviation + ): + # The #1321 report as a user would hit it, not just at the popping layer. + parsed = parse(date_string, settings={"RETURN_AS_TIMEZONE_AWARE": True}) + self.assertEqual(timedelta(hours=expected_offset), parsed.utcoffset()) + self.assertEqual(abbreviation, parsed.tzname()) + + @parameterized.expand( + [ + # US Central, but "CST" also names Cuba (-5) and China (+8). + param("13 August 2026 10:00 CST", -6), + # US Central Daylight, but "CDT" also names Cuba (-4). + param("13 August 2026 10:00 CDT", -5), + # Israel, but "IST" also names India (+5:30) and Ireland (+1). + param("13 August 2026 10:00 IST", +2), + # US Pacific, but "PST" also names the Philippines (+8). + param("13 August 2026 10:00 PST", -8), + ] + ) + def test_ambiguous_abbreviation_keeps_its_offset( + self, date_string, expected_offset + ): + # These keep the value dateparser has always used. The assertion below + # holds whether or not the abbreviation stays ambiguous: what matters is + # that the retained value is one a real zone uses, not an arbitrary one. + self.assertEqual(timedelta(hours=expected_offset), self.offset_of(date_string)) + abbreviation = date_string.rsplit(" ", 1)[1] + self.assertIn(int(expected_offset * 3600), self.tz_database[abbreviation]) + + def test_table_agrees_with_the_tz_database(self): + # The generalized check behind #1322: instead of asserting a fixed list + # of abbreviations, ask the tz database about every abbreviation the two + # tables share, so a regression on any of them is caught. + shared = set(self.checker.static_tz_abbreviations()) & set(self.tz_database) + # Without this, the assertion below would also pass if the comparison + # silently stopped covering anything. + self.assertGreater( + len(shared), 40, f"only {len(shared)} abbreviations compared" + ) + conflicts = self.checker.find_conflicts(tz_database=self.tz_database) + self.assertEqual([], conflicts, f"conflicts with the tz database: {conflicts}") + + def test_report_runs_clean(self): + # Exercises the module's entry point with its real defaults, which the + # test above bypasses by passing the tz database in. + self.assertEqual(0, self.checker.main()) + + def test_reference_years_stay_in_settled_years(self): + # The tz database records future daylight-saving rules as predictions + # that change between releases, so sampling them would tie the result to + # the installed version rather than to real usage. + self.assertLess(max(self.checker.REFERENCE_YEARS), datetime.now().year) + + def test_pre_fix_offsets_are_reported_as_conflicts(self): + # Reproduces the bug this change fixes, and keeps the whole-table check + # from passing vacuously: the offsets shipped before #1322 are flagged. + conflicts = self.checker.find_conflicts( + static={"BST": 39600, "HDT": -34200}, + tz_database=self.FROZEN_TZ_DATABASE, + ) + self.assertEqual( + [ + ("BST", "unambiguous", 39600, [3600]), + ("HDT", "unambiguous", -34200, [-32400]), + ], + [tuple(conflict) for conflict in conflicts], + ) + + def test_offset_no_zone_uses_is_reported_even_when_ambiguous(self): + # "CST" has several meanings, so none of them can be preferred, but +11 + # is not one of them and is still worth reporting. + (conflict,) = self.checker.find_conflicts( + static={"CST": 39600}, tz_database=self.FROZEN_TZ_DATABASE + ) + self.assertEqual("CST", conflict.abbreviation) + self.assertEqual("unsupported", conflict.kind) + self.assertNotIn(39600, conflict.tz_database_offsets) + + @parameterized.expand([param(-21600), param(28800)]) + def test_any_offset_a_zone_really_uses_is_accepted(self, offset): + # Both US Central (-6) and China (+8) are legitimate readings of "CST". + self.assertEqual( + [], + self.checker.find_conflicts( + static={"CST": offset}, tz_database=self.FROZEN_TZ_DATABASE + ), + ) + + def test_abbreviations_outside_the_reference_window_are_ignored(self): + # dateparser keeps abbreviations no zone is named after any more, such + # as "AHST", so historical text still parses. The tz database says + # nothing about them, so they are skipped rather than reported. + self.assertNotIn("AHST", self.tz_database) + self.assertEqual( + [], + self.checker.find_conflicts( + static={"AHST": -36000}, tz_database=self.FROZEN_TZ_DATABASE + ), + ) + + def test_abbreviations_are_compared_case_insensitively(self): + # dateparser matches abbreviations regardless of case, so the table's + # "ChST" entry and the tz database's "ChST" are one abbreviation and + # have to meet under the same key. + self.assertIn("CHST", self.checker.static_tz_abbreviations()) + self.assertIn("CHST", self.tz_database) + + def test_numeric_zone_names_are_not_treated_as_abbreviations(self): + # The tz database names zones that have no established abbreviation + # after their offset, as in "+11" or "-0930". Those are offsets rather + # than identities, and dateparser matches numeric offsets through its + # separate UTC/GMT patterns, so they stay out of this comparison. + self.assertEqual([], [name for name in self.tz_database if name[0] in "+-"]) + self.assertIn("BST", self.tz_database) + + def test_repeated_abbreviation_resolves_to_its_first_entry(self): + # "LMT" is listed four times with four different offsets. Only the first + # can ever match, so that is the value the comparison has to use; + # checking against all four would hide a wrong first entry. + self.assertEqual( + self.checker.static_tz_abbreviations()["LMT"], + self.offset_of("13 August 2026 10:00 LMT").total_seconds(), + ) From de7b986fa1fe3c7830bdb922435501ad871c55c3 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 13 Aug 2026 14:59:12 +0200 Subject: [PATCH 049/107] tests: add CodSpeed benchmarks (#1365) Add CodSpeed benchmarks and a GitHub Actions workflow that runs them, so a performance regression like the one fixed in #1335 is reported on the pull request that introduces it instead of being noticed as a hang. The benchmarks cover the paths #1335 touched: PATTERN.findall()/sub() in freshness_date_parser, the relative-split regex Dictionary builds from the locale's relative-type-regex entries, and dateparser.parse() end to end. Each long-digit-run benchmark is sized so that a reintroduced regression is a ~500x jump that still finishes and reports rather than timing out. The benchmarks live in a dedicated tox environment and are skipped when pytest-codspeed is not installed, leaving the regular test runs unchanged. Closes #1336 Co-authored-by: Claude Opus 5 (1M context) --- .github/workflows/codspeed.yml | 56 +++++++++++++++++ .gitignore | 3 + tests/benchmarks/__init__.py | 41 +++++++++++++ .../test_benchmark_freshness_date_parser.py | 60 +++++++++++++++++++ tests/benchmarks/test_benchmark_languages.py | 40 +++++++++++++ tests/benchmarks/test_benchmark_parse.py | 52 ++++++++++++++++ tox.ini | 21 ++++++- 7 files changed, 272 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/codspeed.yml create mode 100644 tests/benchmarks/__init__.py create mode 100644 tests/benchmarks/test_benchmark_freshness_date_parser.py create mode 100644 tests/benchmarks/test_benchmark_languages.py create mode 100644 tests/benchmarks/test_benchmark_parse.py diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml new file mode 100644 index 000000000..e979aea7e --- /dev/null +++ b/.github/workflows/codspeed.yml @@ -0,0 +1,56 @@ +name: CodSpeed +on: + push: + branches: + - master + pull_request: + branches: + - master + paths: + - dateparser/** + - dateparser_data/** + - tests/benchmarks/** + - pytest.ini + - tox.ini + - pyproject.toml + - .github/workflows/codspeed.yml + # Lets CodSpeed trigger a run to collect the initial baseline. + workflow_dispatch: + +# Superseded runs of the same pull request are cancelled. Outside pull requests +# the group is unique per run, so a master baseline is never cancelled. +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read + +jobs: + benchmarks: + name: Run benchmarks + runs-on: ubuntu-latest + # A reintroduced #1335-style regression makes the benchmarks orders of + # magnitude slower, so cap the job instead of letting it run for hours. + timeout-minutes: 30 + permissions: + contents: read + id-token: write + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.13" + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install tox + tox -e benchmark --notest + - name: Run benchmarks + uses: CodSpeedHQ/action@v5 + with: + mode: simulation + # The step above already built the environment, so the measured command + # only runs pytest instead of packaging and installing again. + run: tox -e benchmark --skip-pkg-install diff --git a/.gitignore b/.gitignore index 9cadfbae5..a638f02d5 100644 --- a/.gitignore +++ b/.gitignore @@ -53,5 +53,8 @@ docs/_build # CLDR /cldr-json/ +# CodSpeed +.codspeed + # Other raw_data diff --git a/tests/benchmarks/__init__.py b/tests/benchmarks/__init__.py new file mode 100644 index 000000000..28b5f402f --- /dev/null +++ b/tests/benchmarks/__init__.py @@ -0,0 +1,41 @@ +"""CodSpeed benchmarks. + +These are only collected when ``pytest-codspeed`` is installed, which is the +case in the dedicated ``benchmark`` tox environment (see ``tox.ini``). In every +other environment they are skipped, so the regular test runs are unaffected. +""" + +import pytest + +pytest.importorskip("pytest_codspeed", reason="Benchmark tests require pytest-codspeed") + +# Relative date strings in the form the freshness parser actually receives them: +# the locale translates the input first, which turns plural units singular +# ("2 hours, 50 minutes ago" -> "2 hour 50 minute ago"). PATTERN only matches +# singular units, so benchmarking the untranslated strings would measure a failed +# scan instead of the real workload. +# +# Each benchmark runs the whole list rather than a single string: CodSpeed's +# simulation mode measures one call, and a lone match on a short string is too +# small a unit of work to be meaningful. +TRANSLATED_RELATIVE_STRINGS = [ + "1 minute ago", + "2 hour 50 minute ago", + "3 day ago", + "in 2 week", + "10.5 year ago", + "1 day 2 hour 3 minute 4 second ago", +] + +# A long run of digits: the input shape that made the relative-date regexes +# backtrack superlinearly before #1335. Deliberately pathological rather than +# realistic -- it is what turns a reintroduced regression into an unmissable +# signal. +# +# The length is chosen so that a regressed run still *finishes and reports*: +# with the old greedy quantifiers this takes ~380ms against ~0.7ms for the +# possessive ones, a ~500x jump that no threshold can miss, while remaining a +# handful of seconds under CodSpeed's instrumentation. The 3200 digits of the +# original #1335 repro would instead need ~20 minutes per benchmark once +# regressed, so the job would time out without ever reporting. +LONG_DIGIT_RUN = "9" * 800 diff --git a/tests/benchmarks/test_benchmark_freshness_date_parser.py b/tests/benchmarks/test_benchmark_freshness_date_parser.py new file mode 100644 index 000000000..cf22bbbf4 --- /dev/null +++ b/tests/benchmarks/test_benchmark_freshness_date_parser.py @@ -0,0 +1,60 @@ +r"""Benchmarks for :mod:`dateparser.freshness_date_parser`. + +``PATTERN`` matches a number followed by a time unit, and is applied to the whole +input string by ``findall()`` (in ``get_kwargs()``) and by ``sub()`` (in +``_parse_time()``). Until #1335 it spelled the number as the greedy +``\d+[.,]?\d*``, whose adjacent digit quantifiers backtrack without ever +changing the match, so the cost grew superlinearly with the length of a digit +run. #1335 made the quantifiers possessive (``\d++[.,]?\d*+``). +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from dateparser.freshness_date_parser import PATTERN, freshness_date_parser +from tests.benchmarks import LONG_DIGIT_RUN, TRANSLATED_RELATIVE_STRINGS + +if TYPE_CHECKING: + from pytest_codspeed import BenchmarkFixture + + +def test_freshness_pattern_findall(benchmark: BenchmarkFixture) -> None: + def run(): + for date_string in TRANSLATED_RELATIVE_STRINGS: + PATTERN.findall(date_string) + + # Guard against measuring a no-op: were PATTERN to stop matching these + # inputs, the benchmark would get faster instead of failing. + assert PATTERN.findall(TRANSLATED_RELATIVE_STRINGS[-1]) == [ + ("1", "day"), + (" 2", "hour"), + (" 3", "minute"), + (" 4", "second"), + ] + + benchmark(run) + + +def test_freshness_pattern_findall_long_digit_run(benchmark: BenchmarkFixture) -> None: + assert PATTERN.findall(LONG_DIGIT_RUN) == [] + + benchmark(lambda: PATTERN.findall(LONG_DIGIT_RUN)) + + +def test_freshness_pattern_sub_long_digit_run(benchmark: BenchmarkFixture) -> None: + """``_parse_time()`` runs ``PATTERN.sub()`` over the input as well.""" + assert PATTERN.sub("", LONG_DIGIT_RUN) == LONG_DIGIT_RUN + + benchmark(lambda: PATTERN.sub("", LONG_DIGIT_RUN)) + + +def test_freshness_get_kwargs(benchmark: BenchmarkFixture) -> None: + def run(): + for date_string in TRANSLATED_RELATIVE_STRINGS: + freshness_date_parser.get_kwargs(date_string) + + kwargs, _ = freshness_date_parser.get_kwargs(TRANSLATED_RELATIVE_STRINGS[1]) + assert kwargs == {"hours": 2.0, "minutes": 50.0} + + benchmark(run) diff --git a/tests/benchmarks/test_benchmark_languages.py b/tests/benchmarks/test_benchmark_languages.py new file mode 100644 index 000000000..d5c39f635 --- /dev/null +++ b/tests/benchmarks/test_benchmark_languages.py @@ -0,0 +1,40 @@ +r"""Benchmarks for :mod:`dateparser.languages.dictionary`. + +``Dictionary.split()`` first splits the input with a regex built from the +locale's ``relative-type-regex`` entries. Those entries carried the same greedy +``\d+[.,]?\d*`` that #1335 replaced with the possessive ``\d++[.,]?\d*+``, and +because the alternation is applied by ``re.split()`` across the whole input, a +long digit run backtracked quadratically here too. + +The typical-input side of ``Dictionary.split()`` is covered end to end by +``test_benchmark_parse.py``, which reaches it through the real locale objects. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import dateparser.data.date_translation_data.en as en_data +from dateparser.conf import settings +from dateparser.languages.dictionary import Dictionary +from tests.benchmarks import LONG_DIGIT_RUN + +if TYPE_CHECKING: + from pytest_codspeed import BenchmarkFixture + + +def test_dictionary_split_relative_regex_long_digit_run( + benchmark: BenchmarkFixture, +) -> None: + # Only the compiled relative-split regex is taken from the dictionary, as + # ``tests/test_freshness_date_parser.py`` already does. For English the + # regex a plain Dictionary compiles is identical to the NormalizedDictionary + # one the parser uses, since normalization leaves these strings untouched. + split_relative_regex = Dictionary( + en_data.info, settings + )._get_split_relative_regex_cache() + + # A digit run holds no relative-date string, so it must come back unsplit. + assert split_relative_regex.split(LONG_DIGIT_RUN) == [LONG_DIGIT_RUN] + + benchmark(lambda: split_relative_regex.split(LONG_DIGIT_RUN)) diff --git a/tests/benchmarks/test_benchmark_parse.py b/tests/benchmarks/test_benchmark_parse.py new file mode 100644 index 000000000..94262cad4 --- /dev/null +++ b/tests/benchmarks/test_benchmark_parse.py @@ -0,0 +1,52 @@ +"""Benchmarks for the public :func:`dateparser.parse` entry point. + +Where the other benchmark modules pin down individual regexes, these cover the +end-to-end cost a caller actually pays, so that a slowdown anywhere in the +parsing pipeline is caught too. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +import dateparser + +if TYPE_CHECKING: + from pytest_codspeed import BenchmarkFixture + +RELATIVE_DATE_STRINGS = [ + "2 hours ago", + "3 days ago", + "in 5 minutes", + "a week ago", + "2 months, 3 weeks ago", +] + +ABSOLUTE_DATE_STRINGS = [ + "2015-06-01", + "June 1, 2015", + "01/06/2015", + "1st of June 2015", + "2015-06-01T13:00:00Z", +] + + +def _benchmark_parse(benchmark: BenchmarkFixture, date_strings: list[str]) -> None: + def run(): + for date_string in date_strings: + dateparser.parse(date_string) + + # Load the locale data and warm the parser caches outside the measurement. + run() + + assert dateparser.parse(date_strings[0]) is not None + + benchmark(run) + + +def test_parse_relative_date_strings(benchmark: BenchmarkFixture) -> None: + _benchmark_parse(benchmark, RELATIVE_DATE_STRINGS) + + +def test_parse_absolute_date_strings(benchmark: BenchmarkFixture) -> None: + _benchmark_parse(benchmark, ABSOLUTE_DATE_STRINGS) diff --git a/tox.ini b/tox.ini index ad2c5610e..6600c6eaf 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = pre-commit,min,min-all,py310,py311,py312,py313,py314,all,scripts,docs,twinedeck +envlist = pre-commit,min,min-all,py310,py311,py312,py313,py314,all,scripts,docs,twinedeck,benchmark [base] deps = @@ -70,3 +70,22 @@ deps = commands = python -m build --sdist --wheel twine check dist/* + +# Pinned to a single interpreter: CodSpeed compares measurements across runs, and +# instruction counts are not comparable between Python versions. +[testenv:benchmark] +basepython = python3.13 +deps = + {[base]deps} + pytest-codspeed +# The CodSpeed runner drives pytest-codspeed through CODSPEED_* variables, which +# have to reach the command tox runs for any measurement to happen. +passenv = + *codspeed* + *ci* +# tox picks a random hash seed per run, which would show up as noise in the +# instruction counts CodSpeed compares. +set_env = + PYTHONHASHSEED = 0 +commands = + pytest tests/benchmarks/ --no-cov --codspeed From cd9bb13e63f41eb5f44074cfdc73a41aa62293e1 Mon Sep 17 00:00:00 2001 From: Adrian Date: Mon, 24 Aug 2026 16:59:12 +0200 Subject: [PATCH 050/107] Make thread-safe (#1346) --- dateparser/date.py | 44 +++++---- dateparser/date_parser.py | 6 +- dateparser/languages/dictionary.py | 139 +++++++++++++++------------ dateparser/languages/loader.py | 40 +++++--- dateparser/languages/locale.py | 146 ++++++++++++++++++----------- dateparser/parser.py | 24 ++--- dateparser/search/search.py | 5 +- dateparser/utils/__init__.py | 24 +++-- tests/test_thread_safety.py | 128 +++++++++++++++++++++++++ 9 files changed, 383 insertions(+), 173 deletions(-) create mode 100644 tests/test_thread_safety.py diff --git a/dateparser/date.py b/dateparser/date.py index 28aacbdf6..ce0dbdb6d 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -1,4 +1,5 @@ import collections +import threading from collections.abc import Set from datetime import datetime, timedelta, timezone @@ -360,21 +361,18 @@ def _try_parser(self, parse_method): translated = self._get_translated_date() - try: - for order in candidates: - self._settings.DATE_ORDER = order - try: - date_obj, period = date_parser.parse( - translated, - parse_method=parse_method, - settings=self._settings, - ) - return DateData(date_obj=date_obj, period=period) - except ValueError: - continue - return None - finally: - self._settings.DATE_ORDER = original_order + for order in candidates: + try: + date_obj, period = date_parser.parse( + translated, + parse_method=parse_method, + settings=self._settings, + date_order=order, + ) + return DateData(date_obj=date_obj, period=period) + except ValueError: + continue + return None def _try_given_formats(self): if not self.date_formats: @@ -550,6 +548,9 @@ def __init__( self.region = region self.detect_languages_function = detect_languages_function self.previous_locales = collections.OrderedDict() + # Guards the per-instance state mutated when a parser is shared by + # multiple threads (previous_locales and the lazily detected languages). + self._lock = threading.RLock() def get_date_data(self, date_string, date_formats=None): """ @@ -631,7 +632,8 @@ def _parse_using_applicable_locales( if parsed_date: parsed_date["locale"] = locale.shortname if self.try_previous_locales: - self.previous_locales[locale] = None + with self._lock: + self.previous_locales[locale] = None return parsed_date return None @@ -671,7 +673,9 @@ def date_strings(): yield stripped_date_string if self.try_previous_locales: - for locale in self.previous_locales.keys(): + with self._lock: + previous_locales = list(self.previous_locales.keys()) + for locale in previous_locales: for s in date_strings(): if self._is_applicable_locale(locale, s, ignore_surrounding_text): yield locale @@ -711,8 +715,12 @@ def _is_applicable_locale(self, locale, date_string, ignore_surrounding_text=Fal ignore_surrounding_text=ignore_surrounding_text, ) + _locale_loader_lock = threading.Lock() + @classmethod def _get_locale_loader(cls): if not cls.locale_loader: - cls.locale_loader = LocaleDataLoader() + with cls._locale_loader_lock: + if not cls.locale_loader: + cls.locale_loader = LocaleDataLoader() return cls.locale_loader diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py index d65b03eb5..ccba0427b 100644 --- a/dateparser/date_parser.py +++ b/dateparser/date_parser.py @@ -9,7 +9,7 @@ class DateParser: @apply_settings - def parse(self, date_string, parse_method, settings=None): + def parse(self, date_string, parse_method, settings=None, date_order=None): date_string = str(date_string) if not date_string.strip(): @@ -18,7 +18,9 @@ def parse(self, date_string, parse_method, settings=None): date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) - date_obj, period = parse_method(date_string, settings=settings, tz=ptz) + date_obj, period = parse_method( + date_string, settings=settings, tz=ptz, date_order=date_order + ) _settings_tz = settings.TIMEZONE.lower() diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index 2249645c4..e5ee4da63 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -1,3 +1,4 @@ +import threading from itertools import chain, zip_longest from operator import methodcaller @@ -81,6 +82,11 @@ class Dictionary: _sorted_relative_strings_cache = {} _match_relative_regex_cache = {} + # The caches above are shared across all Dictionary instances and threads. + # The lock keeps each check-populate-evict-read sequence atomic, so a + # concurrent eviction cannot drop an entry between its check and its read. + _cache_lock = threading.RLock() + def __init__(self, locale_info, settings=None): dictionary = {} self._settings = settings @@ -229,12 +235,16 @@ def split(self, string, keep_formatting=False): return list(filter(bool, chain.from_iterable(tokens))) def _add_to_cache(self, value, cache): - cache.setdefault(self._settings.registry_key, {})[self.info["name"]] = value - if ( - self._settings.CACHE_SIZE_LIMIT - and len(cache) > self._settings.CACHE_SIZE_LIMIT - ): - cache.pop(list(cache.keys())[0]) + with self._cache_lock: + key = self._settings.registry_key + entry = cache.pop(key, {}) + entry[self.info["name"]] = value + cache[key] = entry + if ( + self._settings.CACHE_SIZE_LIMIT + and len(cache) > self._settings.CACHE_SIZE_LIMIT + ): + cache.pop(next(iter(cache))) def _split_by_known_words(self, string: str, keep_formatting: bool): regex = self._get_split_regex_cache() @@ -292,25 +302,31 @@ def _should_capture(self, token, keep_formatting): ) def _get_sorted_words_from_cache(self): - if ( - self._settings.registry_key not in self._sorted_words_cache - or self.info["name"] - not in self._sorted_words_cache[self._settings.registry_key] - ): - self._add_to_cache( - cache=self._sorted_words_cache, - value=sorted([key for key in self], key=len, reverse=True), - ) - return self._sorted_words_cache[self._settings.registry_key][self.info["name"]] + with self._cache_lock: + if ( + self._settings.registry_key not in self._sorted_words_cache + or self.info["name"] + not in self._sorted_words_cache[self._settings.registry_key] + ): + self._add_to_cache( + cache=self._sorted_words_cache, + value=sorted([key for key in self], key=len, reverse=True), + ) + return self._sorted_words_cache[self._settings.registry_key][ + self.info["name"] + ] def _get_split_regex_cache(self): - if ( - self._settings.registry_key not in self._split_regex_cache - or self.info["name"] - not in self._split_regex_cache[self._settings.registry_key] - ): - self._construct_split_regex() - return self._split_regex_cache[self._settings.registry_key][self.info["name"]] + with self._cache_lock: + if ( + self._settings.registry_key not in self._split_regex_cache + or self.info["name"] + not in self._split_regex_cache[self._settings.registry_key] + ): + self._construct_split_regex() + return self._split_regex_cache[self._settings.registry_key][ + self.info["name"] + ] def _construct_split_regex(self): known_words_group = "|".join( @@ -328,36 +344,38 @@ def _construct_split_regex(self): ) def _get_sorted_relative_strings_from_cache(self): - if ( - self._settings.registry_key not in self._sorted_relative_strings_cache - or self.info["name"] - not in self._sorted_relative_strings_cache[self._settings.registry_key] - ): - self._add_to_cache( - cache=self._sorted_relative_strings_cache, - value=sorted( - [ - PARENTHESES_PATTERN.sub("", key) - for key in self._relative_strings - ], - key=len, - reverse=True, - ), - ) - return self._sorted_relative_strings_cache[self._settings.registry_key][ - self.info["name"] - ] + with self._cache_lock: + if ( + self._settings.registry_key not in self._sorted_relative_strings_cache + or self.info["name"] + not in self._sorted_relative_strings_cache[self._settings.registry_key] + ): + self._add_to_cache( + cache=self._sorted_relative_strings_cache, + value=sorted( + [ + PARENTHESES_PATTERN.sub("", key) + for key in self._relative_strings + ], + key=len, + reverse=True, + ), + ) + return self._sorted_relative_strings_cache[self._settings.registry_key][ + self.info["name"] + ] def _get_split_relative_regex_cache(self): - if ( - self._settings.registry_key not in self._split_relative_regex_cache - or self.info["name"] - not in self._split_relative_regex_cache[self._settings.registry_key] - ): - self._construct_split_relative_regex() - return self._split_relative_regex_cache[self._settings.registry_key][ - self.info["name"] - ] + with self._cache_lock: + if ( + self._settings.registry_key not in self._split_relative_regex_cache + or self.info["name"] + not in self._split_relative_regex_cache[self._settings.registry_key] + ): + self._construct_split_relative_regex() + return self._split_relative_regex_cache[self._settings.registry_key][ + self.info["name"] + ] def _construct_split_relative_regex(self): known_relative_strings_group = "|".join( @@ -375,15 +393,16 @@ def _construct_split_relative_regex(self): ) def _get_match_relative_regex_cache(self): - if ( - self._settings.registry_key not in self._match_relative_regex_cache - or self.info["name"] - not in self._match_relative_regex_cache[self._settings.registry_key] - ): - self._construct_match_relative_regex() - return self._match_relative_regex_cache[self._settings.registry_key][ - self.info["name"] - ] + with self._cache_lock: + if ( + self._settings.registry_key not in self._match_relative_regex_cache + or self.info["name"] + not in self._match_relative_regex_cache[self._settings.registry_key] + ): + self._construct_match_relative_regex() + return self._match_relative_regex_cache[self._settings.registry_key][ + self.info["name"] + ] def _construct_match_relative_regex(self): known_relative_strings_group = "|".join( diff --git a/dateparser/languages/loader.py b/dateparser/languages/loader.py index e6d5225f2..138340a7c 100644 --- a/dateparser/languages/loader.py +++ b/dateparser/languages/loader.py @@ -1,3 +1,4 @@ +import threading from collections import OrderedDict from copy import deepcopy from importlib import import_module @@ -41,6 +42,7 @@ class LocaleDataLoader: _loaded_languages = {} _loaded_locales = {} + _load_lock = threading.Lock() def get_locale_map( self, @@ -203,22 +205,30 @@ def _load_data( ) for shortname, lang_reg in locale_dict.items(): - if shortname not in self._loaded_locales: - lang, reg = lang_reg - if lang in self._loaded_languages: - locale = Locale( - shortname, language_info=deepcopy(self._loaded_languages[lang]) - ) - self._loaded_locales[shortname] = locale - else: - language_info = getattr( - import_module("dateparser.data.date_translation_data." + lang), - "info", - ) - locale = Locale(shortname, language_info=deepcopy(language_info)) - self._loaded_languages[lang] = language_info + with self._load_lock: + if shortname not in self._loaded_locales: + lang, reg = lang_reg + if lang in self._loaded_languages: + locale = Locale( + shortname, + language_info=deepcopy(self._loaded_languages[lang]), + ) + else: + language_info = getattr( + import_module( + "dateparser.data.date_translation_data." + lang + ), + "info", + ) + locale = Locale( + shortname, language_info=deepcopy(language_info) + ) + self._loaded_languages[lang] = language_info + # Store only once fully built so concurrent readers never see + # a half-initialised locale. self._loaded_locales[shortname] = locale - yield shortname, self._loaded_locales[shortname] + locale = self._loaded_locales[shortname] + yield shortname, locale default_loader = LocaleDataLoader() diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 0da76dc4f..800dd0557 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -1,3 +1,5 @@ +import copy +import threading from itertools import chain import regex as re @@ -53,6 +55,9 @@ def __init__(self, shortname, language_info): ) self.info = combine_dicts(language_info, locale_specific_info) self.info.pop("locale_specific", None) + # This locale instance is cached and shared across threads; the lock + # guards lazy initialisation of the cached attributes below. + self._lock = threading.RLock() def is_applicable( self, @@ -239,18 +244,19 @@ def _translate_numerals(self, date_string): return "".join(date_string_tokens) def _get_relative_translations(self, settings=None): - if settings.NORMALIZE: - if self._normalized_relative_translations is None: - self._normalized_relative_translations = ( - self._generate_relative_translations(normalize=True) - ) - return self._normalized_relative_translations - else: - if self._relative_translations is None: - self._relative_translations = self._generate_relative_translations( - normalize=False - ) - return self._relative_translations + with self._lock: + if settings.NORMALIZE: + if self._normalized_relative_translations is None: + self._normalized_relative_translations = ( + self._generate_relative_translations(normalize=True) + ) + return self._normalized_relative_translations + else: + if self._relative_translations is None: + self._relative_translations = self._generate_relative_translations( + normalize=False + ) + return self._relative_translations def _generate_relative_translations(self, normalize=False): relative_translations = self.info.get("relative-type-regex", {}) @@ -347,13 +353,14 @@ def translate_search(self, search_string, settings=None): def _get_abbreviations(self, settings): dictionary = self._get_dictionary(settings=settings) - abbreviations = [] - if self._abbreviations is None: - for item in dictionary: - if item.endswith(".") and len(item) > 1: - abbreviations.append(item) - self._abbreviations = abbreviations - return self._abbreviations + with self._lock: + if self._abbreviations is None: + abbreviations = [] + for item in dictionary: + if item.endswith(".") and len(item) > 1: + abbreviations.append(item) + self._abbreviations = abbreviations + return self._abbreviations def _sentence_split(self, string, settings): abbreviations = self._get_abbreviations(settings=settings) @@ -439,11 +446,15 @@ def _simplify_split_align(self, original, settings): return original_tokens, simplified_tokens def _get_split_dictionary(self, settings): - if self._split_dictionary is None: - settings.NORMALIZE = True - dictionary = self._get_dictionary(settings=settings) - self._split_dictionary = self._split_dict(dictionary) - return self._split_dictionary + with self._lock: + if self._split_dictionary is None: + # The split dictionary is always built from the normalized + # dictionary, regardless of the ``NORMALIZE`` setting. + dictionary = self._bind_settings( + self._get_normalized_dictionary(settings), settings + ) + self._split_dictionary = self._split_dict(dictionary) + return self._split_dictionary def _split_dict(self, dictionary): newdict = {} @@ -541,29 +552,34 @@ def replace_number_pairs(match): def _get_simplifications(self, settings=None): no_word_spacing = _parse_bool(self.info.get("no_word_spacing", False)) - if settings.NORMALIZE: - if self._normalized_simplifications is None: - self._normalized_simplifications = [] - simplifications = self._generate_simplifications(normalize=True) - for simplification in simplifications: - pattern, replacement = list(simplification.items())[0] - if not no_word_spacing: - pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern - pattern = re.compile(pattern, flags=re.I | re.U) - self._normalized_simplifications.append({pattern: replacement}) - return self._normalized_simplifications + with self._lock: + if settings.NORMALIZE: + if self._normalized_simplifications is None: + normalized_simplifications = [] + simplifications = self._generate_simplifications(normalize=True) + for simplification in simplifications: + pattern, replacement = list(simplification.items())[0] + if not no_word_spacing: + pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern + pattern = re.compile(pattern, flags=re.I | re.U) + normalized_simplifications.append({pattern: replacement}) + # Assign only once fully built so other threads never observe + # a partially-populated list. + self._normalized_simplifications = normalized_simplifications + return self._normalized_simplifications - else: - if self._simplifications is None: - self._simplifications = [] - simplifications = self._generate_simplifications(normalize=False) - for simplification in simplifications: - pattern, replacement = list(simplification.items())[0] - if not no_word_spacing: - pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern - pattern = re.compile(pattern, flags=re.I | re.U) - self._simplifications.append({pattern: replacement}) - return self._simplifications + else: + if self._simplifications is None: + simplifications_built = [] + simplifications = self._generate_simplifications(normalize=False) + for simplification in simplifications: + pattern, replacement = list(simplification.items())[0] + if not no_word_spacing: + pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern + pattern = re.compile(pattern, flags=re.I | re.U) + simplifications_built.append({pattern: replacement}) + self._simplifications = simplifications_built + return self._simplifications def _generate_simplifications(self, normalize=False): simplifications = [] @@ -603,25 +619,41 @@ def _join(self, tokens, separator=" ", settings=None): def _get_dictionary(self, settings=None): if not settings.NORMALIZE: + return self._bind_settings(self._get_base_dictionary(), settings) + return self._bind_settings(self._get_normalized_dictionary(settings), settings) + + def _get_base_dictionary(self): + with self._lock: if self._dictionary is None: self._generate_dictionary() - self._dictionary._settings = settings return self._dictionary - else: + + def _get_normalized_dictionary(self, settings=None): + with self._lock: if self._normalized_dictionary is None: self._generate_normalized_dictionary() - self._normalized_dictionary._settings = settings return self._normalized_dictionary + @staticmethod + def _bind_settings(dictionary, settings): + # A shallow copy shares the heavy state (translations, regex caches) by + # reference but gets its own settings, so the shared, cached dictionary + # instance is not mutated per call. + bound = copy.copy(dictionary) + bound._settings = settings + return bound + def _get_wordchars(self, settings=None): - if self._wordchars is None: - self._set_wordchars(settings) - return self._wordchars + with self._lock: + if self._wordchars is None: + self._set_wordchars(settings) + return self._wordchars def _get_splitters(self, settings=None): - if self._splitters is None: - self._set_splitters(settings) - return self._splitters + with self._lock: + if self._splitters is None: + self._set_splitters(settings) + return self._splitters def _set_splitters(self, settings=None): splitters = { @@ -664,7 +696,9 @@ def _set_wordchars(self, settings=None): } def get_wordchars_for_detection(self, settings): - if self._wordchars_for_detection is None: + with self._lock: + if self._wordchars_for_detection is not None: + return self._wordchars_for_detection wordchars = set() for word in self._get_dictionary(settings): if re.match(r"^[\W\d_]+$", word, re.UNICODE): diff --git a/dateparser/parser.py b/dateparser/parser.py index 1f3e4719c..2c55de976 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -65,12 +65,12 @@ def resolve_date_order(order, lst=None): return chart_list[order] if lst else date_order_chart[order] -def _parse_absolute(datestring, settings, tz=None): - return _parser.parse(datestring, settings, tz) +def _parse_absolute(datestring, settings, tz=None, date_order=None): + return _parser.parse(datestring, settings, tz, date_order=date_order) -def _parse_nospaces(datestring, settings, tz=None): - return _no_spaces_parser.parse(datestring, settings) +def _parse_nospaces(datestring, settings, tz=None, date_order=None): + return _no_spaces_parser.parse(datestring, settings, date_order=date_order) class _time_parser: @@ -186,7 +186,7 @@ def _find_best_matching_date(cls, datestring): return None @classmethod - def parse(cls, datestring, settings): + def parse(cls, datestring, settings, date_order=None): if not no_space_parser_eligibile(datestring): raise ValueError("Unable to parse date from: %s" % datestring) @@ -194,8 +194,9 @@ def parse(cls, datestring, settings): if not datestring: raise ValueError("Empty string") tokens = tokenizer(datestring) - if settings.DATE_ORDER: - order = resolve_date_order(settings.DATE_ORDER) + date_order = date_order or settings.DATE_ORDER + if date_order: + order = resolve_date_order(date_order) else: order = cls._default_order if EIGHT_DIGIT.match(datestring): @@ -249,8 +250,9 @@ class _parser: "year": ["%y", "%Y"], } - def __init__(self, tokens, settings): + def __init__(self, tokens, settings, date_order=None): self.settings = settings + self._date_order = date_order or settings.DATE_ORDER self.tokens = [(t[0].strip(), t[1]) for t in list(tokens)] self.filtered_tokens = [ (t[0], t[1], i) for i, t in enumerate(self.tokens) if t[1] <= 1 @@ -272,7 +274,7 @@ def __init__(self, tokens, settings): self.ordered_num_directives = { k: self.num_directives[k] - for k in resolve_date_order(settings.DATE_ORDER, lst=True) + for k in resolve_date_order(self._date_order, lst=True) } skip_index = [] @@ -604,9 +606,9 @@ def _correct_for_month(self, dateobj): return dateobj @classmethod - def parse(cls, datestring, settings, tz=None): + def parse(cls, datestring, settings, tz=None, date_order=None): tokens = tokenizer(datestring) - po = cls(tokens.tokenize(), settings) + po = cls(tokens.tokenize(), settings, date_order=date_order) dateobj = po._results() # correction for past, future if applicable diff --git a/dateparser/search/search.py b/dateparser/search/search.py index 873598f02..a983155d7 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -3,7 +3,7 @@ import regex as re -from dateparser.conf import Settings, apply_settings, check_settings +from dateparser.conf import apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages from dateparser.date import DateDataParser from dateparser.languages.loader import LocaleDataLoader @@ -125,7 +125,7 @@ def parse_item(self, parser, item, translated_item, parsed, need_relative_base): item, relative_base = self.set_relative_base(item, parsed) if relative_base: - parser._settings.RELATIVE_BASE = relative_base + parser._settings = parser._settings.replace(RELATIVE_BASE=relative_base) parsed_item = parser.get_date_data(item) return parsed_item, is_relative @@ -206,7 +206,6 @@ def search_parse(self, shortname, text, settings): _add_time_span_results(results, text, settings) - parser._settings = Settings() return results diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index ccbe9eac5..9ed0554cd 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -1,5 +1,6 @@ import calendar import logging +import threading import types import unicodedata from collections import OrderedDict @@ -197,19 +198,26 @@ def set_correct_month_from_settings(date_obj, settings, current_month=None): return date_obj.replace(month=options["last"]) +_registry_lock = threading.Lock() + + def registry(cls): def choose(creator): def constructor(cls, *args, **kwargs): key = cls.get_key(*args, **kwargs) - if not hasattr(cls, "__registry_dict"): - setattr(cls, "__registry_dict", {}) - registry_dict = getattr(cls, "__registry_dict") - - if key not in registry_dict: - registry_dict[key] = creator(cls, *args) - setattr(registry_dict[key], "registry_key", key) - return registry_dict[key] + with _registry_lock: + if not hasattr(cls, "__registry_dict"): + setattr(cls, "__registry_dict", {}) + registry_dict = getattr(cls, "__registry_dict") + + if key not in registry_dict: + instance = creator(cls, *args) + # Set the key before publishing the instance so other + # threads never observe an entry without ``registry_key``. + setattr(instance, "registry_key", key) + registry_dict[key] = instance + return registry_dict[key] return staticmethod(constructor) diff --git a/tests/test_thread_safety.py b/tests/test_thread_safety.py new file mode 100644 index 000000000..755e40fe7 --- /dev/null +++ b/tests/test_thread_safety.py @@ -0,0 +1,128 @@ +import sys +import threading +import unittest +from concurrent.futures import ThreadPoolExecutor + +import dateparser.data.date_translation_data.en as en_data +from dateparser.conf import settings as base_settings +from dateparser.date import DateDataParser +from dateparser.languages.dictionary import Dictionary +from dateparser.search import search_dates +from tests import BaseTestCase + + +class TestThreadSafety(BaseTestCase): + """Regression tests for thread-safety issues. + + See https://github.com/scrapinghub/dateparser/issues/441 and + https://github.com/scrapinghub/dateparser/issues/1291. + """ + + def setUp(self): + super().setUp() + # A tiny thread-switch interval makes the interpreter yield between + # almost every bytecode, so the narrow check-then-read windows that + # cause the races below are exercised reliably instead of only once in + # a blue moon. + self._switch_interval = sys.getswitchinterval() + sys.setswitchinterval(1e-7) + + def tearDown(self): + sys.setswitchinterval(self._switch_interval) + super().tearDown() + + def _run_concurrently(self, func, args_list, workers=32): + with ThreadPoolExecutor(max_workers=workers) as executor: + futures = [executor.submit(func, arg) for arg in args_list] + return [future.result() for future in futures] + + def test_dictionary_cache_eviction_concurrently(self): + # Issue #1291: concurrent population/eviction of the size-limited + # dictionary caches raised intermittent ``KeyError`` because the cache + # was read after a concurrent eviction could remove the entry. + dictionaries = [ + Dictionary( + en_data.info, + base_settings.replace(CACHE_SIZE_LIMIT=1, SKIP_TOKENS=["tok%d" % i]), + ) + for i in range(24) + ] + + def hammer(index): + dictionary = dictionaries[index % len(dictionaries)] + for _ in range(50): + dictionary.split("2 days ago") + dictionary.are_tokens_valid(["2", "days", "ago"]) + return True + + results = self._run_concurrently(hammer, range(24)) + self.assertTrue(all(results)) + + def test_settings_date_order_not_mutated_while_parsing(self): + # The absolute-time parser used to assign the locale-specific date order + # onto the shared Settings object in place (restoring it afterwards), so + # a concurrent parse could observe and use a foreign DATE_ORDER. Here the + # German locale order (DMY) differs from the configured default (MDY); a + # watcher thread asserts the shared setting never changes mid-parse. + parser = DateDataParser( + languages=["de"], settings={"PREFER_LOCALE_DATE_ORDER": True} + ) + baseline = parser._settings.DATE_ORDER + self.assertEqual(baseline, "MDY") + + observed = set() + stop = threading.Event() + + def watch(): + while not stop.is_set(): + observed.add(parser._settings.DATE_ORDER) + + def parse(i): + return parser.get_date_data( + ["02.03.2014", "2014-03-02", "11.12.2013"][i % 3] + ) + + watcher = threading.Thread(target=watch) + watcher.start() + try: + self._run_concurrently(parse, range(100), workers=16) + finally: + stop.set() + watcher.join() + + self.assertEqual(observed, {baseline}) + + def test_search_does_not_mutate_shared_relative_base(self): + # search_dates used to assign RELATIVE_BASE onto the shared default + # Settings while resolving relative dates, polluting it for concurrent + # parses/searches. + text = ( + "19 марта 2001. Сегодня был хороший день. " + "2 дня назад был хороший день. Вчера тоже был хороший день." + ) + baseline = base_settings.RELATIVE_BASE + + observed = set() + stop = threading.Event() + + def watch(): + while not stop.is_set(): + observed.add(base_settings.RELATIVE_BASE) + + def search(i): + return search_dates(text, languages=["ru"]) + + watcher = threading.Thread(target=watch) + watcher.start() + try: + results = self._run_concurrently(search, range(40), workers=8) + finally: + stop.set() + watcher.join() + + self.assertTrue(all(result is not None for result in results)) + self.assertEqual(observed, {baseline}) + + +if __name__ == "__main__": + unittest.main() From 6b5f17d35a7bc4d5aa62ca4c90eea19d7e343490 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Fri, 28 Aug 2026 13:16:02 +0200 Subject: [PATCH 051/107] Reject a %j day of year that the parsed year does not have (#271) (#1370) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Improve Czech (cs) language data (#1172) - Add month locative/dative forms (lednu, únoru, březnu, dubnu, květnu, červnu, červenci, srpnu, říjnu, prosinci) for dates like "v lednu 2023" - Add July abbreviation "črv" - Fix "za měsíc/týden/rok" not parsing: add accusative simplification patterns (previous patterns only matched instrumental -em forms) - Add tests covering the new expressions Co-Authored-By: Claude Sonnet 4.6 (1M context) * Reject a %j day of year that the parsed year does not have datetime.strptime resolves a day of year past the end of the parsed year into the next year, so day 366 of a non-leap year became January 1 of the following year: >>> dateparser.parse("1999366", date_formats=["%Y%j"]) datetime.datetime(2000, 1, 1, 0, 0) The returned year contradicted the year in the input, and invalid values were rejected inconsistently: day 367 gave None while day 366 gave a date. The std lib keeps the value it read for %j in struct_time.tm_yday even after rolling the date into the next year, so the rollover can be spotted by comparing it with the day of year of the resulting date. When the two differ, strptime() now raises ValueError, which parse_with_formats() already handles as "this format does not match". _prepare_format() now also reports whether the format holds a real %j directive, so that an escaped "%%j" literal is not mistaken for one. Fixes #271. Co-authored-by: Claude Opus 5 (1M context) --------- Co-authored-by: Claude Sonnet 4.6 (1M context) --- dateparser/utils/strptime.py | 28 +++++++++++--- tests/test_date.py | 72 ++++++++++++++++++++++++++++++++++++ tests/test_date_parser.py | 22 +++++++++++ tests/test_utils_strptime.py | 54 +++++++++++++++++++++++++++ 4 files changed, 171 insertions(+), 5 deletions(-) diff --git a/dateparser/utils/strptime.py b/dateparser/utils/strptime.py index b22356753..6bcdf176e 100644 --- a/dateparser/utils/strptime.py +++ b/dateparser/utils/strptime.py @@ -90,13 +90,14 @@ def patch_strptime(): __strptime = patch_strptime() -def _prepare_format(date_string: str, og_format: str) -> tuple[str, str]: +def _prepare_format(date_string: str, og_format: str) -> tuple[str, str, bool]: # Adapted from std lib: https://github.com/python/cpython/blob/e34a5e33049ce845de646cf24a498766a2da3586/Lib/_strptime.py#L448 format = re.sub(r"([\\.^$*+?\(\){}\[\]|])", r"\\\1", og_format) format = re.sub(r"\s+", r"\\s+", format) format = re.sub(r"'", "['\u02bc]", format) year_in_format = False day_of_month_in_format = False + day_of_year_in_format = False def repl(m: re.Match[str]) -> str: format_char = m[1] @@ -106,19 +107,36 @@ def repl(m: re.Match[str]) -> str: elif format_char in ("d",): nonlocal day_of_month_in_format day_of_month_in_format = True + elif format_char in ("j",): + nonlocal day_of_year_in_format + day_of_year_in_format = True return "" _ = re.sub(r"%[-_0^#]*[0-9]*([OE]?\\?.?)", repl, format) if day_of_month_in_format and not year_in_format: current_year = datetime.today().year - return f"{current_year} {date_string}", f"%Y {og_format}" - return date_string, og_format + return ( + f"{current_year} {date_string}", + f"%Y {og_format}", + day_of_year_in_format, + ) + return date_string, og_format, day_of_year_in_format def strptime(date_string: str, format: str) -> datetime: - date_string, format = _prepare_format(date_string, format) - obj = datetime(*__strptime(date_string, format)[:-3]) + date_string, format, day_of_year_in_format = _prepare_format(date_string, format) + time_tuple = __strptime(date_string, format) + obj = datetime(*time_tuple[:-3]) + + if day_of_year_in_format and time_tuple.tm_yday != obj.timetuple().tm_yday: + # A day of year past the end of the parsed year is rolled over into the + # next year by the std lib (e.g. day 366 of 1999 becomes 2000-01-01), + # which keeps the original value in tm_yday. Such a day does not belong + # to the parsed year, so reject it instead of returning another year. + raise ValueError( + f"day of year {time_tuple.tm_yday} is out of range for year {obj.year - 1}" + ) if "%f" in format: try: diff --git a/tests/test_date.py b/tests/test_date.py index 688b6b665..be2ce7db7 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -402,6 +402,78 @@ def test_should_parse_day_of_year_format( self.then_parsed_period_is("day") self.then_parsed_date_is(expected_result) + @parameterized.expand( + [ + param( + date_string="1999001", + date_formats=["%Y%j"], + expected_result=datetime(1999, 1, 1), + ), + param( + date_string="1999050", + date_formats=["%Y%j"], + expected_result=datetime(1999, 2, 19), + ), + param( + date_string="1999032", + date_formats=["%Y%j"], + expected_result=datetime(1999, 2, 1), + ), + param( + date_string="1999059", + date_formats=["%Y%j"], + expected_result=datetime(1999, 2, 28), + ), + param( + date_string="1999060", + date_formats=["%Y%j"], + expected_result=datetime(1999, 3, 1), + ), + param( + date_string="1999365", + date_formats=["%Y%j"], + expected_result=datetime(1999, 12, 31), + ), + param( + date_string="2000060", + date_formats=["%Y%j"], + expected_result=datetime(2000, 2, 29), + ), + param( + date_string="2000366", + date_formats=["%Y%j"], + expected_result=datetime(2000, 12, 31), + ), + ] + ) + def test_should_parse_day_of_year_boundaries( + self, date_string, date_formats, expected_result + ): + """Format %%j (day of year) should handle month and leap year edges.""" + self.when_date_is_parsed_with_formats(date_string, date_formats) + self.then_date_was_parsed() + self.then_parsed_period_is("day") + self.then_parsed_date_is(expected_result) + + @parameterized.expand( + [ + # 366 is only a valid day of year in leap years, and must not be + # rolled over into the next year. + param(date_string="1999366", date_formats=["%Y%j"]), + param(date_string="2023-366", date_formats=["%Y-%j"]), + param(date_string="1900366", date_formats=["%Y%j"]), + param(date_string="2100 366", date_formats=["%Y %j"]), + # Values that are out of the %j range altogether. + param(date_string="1999000", date_formats=["%Y%j"]), + param(date_string="1999367", date_formats=["%Y%j"]), + param(date_string="1999777", date_formats=["%Y%j"]), + ] + ) + def test_should_not_parse_out_of_range_day_of_year(self, date_string, date_formats): + """Format %%j (day of year) should reject days the year does not have.""" + self.when_date_is_parsed_with_formats(date_string, date_formats) + self.then_date_was_not_parsed() + @parameterized.expand( [ param( diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index b879017c0..4683b7b6c 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1921,6 +1921,28 @@ def test_prefer_dates_from_with_date_formats_feb29_non_leap(self): self.assertEqual(2, result.month) self.assertEqual(29, result.day) + @parameterized.expand( + [ + param(date_string="1999001", expected=datetime(1999, 1, 1)), + param(date_string="1999050", expected=datetime(1999, 2, 19)), + param(date_string="1999365", expected=datetime(1999, 12, 31)), + param(date_string="2000366", expected=datetime(2000, 12, 31)), + ] + ) + def test_day_of_year_is_parsed(self, date_string, expected): + """Test that %j maps the day of year onto the right date (Issue #271).""" + self.assertEqual(expected, parse(date_string, date_formats=["%Y%j"])) + + @parameterized.expand( + [ + param(date_string="1999366"), # 1999 is not a leap year + param(date_string="1999777"), + ] + ) + def test_out_of_range_day_of_year_is_not_parsed(self, date_string): + """Test that an invalid %j value is not read as another date (Issue #271).""" + self.assertIsNone(parse(date_string, date_formats=["%Y%j"])) + if __name__ == "__main__": unittest.main() diff --git a/tests/test_utils_strptime.py b/tests/test_utils_strptime.py index 529158af7..a76230bc4 100644 --- a/tests/test_utils_strptime.py +++ b/tests/test_utils_strptime.py @@ -238,3 +238,57 @@ def test_dates_with_no_year_use_the_current_year( current_year = datetime.today().year expected = expected.replace(year=current_year) self.assertEqual(self.result, expected) + + @parameterized.expand( + [ + param("1999001", "%Y%j", expected=datetime(1999, 1, 1)), + param("1999032", "%Y%j", expected=datetime(1999, 2, 1)), + param("1999050", "%Y%j", expected=datetime(1999, 2, 19)), + param("1999059", "%Y%j", expected=datetime(1999, 2, 28)), + param("1999060", "%Y%j", expected=datetime(1999, 3, 1)), + param("1999365", "%Y%j", expected=datetime(1999, 12, 31)), + param("2000060", "%Y%j", expected=datetime(2000, 2, 29)), + param("2000061", "%Y%j", expected=datetime(2000, 3, 1)), + param("2000366", "%Y%j", expected=datetime(2000, 12, 31)), + param("2400366", "%Y%j", expected=datetime(2400, 12, 31)), + param("2023-100", "%Y-%j", expected=datetime(2023, 4, 10)), + param("2024 366", "%Y %j", expected=datetime(2024, 12, 31)), + param("1999001 12:30", "%Y%j %H:%M", expected=datetime(1999, 1, 1, 12, 30)), + ] + ) + def test_day_of_year_is_parsed(self, date_string, fmt, expected): + self.when_date_string_is_parsed(date_string, fmt) + self.then_date_object_is(expected) + + @parameterized.expand( + [ + # 366 is only a valid day of year in leap years. + param("1999366", "%Y%j"), + param("2023-366", "%Y-%j"), + param("1900366", "%Y%j"), # divisible by 100 but not by 400 + param("2100366", "%Y%j"), + param("2025366 12:30", "%Y%j %H:%M"), + # Values that strptime itself rejects. + param("1999000", "%Y%j"), + param("1999367", "%Y%j"), + param("1999777", "%Y%j"), + ] + ) + def test_day_of_year_out_of_range_is_not_parsed(self, date_string, fmt): + self.when_date_string_is_parsed(date_string, fmt) + self.then_date_object_is_instance_of(ValueError) + + @parameterized.expand( + [ + param("%j", "%%j", expected=datetime(1900, 1, 1)), + param("1999%j", "%Y%%j", expected=datetime(1999, 1, 1)), + # A literal "%j" must not be taken for a day of year directive, not + # even when another directive rolls the year over. + param("2023 53 1 %j", "%Y %U %w %%j", expected=datetime(2024, 1, 1)), + ] + ) + def test_escaped_day_of_year_directive_is_a_literal( + self, date_string, fmt, expected + ): + self.when_date_string_is_parsed(date_string, fmt) + self.then_date_object_is(expected) From 27182cd1b89111fb8978b3a10acc6f474f0cd320 Mon Sep 17 00:00:00 2001 From: Yi Zhan Date: Thu, 3 Sep 2026 14:59:27 +0800 Subject: [PATCH 052/107] Avoid shared language_detector and locale cache in search_dates (#1371) Fixes #1369. search_dates uses a process-wide DateSearchWithDetection singleton. detect_language stashed a single-use FullTextLanguageDetector on self, and _ExactLanguageSearch kept a 1-slot locale cache. Concurrent calls that disagree about the language could return None or a date from the wrong locale. Use a local detector and return the locale from get_current_language so neither value is instance state. LocaleDataLoader.get_locale already caches. Thanks @serhii73 for the report. --- dateparser/search/search.py | 14 +++--- tests/test_thread_safety.py | 97 ++++++++++++++++++++++++++++++++++++- 2 files changed, 101 insertions(+), 10 deletions(-) diff --git a/dateparser/search/search.py b/dateparser/search/search.py index a983155d7..80ee08463 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -34,15 +34,13 @@ def _add_time_span_results(results, text, settings): class _ExactLanguageSearch: def __init__(self, loader): self.loader = loader - self.language = None def get_current_language(self, shortname): - if self.language is None or self.language.shortname != shortname: - self.language = self.loader.get_locale(shortname) + return self.loader.get_locale(shortname) def search(self, shortname, text, settings): - self.get_current_language(shortname) - result = self.language.translate_search(text, settings=settings) + language = self.get_current_language(shortname) + result = language.translate_search(text, settings=settings) return result @staticmethod @@ -270,13 +268,13 @@ def detect_language( ) if languages: - self.language_detector = FullTextLanguageDetector(languages=languages) + language_detector = FullTextLanguageDetector(languages=languages) else: - self.language_detector = FullTextLanguageDetector( + language_detector = FullTextLanguageDetector( list(self.available_language_map.values()) ) - detected_language = self.language_detector._best_language(text) or ( + detected_language = language_detector._best_language(text) or ( settings.DEFAULT_LANGUAGES[0] if settings.DEFAULT_LANGUAGES else None ) return detected_language diff --git a/tests/test_thread_safety.py b/tests/test_thread_safety.py index 755e40fe7..5d010ccfb 100644 --- a/tests/test_thread_safety.py +++ b/tests/test_thread_safety.py @@ -8,14 +8,16 @@ from dateparser.date import DateDataParser from dateparser.languages.dictionary import Dictionary from dateparser.search import search_dates +from dateparser.search.search import DateSearchWithDetection, _ExactLanguageSearch from tests import BaseTestCase class TestThreadSafety(BaseTestCase): """Regression tests for thread-safety issues. - See https://github.com/scrapinghub/dateparser/issues/441 and - https://github.com/scrapinghub/dateparser/issues/1291. + See https://github.com/scrapinghub/dateparser/issues/441, + https://github.com/scrapinghub/dateparser/issues/1291 and + https://github.com/scrapinghub/dateparser/issues/1369. """ def setUp(self): @@ -123,6 +125,97 @@ def search(i): self.assertTrue(all(result is not None for result in results)) self.assertEqual(observed, {baseline}) + def test_detect_language_does_not_leave_narrowed_detector_on_instance(self): + # Issue #1369 site 1: detect_language used to stash a FullTextLanguageDetector + # on the process-wide singleton. _best_language narrows detector.languages + # in place, so a concurrent search_dates can load another call's already- + # narrowed detector and return None or a wrong date. + ds = DateSearchWithDetection() + detected = ds.detect_language("19 марта 2001", languages=["ru", "en"]) + self.assertEqual(detected, "ru") + detector = getattr(ds, "language_detector", None) + if detector is not None: + leftover = [locale.shortname for locale in detector.languages] + self.assertEqual( + set(leftover), + {"ru", "en"}, + "detect_language left a single-use detector narrowed in place " + "on the instance; concurrent search_dates can observe this " + "(issue #1369). leftover=%r" % leftover, + ) + + def test_concurrent_search_dates_does_not_share_language_detector(self): + # Issue #1369 site 1: the store/load gap is a few bytecodes, so park each + # thread immediately after it stores the detector. Sequential search_dates + # is not a valid RED for this race. + ru_text = "Договор подписан 19 марта 2001 года в Москве" + en_text = "The satellite was launched on 4 October 1957 from Baikonur" + sequential_ru = search_dates(ru_text, languages=["ru"]) + sequential_en = search_dates(en_text, languages=["en"]) + self.assertIsNotNone(sequential_ru) + self.assertIsNotNone(sequential_en) + + slot = {} + barrier = threading.Barrier(2, timeout=10) + + def _get(self): + return slot["v"] + + def _set(self, value): + slot["v"] = value + try: + barrier.wait() + except threading.BrokenBarrierError: + pass + + DateSearchWithDetection.language_detector = property(_get, _set) + try: + with ThreadPoolExecutor(max_workers=2) as executor: + ru, en = executor.map( + lambda args: search_dates(args[0], languages=[args[1]]), + [(ru_text, "ru"), (en_text, "en")], + ) + finally: + del DateSearchWithDetection.language_detector + + self.assertEqual(ru, sequential_ru) + self.assertEqual(en, sequential_en) + + def test_concurrent_search_dates_does_not_share_locale_slot(self): + # Issue #1369 site 2: _ExactLanguageSearch.self.language is a 1-slot cache + # on the same singleton. Park after get_current_language so a store from + # the other thread lands before translate_search. + ru_text = "Договор подписан 19 марта 2001 года в Москве" + en_text = "The satellite was launched on 4 October 1957 from Baikonur" + sequential_ru = search_dates(ru_text, languages=["ru"]) + sequential_en = search_dates(en_text, languages=["en"]) + self.assertIsNotNone(sequential_ru) + self.assertIsNotNone(sequential_en) + + original = _ExactLanguageSearch.get_current_language + barrier = threading.Barrier(2, timeout=10) + + def patched(self, shortname): + result = original(self, shortname) + try: + barrier.wait() + except threading.BrokenBarrierError: + pass + return result + + _ExactLanguageSearch.get_current_language = patched + try: + with ThreadPoolExecutor(max_workers=2) as executor: + ru, en = executor.map( + lambda args: search_dates(args[0], languages=[args[1]]), + [(ru_text, "ru"), (en_text, "en")], + ) + finally: + _ExactLanguageSearch.get_current_language = original + + self.assertEqual(ru, sequential_ru) + self.assertEqual(en, sequential_en) + if __name__ == "__main__": unittest.main() From 9ce60b1958f1b285886bcfbb743f6419feacfc92 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Thu, 3 Sep 2026 12:02:49 +0200 Subject: [PATCH 053/107] 1.4.3 release (#1376) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 1.4.3 release notes Co-Authored-By: Claude Opus 5 (1M context) * Bump version: 1.4.2 → 1.4.3 --------- Co-authored-by: Claude Opus 5 (1M context) --- HISTORY.rst | 36 ++++++++++++++++++++++++++++++++++++ dateparser/__init__.py | 2 +- pyproject.toml | 2 +- 3 files changed, 38 insertions(+), 2 deletions(-) diff --git a/HISTORY.rst b/HISTORY.rst index de6c8b6d9..34de7131a 100644 --- a/HISTORY.rst +++ b/HISTORY.rst @@ -3,6 +3,42 @@ History ======= +1.4.3 (2026-09-03) +------------------ + +Fixes: + +- Make parsing thread-safe: parsing from several threads no longer + raises an intermittent ``KeyError`` from the shared language caches, + and a ``DATE_ORDER`` or ``RELATIVE_BASE`` value meant for one parse no + longer leaks into the settings that other parses read, where it could + make them return a wrong date (#1346) +- Do not share the language detector and the detected locale between + ``search_dates()`` calls, so concurrent searches over text in + different languages no longer return ``None`` or a date read in the + wrong locale (#1371) +- Resolve the ``BST`` and ``HDT`` timezone abbreviations to the offsets + the tz database gives them, UTC+1 (British Summer Time) and UTC-9 + (Hawaii-Aleutian Daylight Time), instead of +11 and -9:30, which no + zone goes by those names today; abbreviations that the tz database + maps to more than one offset, such as ``CST`` and ``IST``, keep their + current offset. Text carrying these abbreviations keeps its wall clock + but moves by 10 hours for ``BST`` and 30 minutes for ``HDT``, which can + put the parsed instant on a different day (#1366) +- Reject a ``%j`` (day of year) value that the parsed year does not + have, instead of rolling it over into the next year, so "1999366" with + ``date_formats=["%Y%j"]`` returns ``None`` rather than 2000-01-01. A + format with no year directive is checked against the year ``strptime`` + defaults to, 1900, which is not a leap year, so "366" with + ``date_formats=["%j"]`` now returns ``None`` where it used to return + January 1 (#1370) + +Cleanups and internal improvements: + +- Add CodSpeed benchmarks and a workflow that runs them, so a + performance regression such as the quadratic backtracking fixed in + 1.4.1 is reported on the pull request that introduces it (#1365) + 1.4.2 (2026-08-04) ------------------ diff --git a/dateparser/__init__.py b/dateparser/__init__.py index b43021910..565965882 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,4 +1,4 @@ -__version__ = "1.4.2" +__version__ = "1.4.3" from .conf import apply_settings from .date import DateDataParser diff --git a/pyproject.toml b/pyproject.toml index 71e6a8d61..55418df00 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ requires = [ [project] name = "dateparser" -version = "1.4.2" +version = "1.4.3" description = "Date parsing library designed to parse dates from HTML pages" authors = [ { name = "Scrapinghub", email = "opensource@zyte.com" }, From d10d0f7be446861e88f5056b3d918207fa86f1a9 Mon Sep 17 00:00:00 2001 From: Laurie O Date: Mon, 7 Sep 2026 21:44:28 +1000 Subject: [PATCH 054/107] Fix raw-HTML pattern in README parsing (#1359) --- README.rst | 38 +++++++++++++++++++------------------- setup.py | 3 ++- 2 files changed, 21 insertions(+), 20 deletions(-) diff --git a/README.rst b/README.rst index a0b69ecc8..2b0ac941b 100644 --- a/README.rst +++ b/README.rst @@ -53,7 +53,7 @@ Key Features ------------- +============ - Support for almost every existing date format: absolute dates, relative dates (``"two weeks ago"`` or ``"tomorrow"``), timestamps, @@ -72,7 +72,7 @@ Key Features - Time span detection for expressions like "past month", "last week". Online demo ------------ +=========== Do you want to try it out without installing any dependency? Now you can test it quickly by visiting `this online demo `__! @@ -80,7 +80,7 @@ it quickly by visiting `this online demo `__. Timezone and UTC Offset -^^^^^^^^^^^^^^^^^^^^^^^ +----------------------- By default, `dateparser` returns a timezone-aware ``datetime`` if a timezone is present in the date string. Otherwise it returns a naive ``datetime`` object. @@ -224,7 +224,7 @@ using the ``TIMEZONE`` setting: For more on timezones, see the `settings documentation `__. Incomplete Dates -^^^^^^^^^^^^^^^^ +---------------- .. code:: python @@ -259,7 +259,7 @@ You can also ignore incomplete dates by setting the ``STRICT_PARSING`` flag: For more on handling incomplete dates, see the `settings documentation `__. Search for Dates in Longer Chunks of Text -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +----------------------------------------- .. warning:: Support for date searching is limited and needs improvement. Contributions are welcome — see `contributing `__. @@ -274,7 +274,7 @@ list of ``(substring, datetime)`` tuples: [('25 of October 2017', datetime.datetime(2017, 10, 25, 0, 0)), ('the 27th is in 2 days', datetime.datetime(2017, 10, 27, 0, 0))] Time Span Detection -^^^^^^^^^^^^^^^^^^^ +------------------- The ``search_dates`` function can also detect time spans such as "past month" or "last week". When ``RETURN_TIME_SPAN`` is enabled it @@ -287,7 +287,7 @@ returns start and end dates for the detected period: ('past month (end)', datetime.datetime(2024, 12, 7, 23, 59, 59, 999999))] Settings -^^^^^^^^ +-------- You can control multiple behaviors by using the ``settings`` parameter: @@ -309,7 +309,7 @@ To see all available settings, check the `settings documentation `__. False positives -^^^^^^^^^^^^^^^ +--------------- **dateparser** will do its best to return a date, dealing with multiple formats and different locales. For that reason it is important that the input is a valid date, otherwise it could return false positives. @@ -326,7 +326,7 @@ are executed, you can do so through the `settings PARSERS `_. Installation ------------- +============ Dateparser supports Python 3.10+. You can install it by doing: @@ -342,7 +342,7 @@ If you want to use the jalali or hijri calendar, you need to install the $ pip install dateparser[calendars] Supported Calendars -------------------- +=================== Apart from the Gregorian calendar, `dateparser` supports the `Persian Jalali calendar` and the `Hijri/Islamic calendar`. @@ -367,7 +367,7 @@ Example using the `Hijri/Islamic calendar DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None) Dependencies ------------- +============ `dateparser` relies on the following libraries: @@ -384,13 +384,13 @@ Dependencies .. _ruamel.yaml: https://pypi.python.org/pypi/ruamel.yaml Common use cases ----------------- +================ **dateparser** can be used for a wide variety of purposes, but it stands out when it comes to: Consuming data from different sources: -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +-------------------------------------- - **Scraping**: extract dates from different places with several different formats and languages @@ -401,7 +401,7 @@ Consuming data from different sources: different files (PDF, CSV, etc.) to other formats (database, etc). Offering natural interaction with users: -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +---------------------------------------- - **Tooling and CLI**: allow users to write “3 days ago” to retrieve information. @@ -410,7 +410,7 @@ Offering natural interaction with users: - **Bots**: allow users to interact with a bot easily You may also like... --------------------- +==================== - `price-parser `__ - A small library for extracting price and currency from raw text @@ -422,6 +422,6 @@ You may also like... scraping framework License -------- +======= `BSD3-Clause `__ diff --git a/setup.py b/setup.py index eb2dfebe2..13c90073b 100644 --- a/setup.py +++ b/setup.py @@ -4,11 +4,12 @@ readme = open("README.rst", encoding="utf-8").read() # Remove `.. raw:: html` blocks, which are not supported by PyPI. -readme = re.sub(r"(?ms)^\.\. raw:: html\n(?:^[ \t].*\n|^[ \t]*\n)*", "", readme) +readme = re.sub(r"(?m)^\.\. raw:: html\n(?:^[ \t].*\n|^[ \t]*\n)*?\n\n", "", readme) history = re.sub( r":mod:|:class:|:func:", "", open("HISTORY.rst", encoding="utf-8").read() ) setup( long_description=readme + "\n\n" + history, + long_description_content_type="text/x-rst", ) From f766ceee28ba3f63055a0c31435cbe623c7d73dd Mon Sep 17 00:00:00 2001 From: Jack Walker Date: Tue, 8 Sep 2026 10:52:04 +0000 Subject: [PATCH 055/107] Repair documented contributor test, packaging, and regeneration commands (#1379) --- .isort.cfg | 2 -- CONTRIBUTING.rst | 23 ++++++++++++++++------- conftest.py | 9 --------- pytest.ini | 4 +--- tox.ini | 2 +- 5 files changed, 18 insertions(+), 22 deletions(-) delete mode 100644 .isort.cfg delete mode 100644 conftest.py diff --git a/.isort.cfg b/.isort.cfg deleted file mode 100644 index f238bf7ea..000000000 --- a/.isort.cfg +++ /dev/null @@ -1,2 +0,0 @@ -[settings] -profile = black diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index ff08dc1f6..0aedb2dbc 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -76,7 +76,7 @@ installed, this is how you set up your fork for local development:: $ mkvirtualenv dateparser $ cd dateparser/ - $ pip install -e . + $ pip install -e . pytest parameterized tox 4. Create a branch for local development:: @@ -84,12 +84,20 @@ installed, this is how you set up your fork for local development:: Now you can make your changes locally. -5. When you're done making changes, check that your changes pass flake8 and the -tests, including testing other Python versions with tox:: +5. Run the tests and the ruff linting and formatting hooks:: - $ tox + $ pytest + $ tox -e pre-commit - To get ``tox``, just ``pip install`` it into your virtualenv. In addition to tests, ``tox`` checks for code style and maximum line length (119 characters). + Bare ``pytest`` runs the ``tests/`` directory. Optional calendar and language + detection tests require ``pip install -e '.[calendars,langdetect]'``. + The ruff formatter uses its default line length of 88; the linter does not + enforce a maximum line length. + + Use ``tox`` to run the full environment list, including the supported Python + versions, documentation, scripts, packaging checks, and benchmarks. These + environments require their configured Python interpreters to be installed. + To run just the packaging check, use ``tox -e twinecheck``. 6. Commit your changes and push your branch to GitHub:: @@ -153,9 +161,10 @@ language, you must: :ref:`language-data-template` for details. #. Regenerate the corresponding file within - ``dateparser/data/date_translation_data`` running the following script:: + ``dateparser/data/date_translation_data`` after installing the script dependencies:: - dateparser_scripts/write_complete_data.py + pip install -r dateparser_scripts/requirements.txt + python -m dateparser_scripts.write_complete_data #. Write tests that cover your changes diff --git a/conftest.py b/conftest.py deleted file mode 100644 index 21040d96d..000000000 --- a/conftest.py +++ /dev/null @@ -1,9 +0,0 @@ -def pytest_collection_modifyitems(session, config, items): - # Avoid executing tests when executing `--flake8` flag (pytest-flake8) - try: - from pytest_flake8 import Flake8Item - - if config.getoption("--flake8"): - items[:] = [item for item in items if isinstance(item, Flake8Item)] - except ImportError: - pass diff --git a/pytest.ini b/pytest.ini index 1a75689bf..5ee647716 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,4 +1,2 @@ [pytest] -addopts = - --doctest-modules - --assert=plain +testpaths = tests diff --git a/tox.ini b/tox.ini index 6600c6eaf..44027a5c6 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,5 @@ [tox] -envlist = pre-commit,min,min-all,py310,py311,py312,py313,py314,all,scripts,docs,twinedeck,benchmark +envlist = pre-commit,min,min-all,py310,py311,py312,py313,py314,all,scripts,docs,twinecheck,benchmark [base] deps = From 6114c906f62c4018cb92c7f6ad5da70315ae1288 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 9 Sep 2026 11:50:45 +0200 Subject: [PATCH 056/107] Run the test matrix nightly and turn warnings into errors (#1382) * Run the test matrix nightly and turn warnings into errors CI only ran on push and pull request, so breakage that arrives without a commit -- a dependency release, a tz database update, the calendar rolling over -- stayed invisible until someone happened to push. Master saw CI on 41 distinct days in the last 13 months, twice going more than two months without a run, which is how #1286 reached a downstream packager first. A new Nightly workflow calls the existing Build matrix daily at 04:17 UTC and files one tracking issue per outage, since GitHub's own notification goes to a single person. The schedule lives in its own workflow because GitHub disables a workflow that has a schedule after 60 days without repository activity, and a disabled workflow answers none of its triggers: keeping the cron out of main.yml means an inactivity disable can never take pull request runs down with it. pytest.ini turns warnings into errors. The suite emits none today on 3.10 through 3.14, with and without the calendars and langdetect extras, against both current dependencies and the min pins, so the exemption list starts empty. The exception is the tzlocal 0.2 pin in the min environments, whose invalid string escapes become an import-time SyntaxError under an error filter whenever the installer does not byte-compile, so tox ignores that one message for those two environments. The matrix gains a plain 3.10 leg: 3.10 is a supported interpreter that was only ever tested against the oldest permitted dependency versions, since the Python bump in #1296 consumed the bare 3.10 row. CIFuzz uploads SARIF with github/codeql-action/upload-sarif@v4. v2 has been emitting a failure-level annotation on every run, and v3 emits one of its own, so v4 is what actually clears it. Fixes #1374 Co-Authored-By: Claude Opus 5 (1M context) * Address review findings on the nightly and warnings setup Scope the Nightly token to contents: read at the workflow level, which the called matrix inherits; the report job asks for issues: write itself (CodeQL actions/missing-workflow-permissions). Exempt three environmental warnings from the error filter: tzlocal's two UserWarnings on a host with no or stale time zone configuration, which CI never sees because it always sets TZ but which fail most of the suite for a contributor in a bare container or in nixpkgs' sandbox, and pytest's PytestCacheWarning in a read-only checkout, which turned a green run into exit 1. Drop the DeprecationWarning category from the tzlocal 0.2 escape filter, since CPython 3.12+ emits it as a SyntaxWarning, and carry it through PYTEST_ADDOPTS instead of a copied command line so min and min-all keep following [testenv] commands. Ignore pytest-codspeed's measurement-hook RuntimeWarnings in the benchmark env, so a runner glitch cannot turn CodSpeed red. Upload coverage only on push and pull_request, so a dispatched Nightly does not re-upload master's report. Gate the report job on master and on failure or cancelled, key the tracking issue on a dedicated nightly-failure label so retitling it does not defeat the dedupe, and let a transient listing failure fall through to filing rather than aborting. Lint W605 with ruff: pip's byte-compilation absorbs an invalid-escape warning before pytest can see it, so the linter is the only leg that can. Co-Authored-By: Claude Fable 5.1 --------- Co-authored-by: Claude Opus 5 (1M context) --- .github/workflows/cifuzz.yml | 2 +- .github/workflows/main.yml | 11 +++++ .github/workflows/nightly.yml | 79 +++++++++++++++++++++++++++++++++++ CONTRIBUTING.rst | 4 ++ pyproject.toml | 5 +++ pytest.ini | 14 +++++++ tox.ini | 14 ++++++- 7 files changed, 127 insertions(+), 2 deletions(-) create mode 100644 .github/workflows/nightly.yml diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml index 111913019..c32c5c9b7 100644 --- a/.github/workflows/cifuzz.yml +++ b/.github/workflows/cifuzz.yml @@ -28,7 +28,7 @@ jobs: path: ./out/artifacts - name: Upload Sarif if: always() && steps.build.outcome == 'success' - uses: github/codeql-action/upload-sarif@v2 + uses: github/codeql-action/upload-sarif@v4 with: # Path to SARIF file relative to the root of the repository sarif_file: cifuzz-sarif/results.sarif diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index cb397b116..0b7ef6939 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -6,6 +6,12 @@ on: pull_request: branches: - master + # Called by the Nightly workflow, which re-runs these same legs daily. The + # schedule lives there and not here because GitHub disables a workflow that + # has a schedule after 60 days without repository activity, and a disabled + # workflow answers none of its triggers, which would take pull request runs + # down with it. + workflow_call: jobs: build: name: Build @@ -20,6 +26,7 @@ jobs: toxenv: min - python-version: "3.10" toxenv: min-all + - python-version: "3.10" - python-version: "3.11" - python-version: "3.12" - python-version: "3.14" @@ -53,6 +60,10 @@ jobs: TZ=${{ matrix.timezone || 'UTC' }} echo "Running tests with timezone: $TZ" TZ=${{ matrix.timezone || 'UTC' }} tox -e ${{ matrix.toxenv || 'py' }} - name: Upload coverage.xml to codecov + # A nightly run, scheduled or dispatched, re-tests a commit that already + # has a coverage report, so uploading again only repeats the Codecov + # notification for that SHA. + if: github.event_name == 'push' || github.event_name == 'pull_request' uses: codecov/codecov-action@v5 with: token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml new file mode 100644 index 000000000..2ba448bed --- /dev/null +++ b/.github/workflows/nightly.yml @@ -0,0 +1,79 @@ +name: Nightly +on: + # Dependency, time zone database and calendar drift arrives with no commit + # behind it, and tests that only fail on the 31st of a month need a run on + # every date; a fixed weekday lands on a 31st about once a year. Off the hour, + # which GitHub names as a high-load window, and early in the UTC day so that + # the Pacific/Auckland and Pacific/Fiji legs stay on the same calendar date as + # the rest of the matrix. + schedule: + - cron: "17 4 * * *" + # Runs the same legs on demand, which is also the only way to exercise the + # reporting below before it is needed. GitHub disables this workflow after 60 + # days without repository activity; re-enable it from the Actions tab or with + # `gh workflow enable nightly.yml`, since a disabled workflow answers no + # triggers at all. + workflow_dispatch: + +# The called matrix only checks out and tests; the report job below asks for +# the one extra scope it needs. +permissions: + contents: read + +jobs: + build: + uses: ./.github/workflows/main.yml + secrets: inherit + + report: + name: Report failure + needs: build + # A push or pull request failure is already in front of whoever caused it. + # A failure with no commit behind it has nowhere to land but a single + # notification email to whoever last edited the schedule. A cancelled build + # counts, since a leg that hangs until GitHub kills it is a failure too. + # Master only, so that a dispatch on a work branch can neither file a + # report nor mask the real one. + if: >- + (needs.build.result == 'failure' || needs.build.result == 'cancelled') + && github.ref == 'refs/heads/master' + runs-on: ubuntu-latest + permissions: + issues: write + steps: + - name: File a tracking issue unless one is already open + env: + GH_TOKEN: ${{ github.token }} + GH_REPO: ${{ github.repository }} + TITLE: The nightly build is failing + LABEL: nightly-failure + RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }} + SHA: ${{ github.sha }} + run: | + set -euo pipefail + # One issue per outage: a daily comment stream would only be one more + # signal to ignore. The label, not the title, identifies the tracking + # issue, so retitling it to record the cause does not defeat the + # check; --force makes creating the label idempotent. A transient + # listing failure must not stop the report, since a duplicate issue + # is cheaper than silence. + gh label create "$LABEL" --force --color d93f0b \ + --description "Filed by the Nightly workflow" + existing="$(gh issue list --state open --label "$LABEL" --limit 1 \ + --json number --jq '.[0].number // empty' || true)" + if [ -n "$existing" ]; then + echo "Already tracked in #$existing." + exit 0 + fi + gh issue create --title "$TITLE" --label "$LABEL" \ + --label "Type: Maintenance" --body-file - < Date: Tue, 15 Sep 2026 10:40:34 +0200 Subject: [PATCH 057/107] Parse Vietnamese dates with zero-padded months (#1297) (#1338) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Vietnamese month names like "tháng 09" did not parse: the locale data only listed the un-padded forms ("tháng 9"), so a zero-padded month fell through to the generic "tháng" -> month token and produced a wrong relative date instead of an absolute one. Add zero-padded aliases ("tháng 0N" / "thg 0N") for months 1-9 in the supplementary language data and regenerate vi.py. Months 10-12 already carry two-digit forms. --- dateparser/data/date_translation_data/vi.py | 36 ++++++++++++++----- .../date_translation_data/vi.yaml | 18 ++++++++++ tests/test_languages.py | 3 ++ 3 files changed, 48 insertions(+), 9 deletions(-) diff --git a/dateparser/data/date_translation_data/vi.py b/dateparser/data/date_translation_data/vi.py index 3b9a5e51d..4753f02d9 100644 --- a/dateparser/data/date_translation_data/vi.py +++ b/dateparser/data/date_translation_data/vi.py @@ -4,47 +4,65 @@ "january": [ "thg 1", "tháng 1", - "Tháng một" + "Tháng một", + "tháng 01", + "thg 01" ], "february": [ "thg 2", "tháng 2", - "Tháng hai" + "Tháng hai", + "tháng 02", + "thg 02" ], "march": [ "thg 3", "tháng 3", - "Tháng ba" + "Tháng ba", + "tháng 03", + "thg 03" ], "april": [ "thg 4", "tháng 4", - "Tháng tư" + "Tháng tư", + "tháng 04", + "thg 04" ], "may": [ "thg 5", "tháng 5", - "Tháng năm" + "Tháng năm", + "tháng 05", + "thg 05" ], "june": [ "thg 6", "tháng 6", - "Tháng sáu" + "Tháng sáu", + "tháng 06", + "thg 06" ], "july": [ "thg 7", "tháng 7", - "Tháng bảy" + "Tháng bảy", + "tháng 07", + "thg 07" ], "august": [ "thg 8", "tháng 8", - "Tháng tám" + "Tháng tám", + "tháng 08", + "thg 08" ], "september": [ "thg 9", "tháng 9", - "Tháng chín" + "Tháng chín", + "tháng 09", + "thg 09" ], "october": [ "thg 10", diff --git a/dateparser_data/supplementary_language_data/date_translation_data/vi.yaml b/dateparser_data/supplementary_language_data/date_translation_data/vi.yaml index ee4552e69..68b768b14 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/vi.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/vi.yaml @@ -19,22 +19,40 @@ sunday: january: - Tháng một + - tháng 01 + - thg 01 february: - Tháng hai + - tháng 02 + - thg 02 march: - Tháng ba + - tháng 03 + - thg 03 april: - Tháng tư + - tháng 04 + - thg 04 may: - Tháng năm + - tháng 05 + - thg 05 june: - Tháng sáu + - tháng 06 + - thg 06 july: - Tháng bảy + - tháng 07 + - thg 07 august: - Tháng tám + - tháng 08 + - thg 08 september: - Tháng chín + - tháng 09 + - thg 09 october: - Tháng mười november: diff --git a/tests/test_languages.py b/tests/test_languages.py index 783af3654..e466abe56 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -160,6 +160,9 @@ def setUp(self): param( "vi", "9 Tháng 1 2015 lúc 15:08", "9 january 2015 15:08" ), # Issue #1302: "lúc" removed, whitespace preserved + param( + "vi", "21 tháng 09 năm 2025", "21 september 2025" + ), # Issue #1297: zero-padded month "09" # Thai param( "th", From 5e77cac26af912ba0a2d8a7e23b0a304a8f0b5f7 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Wed, 16 Sep 2026 10:12:06 +0200 Subject: [PATCH 058/107] Find a date written next to a relative one without a comma (#695) (#1385) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Improve Czech (cs) language data (#1172) - Add month locative/dative forms (lednu, únoru, březnu, dubnu, květnu, červnu, červenci, srpnu, říjnu, prosinci) for dates like "v lednu 2023" - Add July abbreviation "črv" - Fix "za měsíc/týden/rok" not parsing: add accusative simplification patterns (previous patterns only matched instrumental -em forms) - Add tests covering the new expressions Co-Authored-By: Claude Sonnet 4.6 (1M context) * Find a date written next to a relative one without a comma (#695) search_dates('Today 13 Feb 2020') found no dates at all, while 'Today, 13 Feb 2020' found both. A chunk that does not parse as one date is split by looking for a separator that the translation and the text it was translated from hold the same number of times, and "today" is translated into "0 day ago": the translation gains two spaces the text never had, so the whitespace splitter is refused and the whole chunk is dropped. The comma form works because the comma survives the translation one for one. Cut such a chunk where the relative expression ends instead. The cut is taken only when the expression sits at one end of the chunk, when the rest of the translation keeps one word per remaining original word, when the word at that end really is the one the expression was translated from -- which the locale is asked to confirm by translating it on its own -- and when what is left of the chunk is a date. A chunk that fails any of these is left alone rather than cut at a guess, which is why 'Today 13 Feb 2020 and 14 Mar 2021', whose "and" the translation drops, still finds nothing. The cut is only looked for when no separator lined up, so a chunk that splits today keeps splitting exactly the way it does now. Fixes #695 Co-Authored-By: Claude Opus 5 (1M context) --------- Co-authored-by: Claude Sonnet 4.6 (1M context) --- dateparser/search/search.py | 69 ++++++++++++++++++++++++++++++-- tests/test_search.py | 79 +++++++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+), 3 deletions(-) diff --git a/dateparser/search/search.py b/dateparser/search/search.py index 80ee08463..c818f2522 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -6,6 +6,7 @@ from dateparser.conf import apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages from dateparser.date import DateDataParser +from dateparser.freshness_date_parser import _UNITS from dateparser.languages.loader import LocaleDataLoader from dateparser.search.ngram_search import _NgramDateSearch from dateparser.search.text_detection import FullTextLanguageDetector @@ -13,6 +14,13 @@ RELATIVE_REG = re.compile("(ago|in|from now|tomorrow|today|yesterday)") +# How a relative expression looks once translated. A single word such as "today" +# turns into several words ("0 day ago"), which is why the translation of a +# chunk can hold more words than the text it was translated from. +TRANSLATED_RELATIVE_REG = re.compile( + r"\bin \d+ (?:{units})s?\b|\b\d+ (?:{units})s? ago\b".format(units=_UNITS) +) + def date_is_relative(translation): return re.search(RELATIVE_REG, translation) is not None @@ -104,12 +112,61 @@ def split_by(self, item, original, splitter): all_possible_splits.append([item_partially_split, original_partially_split]) return all_possible_splits - def split_if_not_parsed(self, item, original): + def split_by_relative_expression(self, parser, item, original, language, settings): + """Split a chunk into a relative expression and the date next to it. + + A word translated into a multi-word relative expression gives the + translation more separators than the text it was translated from, which + is what keeps the splitters above from lining the two up. Cutting the + chunk in two where the expression ends lines them up again, once the + word the expression was translated from is known and the rest of the + chunk turns out to be the date it was written next to. + """ + words = original.split() + possible_splits = [] + for match in TRANSLATED_RELATIVE_REG.finditer(item): + before = item[: match.start()].strip() + after = item[match.end() :].strip() + if bool(before) == bool(after): + # The expression is the whole chunk, or sits between two parts of + # it, which leaves no boundary the original text can be cut at. + continue + rest = after or before + if len(rest.split()) != len(words) - 1: + # What is left of the translation does not keep one word per + # remaining original one, so it would not line up either. + continue + index = 1 if after else len(words) - 1 + expression = words[0] if after else words[-1] + if language.translate(expression, settings=settings) != match.group(): + # The word next to the boundary is not the one the expression was + # translated from: some other word of the chunk also changed the + # word count, and only made the one above add up. + continue + if parser.get_date_data(rest)["date_obj"] is None: + # There is no date next to the expression, so cutting the chunk + # would report the expression and drop the rest of it. + continue + possible_splits.append( + [ + [match.group(), after] if after else [before, match.group()], + [" ".join(words[:index]), " ".join(words[index:])], + ] + ) + return possible_splits + + def split_if_not_parsed(self, parser, item, original, language, settings): splitters = [",", "،", "——", "—", "–", ".", " "] possible_splits = [] for splitter in splitters: if splitter in item and item.count(splitter) == original.count(splitter): possible_splits.extend(self.split_by(item, original, splitter)) + if not possible_splits: + # Only when no splitter lines up, so that a chunk which already + # splits keeps being split exactly the way it is split today. + possible_splits = self.split_by_relative_expression( + parser, item, original, language, settings + ) return possible_splits def parse_item(self, parser, item, translated_item, parsed, need_relative_base): @@ -127,7 +184,9 @@ def parse_item(self, parser, item, translated_item, parsed, need_relative_base): parsed_item = parser.get_date_data(item) return parsed_item, is_relative - def parse_found_objects(self, parser, to_parse, original, translated, settings): + def parse_found_objects( + self, parser, to_parse, original, translated, settings, language + ): parsed = [] substrings = [] need_relative_base = True @@ -145,7 +204,9 @@ def parse_found_objects(self, parser, to_parse, original, translated, settings): substrings.append(original[i].strip(" .,:()[]-'")) continue - possible_splits = self.split_if_not_parsed(item, original[i]) + possible_splits = self.split_if_not_parsed( + parser, item, original[i], language, settings + ) if not possible_splits: continue @@ -179,6 +240,7 @@ def parse_found_objects(self, parser, to_parse, original, translated, settings): return parsed, substrings def search_parse(self, shortname, text, settings): + language = self.get_current_language(shortname) translated, original = self.search(shortname, text, settings) bad_translate_with_search = [ "vi", @@ -198,6 +260,7 @@ def search_parse(self, shortname, text, settings): original=original, translated=translated, settings=settings, + language=language, ) results = list(zip(substrings, [i[0]["date_obj"] for i in parsed])) diff --git a/tests/test_search.py b/tests/test_search.py index 1428e9e14..b1e634400 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -12,6 +12,7 @@ from tests import BaseTestCase today = datetime.datetime.now(tz=pytz.timezone("UTC")) +relative_base = datetime.datetime(2020, 2, 13, 20, 7, 6) class TestTranslateSearch(BaseTestCase): @@ -1048,6 +1049,84 @@ def test_date_search_function(self, text, languages, settings, expected): result = search_dates(text, languages=languages, settings=settings) self.assertEqual(result, expected) + @parameterized.expand( + [ + # The comma used to be what told the expression and the date apart + param( + text="Today 13 Feb 2020", + languages=["en"], + expected=[ + ("Today", relative_base), + ("13 Feb 2020", datetime.datetime(2020, 2, 13, 0, 0)), + ], + ), + param( + text="Today, 13 Feb 2020", + languages=["en"], + expected=[ + ("Today", relative_base), + ("13 Feb 2020", datetime.datetime(2020, 2, 13, 0, 0)), + ], + ), + # The expression written after the date instead of before it + param( + text="13 Feb 2020 Today", + languages=["en"], + expected=[ + ("13 Feb 2020", datetime.datetime(2020, 2, 13, 0, 0)), + ("Today", relative_base), + ], + ), + # An expression translated into "in 1 day" instead of "0 day ago" + param( + text="Tomorrow 13 Feb 2020", + languages=["en"], + expected=[ + ("Tomorrow", datetime.datetime(2020, 2, 14, 20, 7, 6)), + ("13 Feb 2020", datetime.datetime(2020, 2, 13, 0, 0)), + ], + ), + param( + text="hoy 13 feb 2020", + languages=["es"], + expected=[ + ("hoy", relative_base), + ("13 feb 2020", datetime.datetime(2020, 2, 13, 0, 0)), + ], + ), + # "and" is written by the text but not by its translation, so the + # words left of the expression no longer line up with the ones + # they were translated from + param( + text="Today 13 Feb 2020 and 14 Mar 2021", + languages=["en"], + expected=None, + ), + # "3 days ago" is written as three words and translated into three, + # which the two "tomorrow" adds back: the counts line up although + # the expression was not translated from "3" alone + param( + text="3 days ago tomorrow 13 Feb 2020", + languages=["en"], + expected=None, + ), + # Cutting "today" off would leave "13 feb 2020 before", which is no + # longer a date, so the expression was not written next to one + param( + text="13 feb 2020 before today", + languages=["en"], + expected=None, + ), + ] + ) + def test_search_dates_with_a_relative_expression_next_to_a_date( + self, text, languages, expected + ): + result = search_dates( + text, languages=languages, settings={"RELATIVE_BASE": relative_base} + ) + self.assertEqual(result, expected) + @parameterized.expand( [ param( From 901414a60fa7aa01348536b3afb8e1fd2b8e2a93 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Tue, 22 Sep 2026 11:08:23 +0200 Subject: [PATCH 059/107] Read the direction of a relative expression written next to punctuation (#706) (#1391) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Read the direction of a relative expression written next to punctuation (#706) A future expression such as "через 2 часа" is translated into "in 2 hour", and the "in" is what tells the parser to count forward. A preposition translated into the same word has to be dropped instead, which is decided by looking for a unit of time among the words next to it. A unit keeps the punctuation it was written next to, so "через 2 часа, пожалуйста" translates into "in 2 hour," and the unit is looked up as "hour,". No unit is found, the "in" is dropped as a preposition, and what is left parses as a past date two hours before the reference time instead of two hours after it. Look the unit up without the punctuation it carries. The expression is translated into English before it is parsed, so this reaches every language the same way. Co-Authored-By: Claude Opus 5 (1M context) * Name the punctuation a translated word carries on The direction fix only holds while _clear_future_words strips exactly the punctuation translate_search re-attaches to a translated unit. Give that set one name so the two sites cannot drift apart, and say in the test what it covers: what the translation carries on, not any punctuation at all. No behaviour change: the differential run over the same 14,326 inputs is identical to the previous commit. Co-Authored-By: Claude Fable 5.1 --------- Co-authored-by: Claude Opus 5 (1M context) --- dateparser/languages/locale.py | 25 +++++++++----- tests/test_search.py | 62 ++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+), 8 deletions(-) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 800dd0557..3bfdea2de 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -21,6 +21,12 @@ def _parse_bool(value): return False +# Punctuation a word can be written next to without ceasing to be that word: +# it is looked up in the dictionary without it, and the translation carries +# it on so the text and its translation keep the same separators. +PUNCTUATION = "()\"'{}[],.،" + + class Locale: """ Class that deals with applicability and translation from a locale. @@ -315,14 +321,13 @@ def translate_search(self, search_string, settings=None): elif word in dictionary and word not in dashes: translated_chunk.append(dictionary[word]) original_chunk.append(original_tokens[i]) - elif word.strip("()\"'{}[],.،") in dictionary and word not in dashes: - punct = word[len(word.strip("()\"'{}[],.،")) :] - if punct and dictionary[word.strip("()\"'{}[],.،")]: - translated_chunk.append( - dictionary[word.strip("()\"'{}[],.،")] + punct - ) + elif word.strip(PUNCTUATION) in dictionary and word not in dashes: + bare_word = word.strip(PUNCTUATION) + punct = word[len(bare_word) :] + if punct and dictionary[bare_word]: + translated_chunk.append(dictionary[bare_word] + punct) else: - translated_chunk.append(dictionary[word.strip("()\"'{}[],.،")]) + translated_chunk.append(dictionary[bare_word]) original_chunk.append(original_tokens[i]) elif self._token_with_digits_is_ok(word): translated_chunk.append(word) @@ -599,7 +604,11 @@ def _generate_simplifications(self, normalize=False): def _clear_future_words(self, words): freshness_words = {"day", "week", "month", "year", "hour", "minute", "second"} - if set(words).isdisjoint(freshness_words): + # A unit keeps the punctuation it was written next to, so "2 hours," + # becomes "hour,". That is still the unit of a future expression, and + # dropping the "in" of one is what turns it into a past date. + bare_words = {word.strip(PUNCTUATION) for word in words if word} + if bare_words.isdisjoint(freshness_words): words[words.index("in")] = "" return words diff --git a/tests/test_search.py b/tests/test_search.py index b1e634400..bfed0520d 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1127,6 +1127,68 @@ def test_search_dates_with_a_relative_expression_next_to_a_date( ) self.assertEqual(result, expected) + @parameterized.expand( + [ + # The word a future expression is written with is what points it + # forward, and reporting it is what tells the two directions apart + param( + text="через 2 часа", + languages=["ru"], + expected=[("через 2 часа", relative_base + timedelta(hours=2))], + ), + # The unit is written next to a comma, which used to keep it from + # being read as the unit of a future expression + param( + text="через 2 часа, пожалуйста", + languages=["ru"], + expected=[("через 2 часа", relative_base + timedelta(hours=2))], + ), + param( + text="Позвони мне через 2 часа, пожалуйста", + languages=["ru"], + expected=[("через 2 часа", relative_base + timedelta(hours=2))], + ), + param( + text="через 3 дня, пожалуйста", + languages=["ru"], + expected=[("через 3 дня", relative_base + timedelta(days=3))], + ), + # A past expression is written with its own word and keeps pointing + # back, comma or not + param( + text="2 часа назад", + languages=["ru"], + expected=[("2 часа назад", relative_base - timedelta(hours=2))], + ), + param( + text="2 часа назад, пожалуйста", + languages=["ru"], + expected=[("2 часа назад", relative_base - timedelta(hours=2))], + ), + # The expression is translated into English before it is parsed, so + # the comma reaches the same code whatever it was written in + param( + text="in 2 hours, please", + languages=["en"], + expected=[("in 2 hours", relative_base + timedelta(hours=2))], + ), + # Not only a comma: any punctuation the translation carries on the + # unit. ``parse`` already reads this one as a future date + param( + text="in three weeks' time", + languages=["en"], + expected=[("in three weeks", relative_base + timedelta(weeks=3))], + ), + ] + ) + def test_search_dates_with_a_relative_expression_reads_its_direction( + self, text, languages, expected + ): + result = search_dates( + text, languages=languages, settings={"RELATIVE_BASE": relative_base} + ) + self.assertEqual(result, expected) + @parameterized.expand( [ param( From 2c7ffb9f928328ed67bed0d5c2a47ac7010c10fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=91=A8=E8=80=95=E6=AF=85=EF=BC=88Ryan=20Chou=EF=BC=89?= <88779759+ryanchou1994@users.noreply.github.com> Date: Thu, 24 Sep 2026 02:07:00 +0800 Subject: [PATCH 060/107] fix: preserve complete week dates when parsing custom formats (#1381) --- dateparser/date.py | 2 +- dateparser/utils/__init__.py | 11 ++++++ dateparser/utils/strptime.py | 8 +++-- tests/test_date.py | 68 ++++++++++++++++++++++++++++++++++++ tests/test_utils.py | 9 +++++ 5 files changed, 95 insertions(+), 3 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index ce0dbdb6d..7e28b44fe 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -241,7 +241,7 @@ def parse_with_formats(date_string, date_formats, settings): now = settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( tzinfo=None ) - if not ("%y" in date_format or "%Y" in date_format): + if "year" in _missing: date_obj = date_obj.replace(year=now.year) elif "%y" in date_format and "%Y" not in date_format: date_obj = _apply_century_preference( diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 9ed0554cd..9b6678054 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -56,6 +56,17 @@ def _get_missing_parts(fmt): Return a list containing missing parts (day, month, year) from a date format checking its directives """ + if "%U" in fmt or "%W" in fmt or "%V" in fmt: + # A year, week number and weekday determine the complete date. Consume + # %% pairs so literal directive names do not count as date components. + directives = set(re.findall(r"%[%UWVwuAaYyG]", fmt)) + if ( + directives & {"%U", "%W", "%V"} + and directives & {"%w", "%u", "%a", "%A"} + and directives & {"%Y", "%y", "%G"} + ): + return [] + directive_mapping = { "day": ["%d", "%-d", "%j", "%-j"], # %j (day of year) encodes month implicitly: a successful strptime with %j always diff --git a/dateparser/utils/strptime.py b/dateparser/utils/strptime.py index 6bcdf176e..2dfaa86f7 100644 --- a/dateparser/utils/strptime.py +++ b/dateparser/utils/strptime.py @@ -1,6 +1,8 @@ +import calendar import importlib.util import sys from datetime import datetime +from types import ModuleType import regex as re @@ -37,8 +39,10 @@ def patch_strptime(): _exec_module(_strptime_spec, _strptime) sys.modules["strptime_patched"] = _strptime - _calendar = importlib.util.module_from_spec(_strptime_spec) - _exec_module(_strptime_spec, _calendar) + # Copy the namespace without re-executing calendar, whose enum decorators + # would modify the original module. English names are rebound only here. + _calendar = ModuleType("calendar_patched") + _calendar.__dict__.update(vars(calendar), __name__="calendar_patched") sys.modules["calendar_patched"] = _calendar _strptime._getlang = lambda: ("en_US", "UTF-8") diff --git a/tests/test_date.py b/tests/test_date.py index be2ce7db7..42d8008e9 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -374,6 +374,74 @@ def test_should_parse_date(self, date_string, date_formats, expected_result): self.then_parsed_period_is("day") self.then_parsed_date_is(expected_result) + @parameterized.expand( + [ + ("01.24-1", "%W.%y-%w", datetime(2024, 1, 1)), + ("2024-01-1", "%Y-%U-%w", datetime(2024, 1, 8)), + ("2023-00-1", "%Y-%W-%w", datetime(2022, 12, 26)), + ("2024-09-4", "%Y-%W-%u", datetime(2024, 2, 29)), + ("2024-09-Thu", "%Y-%W-%a", datetime(2024, 2, 29)), + ("2024-08-Thursday", "%Y-%U-%A", datetime(2024, 2, 29)), + ("01.2024-1", "%V.%G-%u", datetime(2024, 1, 1)), + ("2019-W01-1", "%G-W%V-%u", datetime(2018, 12, 31)), + ("2020-W53-5", "%G-W%V-%u", datetime(2021, 1, 1)), + ("2020-W53-Fri", "%G-W%V-%a", datetime(2021, 1, 1)), + ("2020-W53-Friday", "%G-W%V-%A", datetime(2021, 1, 1)), + ("2020-W53-5", "%G-W%V-%w", datetime(2021, 1, 1)), + ] + ) + def test_should_preserve_complete_week_date(self, text, fmt, expected): + self.given_now(2026, 9, 15) + for preference in ("first", "last", "current"): + with self.subTest(preference=preference): + settings = { + "RELATIVE_BASE": datetime(2026, 9, 15), + "PREFER_DAY_OF_MONTH": preference, + "PREFER_MONTH_OF_YEAR": preference, + "PARSERS": ["custom-formats"], + } + parsed = date.DateDataParser(settings=settings).get_date_data( + text, date_formats=[fmt] + ) + self.assertEqual(parsed.date_obj, expected) + self.assertEqual(parsed.period, "day") + self.assertEqual( + dateparser.parse(text, date_formats=[fmt], settings=settings), + expected, + ) + + @parameterized.expand( + [ + ("2024-09", "%Y-%W", 2024), + ("2024-1", "%Y-%w", 2024), + ("2024-%W-1", "%Y-%%W-%w", 2024), + ("2024-01-%w", "%Y-%W-%%w", 2024), + ("09-1", "%W-%w", 2026), + ] + ) + def test_incomplete_week_date_keeps_date_preferences(self, text, fmt, year): + self.given_now(2026, 9, 15) + settings = Settings().replace( + RELATIVE_BASE=datetime(2026, 9, 15), + PREFER_DAY_OF_MONTH="last", + PREFER_MONTH_OF_YEAR="last", + ) + self.when_date_is_parsed_with_formats(text, [fmt], settings) + self.then_parsed_date_is(datetime(year, 12, 31)) + self.then_parsed_period_is("year") + + @parameterized.expand( + [ + ("2024-W01", "%G-W%V"), + ("2024-W01-1", "%Y-W%V-%u"), + ("2024-W01-1", "%G-W%W-%u"), + ("2024-W01-8", "%G-W%V-%u"), + ] + ) + def test_invalid_iso_week_date_is_not_parsed(self, text, fmt): + self.when_date_is_parsed_with_formats(text, [fmt]) + self.then_date_was_not_parsed() + @parameterized.expand( [ param( diff --git a/tests/test_utils.py b/tests/test_utils.py index d107a8644..9b71c9b90 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,3 +1,4 @@ +import calendar import itertools from datetime import datetime @@ -16,6 +17,7 @@ localize_timezone, registry, ) +from dateparser.utils.strptime import patch_strptime from tests import BaseTestCase @@ -25,6 +27,13 @@ def setUp(self): self.date_format = None self.result = None + def test_patch_strptime_preserves_global_calendar(self): + before = vars(calendar).copy() + patch_strptime() + self.assertEqual(set(vars(calendar)), set(before)) + for name, value in before.items(): + self.assertIs(getattr(calendar, name), value, name) + def given_date_format(self, date_format): self.date_format = date_format From ef140a86475a3cd92e472647cbf84b9ed391da7e Mon Sep 17 00:00:00 2001 From: Adrian Date: Mon, 28 Sep 2026 13:46:13 +0200 Subject: [PATCH 061/107] Read year-first dates as YMD unless DATE_ORDER starts with the year (#1419) --- dateparser/parser.py | 7 +++---- tests/test_date_parser.py | 16 ++++++++++++++++ 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 2c55de976..25b84da8e 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -640,13 +640,12 @@ def parse_number(token, skip_component=None): skip_component == "year" and self.day is None and self.month is None - and "DATE_ORDER" not in self.settings._mod_settings + and not self._date_order.startswith("Y") ): # The date string starts with a four-digit year (e.g. an # ISO 8601 date like "2017-06-22"), so the remaining numeric - # components are expected in month-day order, regardless of - # the locale date order, unless the caller explicitly set - # DATE_ORDER (#360). + # components are expected in month-day order, unless the date + # order itself puts the year first (e.g. YDM). num_directives = { k: self.num_directives[k] for k in ("month", "day", "year") } diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 4683b7b6c..c73edcc15 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -955,6 +955,22 @@ def test_iso_datestamp_format_should_parse_with_locale_date_order( self.result["date_obj"] = self.result["date_obj"].replace(tzinfo=None) self.then_date_obj_exactly_is(expected) + @parameterized.expand( + [ + param("2023-11-08", date_order="DMY", expected=datetime(2023, 11, 8)), + param("1960-12-23", date_order="DMY", expected=datetime(1960, 12, 23)), + param("2023-11-08", date_order="MDY", expected=datetime(2023, 11, 8)), + param("2023-11-08", date_order="YDM", expected=datetime(2023, 8, 11)), + ] + ) + def test_year_first_date_with_explicit_date_order( + self, date_string, date_order, expected + ): + self.given_parser(languages=["en"], settings={"DATE_ORDER": date_order}) + self.when_date_is_parsed(date_string) + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(expected) + @parameterized.expand( [ # Epoch timestamps. From 3ec5fe34eb125c10297a35932c3f52009d1b8ad9 Mon Sep 17 00:00:00 2001 From: yamilmaud <75587783+yamilmaud@users.noreply.github.com> Date: Tue, 29 Sep 2026 06:32:31 -0300 Subject: [PATCH 062/107] Fix timezone parser ignoring Unicode dash-like UTC offset characters (#1474) --- dateparser/date.py | 40 +++++++++++++++++++++++++++++++++++ tests/test_date.py | 7 ++++++ tests/test_timezone_parser.py | 17 +++++++++++++++ 3 files changed, 64 insertions(+) diff --git a/dateparser/date.py b/dateparser/date.py index 7e28b44fe..3bafddf5e 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -37,6 +37,44 @@ "\N{FULLWIDTH APOSTROPHE}", # '\uff07' ] +# Unicode Dash Characters, per the "Dash" property table in the Unicode Standard +# (https://www.unicode.org/versions/latest/core-spec/chapter-6/#G9697), excluding +# U+002D HYPHEN-MINUS itself. Written as \u/\U escapes rather than \N{...} names +# since some of these (e.g. Garay Hyphen, Yezidi Hyphenation Mark) are recent +# Unicode additions not present in the unicodedata name tables of older Pythons. +DASH_LOOK_ALIKE_CHARS = [ + "\u058a", # ARMENIAN HYPHEN + "\u05be", # HEBREW PUNCTUATION MAQAF + "\u1400", # CANADIAN SYLLABICS HYPHEN + "\u1806", # MONGOLIAN TODO SOFT HYPHEN + "\u2010", # HYPHEN + "\u2011", # NON-BREAKING HYPHEN + "\u2012", # FIGURE DASH + "\u2013", # EN DASH + "\u2014", # EM DASH + "\u2015", # HORIZONTAL BAR + "\u2053", # SWUNG DASH + "\u207b", # SUPERSCRIPT MINUS + "\u208b", # SUBSCRIPT MINUS + "\u2212", # MINUS SIGN + "\u2e17", # DOUBLE OBLIQUE HYPHEN + "\u2e1a", # HYPHEN WITH DIAERESIS + "\u2e3a", # TWO-EM DASH + "\u2e3b", # THREE-EM DASH + "\u2e40", # DOUBLE HYPHEN + "\u2e5d", # OBLIQUE HYPHEN + "\u301c", # WAVE DASH + "\u3030", # WAVY DASH + "\u30a0", # KATAKANA-HIRAGANA DOUBLE HYPHEN + "\ufe31", # PRESENTATION FORM FOR VERTICAL EM DASH + "\ufe32", # PRESENTATION FORM FOR VERTICAL EN DASH + "\ufe58", # SMALL EM DASH + "\ufe63", # SMALL HYPHEN-MINUS + "\uff0d", # FULLWIDTH HYPHEN-MINUS + "\U00010d6e", # GARAY HYPHEN + "\U00010ead", # YEZIDI HYPHENATION MARK +] + RE_NBSP = re.compile("\xa0", flags=re.UNICODE) RE_SPACES = re.compile(r"\s+") RE_TRIM_SPACES = re.compile(r"^\s+(\S.*?)\s+$") @@ -52,6 +90,7 @@ RE_SANITIZE_PERIOD = re.compile(r"(?<=[^0-9\s])\.", flags=re.U) RE_SANITIZE_ON = re.compile(r"^.*?on:\s+(.*)") RE_SANITIZE_APOSTROPHE = re.compile("|".join(APOSTROPHE_LOOK_ALIKE_CHARS)) +RE_SANITIZE_DASH = re.compile("|".join(DASH_LOOK_ALIKE_CHARS)) RE_SEARCH_TIMESTAMP = re.compile(r"^(\d{10})(\d{3})?(\d{3})?(?![^.])") RE_SEARCH_NEGATIVE_TIMESTAMP = re.compile(r"^([-]\d{10})(\d{3})?(\d{3})?(?![^.])") @@ -145,6 +184,7 @@ def sanitize_date(date_string): date_string = RE_SANITIZE_ON.sub(r"\1", date_string) date_string = RE_TRIM_COLONS.sub(r"\1", date_string) date_string = RE_SANITIZE_APOSTROPHE.sub("'", date_string) + date_string = RE_SANITIZE_DASH.sub("-", date_string) date_string = date_string.strip() return date_string diff --git a/tests/test_date.py b/tests/test_date.py index 42d8008e9..8ade54321 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1298,6 +1298,13 @@ def test_sanitize_date_colons(self): self.assertEqual(date.sanitize_date("2019:"), "2019") self.assertEqual(date.sanitize_date("31/07/2019:"), "31/07/2019") + def test_sanitize_date_dash_look_alikes(self): + for dash in date.DASH_LOOK_ALIKE_CHARS: + self.assertEqual( + date.sanitize_date(f"UTC{dash}06:00"), + "UTC-06:00", + ) + class TestDateLocaleParser(BaseTestCase): def setUp(self): diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index 7b7fa6bc7..6691b69d5 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -122,6 +122,23 @@ def then_offset_is(self, expected_offset): self.assertEqual(delta, self.timezone_offset) +class TestUnicodeDashOffsets(BaseTestCase): + @parameterized.expand( + [ + param("jan 15th UTC‐06:00", -6), # HYPHEN + param("jan 15th UTC–06:00", -6), # EN DASH + param("jan 15th UTC—06:00", -6), # EM DASH + param("jan 15th UTC−06:00", -6), # MINUS SIGN + param("jan 15th UTC-06:00", -6), # FULLWIDTH HYPHEN-MINUS + param("jan 15th UTC+06:00", 6), + ] + ) + def test_parses_dash_look_alike_offsets(self, date_string, expected_offset_hours): + parsed = parse(date_string) + self.assertIsNotNone(parsed) + self.assertEqual(parsed.utcoffset(), timedelta(hours=expected_offset_hours)) + + class TestLocalTZOffset(BaseTestCase): def setUp(self): super().setUp() From 7385b82044ecf6a05c9e2b50694a49656e8e1b05 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 08:10:14 +0200 Subject: [PATCH 063/107] Swap day and month for any DATE_ORDER when they do not fit (#1431) --- dateparser/parser.py | 33 ++++++++++++++++++++++++++++++--- tests/test_date_parser.py | 21 +++++++++++++++++++++ 2 files changed, 51 insertions(+), 3 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 25b84da8e..74cf14518 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -377,6 +377,19 @@ def __init__(self, tokens, settings, date_order=None): setattr(self, "_token_%s" % attr, token) setattr(self, attr, int(token)) + @classmethod + def _has_month_name(cls, tokens): + for token, type in tokens: + if type != 1: + continue + for directive in cls.alpha_directives["month"]: + try: + strptime(token.strip(), directive) + return True + except ValueError: + pass + return False + def _get_period(self): if self.settings.RETURN_TIME_AS_PERIOD: if getattr(self, "time", None): @@ -607,9 +620,23 @@ def _correct_for_month(self, dateobj): @classmethod def parse(cls, datestring, settings, tz=None, date_order=None): - tokens = tokenizer(datestring) - po = cls(tokens.tokenize(), settings, date_order=date_order) - dateobj = po._results() + tokens = list(tokenizer(datestring).tokenize()) + date_order = date_order or settings.DATE_ORDER + try: + po = cls(tokens, settings, date_order=date_order) + dateobj = po._results() + except ValueError as error: + if ( + "DATE_ORDER" not in settings._mod_settings + or str(error).startswith("Fields missing") + or cls._has_month_name(tokens) + ): + raise + # The numbers do not fit the date order set by the caller, so read + # them with the day and month swapped, e.g. "2021-01-13" with YDM. + swapped = date_order.translate(str.maketrans("DM", "MD")) + po = cls(tokens, settings, date_order=swapped) + dateobj = po._results() # correction for past, future if applicable dateobj = po._correct_for_time_frame(dateobj, tz) diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index c73edcc15..c332d07c3 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1194,6 +1194,17 @@ def test_period_is_day_if_return_time_as_period_setting_not_applied( expected=datetime(1856, 5, 23, 0, 9, 8), order="DMY", ), + # A day and month that do not fit the date order are swapped. + param("2021-13-01", expected=datetime(2021, 1, 13), order="YMD"), + param("2021-01-13", expected=datetime(2021, 1, 13), order="YDM"), + param("13/01/2021", expected=datetime(2021, 1, 13), order="MDY"), + param("01/13/2021", expected=datetime(2021, 1, 13), order="DMY"), + param("01/13/21", expected=datetime(2021, 1, 13), order="DMY"), + param("13-2021-01", expected=datetime(2021, 1, 13), order="MYD"), + param("01-2021-13", expected=datetime(2021, 1, 13), order="DYM"), + param("13/01/2021", expected=datetime(2021, 1, 13), order="YDM"), + param("01/13/2021", expected=datetime(2021, 1, 13), order="DYM"), + param("12 13 December", expected=datetime(2013, 12, 12), order="DMY"), ] ) def test_order(self, date_string, expected=None, order=None): @@ -1202,6 +1213,16 @@ def test_order(self, date_string, expected=None, order=None): self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) + def test_locale_order_is_not_swapped(self): + self.given_parser(languages=["fr"]) + self.when_date_is_parsed("01/13/2021") + self.then_date_obj_exactly_is(None) + + def test_order_is_not_swapped_with_a_month_name(self): + self.given_parser(languages=["en"], settings={"DATE_ORDER": "DMY"}) + self.when_date_is_parsed("12/24, Monday 15 March 2021") + self.then_date_obj_exactly_is(None) + @parameterized.expand( [ # Japanese dates without a year: the day must not be read as From 2ab35886509dbc67df6b7791ab4062297c02a950 Mon Sep 17 00:00:00 2001 From: yamilmaud <75587783+yamilmaud@users.noreply.github.com> Date: Wed, 30 Sep 2026 04:49:58 -0300 Subject: [PATCH 064/107] Fix weekday/month abbreviation conflicts in translation (#1061) (#1476) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * fix: resolve weekday/month abbreviation conflicts in translation Some locales (Italian and 20+ others) reuse the same abbreviation for a weekday and a month, e.g. Italian "mar" is both "martedì" (Tuesday) and "marzo" (March). Dictionary construction always resolved this in favor of the month since months are listed after weekdays in KNOWN_WORD_TOKENS, so strings like "mar, 07 giu 2022 08:56:47 +0200" translated to "march, 07 june 2022..." and failed to parse entirely, with or without an explicit date_formats. Track these conflicts in Dictionary.weekday_month_conflicts and, in Locale.translate(), resolve a leading ambiguous token followed by a comma (the common "Weekday, day Month Year" pattern) as the weekday. Fixes #1061 Co-Authored-By: Claude Sonnet 5 * fix: only treat ambiguous weekday/month token as weekday with an unambiguous month present Address review feedback on the previous commit: resolving any ambiguous weekday/month token followed by a comma as a weekday was too broad and flipped genuine month-only usages (e.g. Italian "mar, 2022" from March 2022 to the current month, "mar, 7 2022" from March 7 to a different month/day), and still failed to parse the same string without a comma ("mar 07 giu 2022 ..."). Instead, only resolve an ambiguous token as a weekday when another, unambiguous month is present elsewhere in the same string - a date string only needs one month, so any other month-shaped token in that case must be something else. Rename the new Dictionary members with a leading underscore since they are not public API. Co-Authored-By: Claude Sonnet 5 * fix: prefix _is_unambiguous_month and trim redundant test docstring Small follow-up nits from review: rename Dictionary.is_unambiguous_month to _is_unambiguous_month, since it's internal API like the other new members, and drop the "as it was before Issue #1061 was fixed" clause from test_weekday_month_abbreviation_conflict_is_read_as_month's docstring. Co-Authored-By: Claude Sonnet 5 --------- Co-authored-by: Claude Sonnet 5 --- dateparser/languages/dictionary.py | 39 +++++++++++++++++++++++ dateparser/languages/locale.py | 16 +++++++++- tests/test_date_parser.py | 51 ++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 1 deletion(-) diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index e5ee4da63..dbba8a14b 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -48,6 +48,9 @@ NUMERAL_PATTERN = re.compile(r"(\d+)") KEEP_TOKEN_PATTERN = re.compile(r"^.*[^\W_].*$", flags=re.U) +_WEEKDAY_TOKENS = KNOWN_WORD_TOKENS[0:7] +_MONTH_TOKENS = KNOWN_WORD_TOKENS[7:19] + class UnknownTokenError(Exception): pass @@ -102,6 +105,32 @@ def __init__(self, locale_info, settings=None): if word in locale_info: translations = map(methodcaller("lower"), locale_info[word]) dictionary.update(zip_longest(translations, [], fillvalue=word)) + + # Some locales (mostly Romance languages) reuse the same abbreviation for a + # weekday and a month (e.g. Italian "mar" is both "martedì" and "marzo"). + # The loop above always resolves those in favor of the month, since months + # are listed after weekdays in KNOWN_WORD_TOKENS. Keep track of the weekday + # each conflicting token could also mean, and of which tokens are + # unambiguously months, so a caller with extra context (e.g. another, + # unambiguous month elsewhere in the same string) can recover the weekday + # reading. + weekday_translations = {} + for word in _WEEKDAY_TOKENS: + if word in locale_info: + for token in map(methodcaller("lower"), locale_info[word]): + weekday_translations[token] = word + self._month_translations = set() + for word in _MONTH_TOKENS: + if word in locale_info: + self._month_translations.update( + map(methodcaller("lower"), locale_info[word]) + ) + self._weekday_month_conflicts = { + token: weekday + for token, weekday in weekday_translations.items() + if token in self._month_translations + } + dictionary.update(zip_longest(ALWAYS_KEEP_TOKENS, ALWAYS_KEEP_TOKENS)) dictionary.update( zip_longest( @@ -122,6 +151,16 @@ def __init__(self, locale_info, settings=None): relative_type_regex = locale_info.get("relative-type-regex", {}) self._relative_strings = list(chain.from_iterable(relative_type_regex.values())) + def _is_unambiguous_month(self, token): + """ + Whether ``token`` (already lowercased) names a month and, unlike the + tokens in :attr:`_weekday_month_conflicts`, cannot also mean a weekday. + """ + return ( + token in self._month_translations + and token not in self._weekday_month_conflicts + ) + def __contains__(self, key): if key in self._settings.SKIP_TOKENS: return True diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 3bfdea2de..dd3bed76f 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -179,6 +179,15 @@ def translate( relative_translations = self._get_relative_translations(settings=settings) + # A token that could be either a weekday or a month abbreviation (see + # Dictionary._weekday_month_conflicts) can only be the weekday if another, + # unambiguous month is present elsewhere in the string - otherwise it keeps + # meaning a month, as it does everywhere else in the string's locale. + has_unambiguous_month = any( + dictionary._is_unambiguous_month(token.lower()) + for token in date_string_tokens + ) + for i, word in enumerate(date_string_tokens): word = word.lower() for pattern, replacement in relative_translations.items(): @@ -186,7 +195,12 @@ def translate( date_string_tokens[i] = pattern.sub(replacement, word) break else: - if word in dictionary: + if ( + has_unambiguous_month + and word in dictionary._weekday_month_conflicts + ): + date_string_tokens[i] = dictionary._weekday_month_conflicts[word] + elif word in dictionary: fallback = word if keep_formatting and not word.isalpha() else "" date_string_tokens[i] = dictionary[word] or fallback if "in" in date_string_tokens: diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index c332d07c3..b543984da 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1980,6 +1980,57 @@ def test_out_of_range_day_of_year_is_not_parsed(self, date_string): """Test that an invalid %j value is not read as another date (Issue #271).""" self.assertIsNone(parse(date_string, date_formats=["%Y%j"])) + @parameterized.expand( + [ + param( + date_string="mar, 07 giu 2022 08:56:47 +0200", + date_formats=["%a, %d %b %Y %H:%M:%S %z"], + ), + param(date_string="mar, 07 giu 2022 08:56:47 +0200", date_formats=None), + param(date_string="mar 07 giu 2022 08:56:47 +0200", date_formats=None), + ] + ) + def test_weekday_month_abbreviation_conflict_is_read_as_weekday( + self, date_string, date_formats + ): + """Italian "mar" abbreviates both "martedì" (Tue) and "marzo" (Mar). When + another, unambiguous month ("giu") is present in the same string, "mar" must + be read as the weekday, comma or not, or the string fails to parse entirely + (Issue #1061).""" + result = parse(date_string, date_formats=date_formats, languages=["it"]) + self.assertIsNotNone(result) + self.assertEqual(datetime(2022, 6, 7, 8, 56, 47), result.replace(tzinfo=None)) + + @parameterized.expand( + [ + param(date_string="mar 2022", expected_year=2022, expected_month=3), + param(date_string="mar, 2022", expected_year=2022, expected_month=3), + param( + date_string="mar, 7 2022", + expected_year=2022, + expected_month=3, + expected_day=7, + ), + param( + date_string="mar, 10, 2022", + expected_year=2022, + expected_month=3, + expected_day=10, + ), + ] + ) + def test_weekday_month_abbreviation_conflict_is_read_as_month( + self, date_string, expected_year, expected_month, expected_day=None + ): + """Without another, unambiguous month elsewhere in the string, the ambiguous + Italian "mar" abbreviation must still be read as the month.""" + result = parse(date_string, languages=["it"]) + self.assertIsNotNone(result) + self.assertEqual(expected_year, result.year) + self.assertEqual(expected_month, result.month) + if expected_day is not None: + self.assertEqual(expected_day, result.day) + if __name__ == "__main__": unittest.main() From b373ff775691b8d269423be9f1b57fc15b40c305 Mon Sep 17 00:00:00 2001 From: Sanjay Santhanam <51058514+Sanjays2402@users.noreply.github.com> Date: Wed, 30 Sep 2026 01:35:45 -0700 Subject: [PATCH 065/107] fix: parse dates with a numeric offset and redundant tz abbreviation (#1227) (#1348) --- dateparser/timezone_parser.py | 58 +++++++++++++++++++++++++++-------- dateparser/timezones.py | 2 +- tests/test_date_parser.py | 15 +++++++++ tests/test_timezone_parser.py | 9 ++++++ 4 files changed, 71 insertions(+), 13 deletions(-) diff --git a/dateparser/timezone_parser.py b/dateparser/timezone_parser.py index 04d412f99..58aa2c0c8 100644 --- a/dateparser/timezone_parser.py +++ b/dateparser/timezone_parser.py @@ -31,19 +31,53 @@ def __getinitargs__(self): return self.__name, self.__offset +def _search_and_pop_tz(date_string): + """Find and remove the first timezone token from ``date_string``. + + Returns a ``(new_string, name, info)`` tuple, or ``None`` if no timezone + token is present. + """ + if not _search_regex_ignorecase.search(date_string): + return None + for name, info in _tz_offsets: + timezone_match = info["regex"].search(date_string) + if timezone_match: + start, stop = timezone_match.span() + # A token glued to the digits that follow, as in + # 2019-09-28WIB19:17:34, leaves a space so that the date and time + # digits stay apart. + glued = stop < len(date_string) and date_string[stop - 1].isalpha() + separator = " " if glued else "" + return ( + date_string[: start + 1] + separator + date_string[stop:], + name, + info, + ) + return None + + def pop_tz_offset_from_string(date_string, as_offset=True): - if _search_regex_ignorecase.search(date_string): - for name, info in _tz_offsets: - timezone_re = info["regex"] - timezone_match = timezone_re.search(date_string) - if timezone_match: - start, stop = timezone_match.span() - date_string = date_string[: start + 1] + date_string[stop:] - return ( - date_string, - StaticTzInfo(name, info["offset"]) if as_offset else name, - ) - return date_string, None + match = _search_and_pop_tz(date_string) + if match is None: + return date_string, None + + date_string, name, info = match + result = StaticTzInfo(name, info["offset"]) if as_offset else name + + # A date string may carry both a numeric UTC offset and a redundant, + # equivalent timezone abbreviation, e.g. the RFC 2822 email form + # ``-0500 (CDT)`` (the parenthesised name is informational and the numeric + # offset is authoritative). Only one token is removed above; strip a second, + # equivalent one so the leftover does not break the rest of the parser. + # The remainder is right-stripped first because the numeric-offset regexes + # are anchored at the end of the string. + while True: + extra = _search_and_pop_tz(date_string.rstrip()) + if extra is None or extra[2]["offset"] != info["offset"]: + break + date_string = extra[0] + + return date_string, result def word_is_tz(word): diff --git a/dateparser/timezones.py b/dateparser/timezones.py index 592c1d70c..458bc5d6e 100644 --- a/dateparser/timezones.py +++ b/dateparser/timezones.py @@ -74,7 +74,7 @@ ], }, { - "regex_patterns": [r"(\W|\d|_)%s($|\W)"], + "regex_patterns": [r"(\W|\d|_)%s($|\W|(?=\d))"], "timezones": [ ("ACDT", 37800), ("ACST", 34200), diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index b543984da..3a431728b 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -547,6 +547,21 @@ def test_dateparser_should_return_date_in_setting_timezone_if_timezone_info_pres "Fri Sep 23 2016 10:34:51 GMT+0800 (CST)", datetime(2016, 9, 23, 2, 34, 51), ), + # RFC 2822 email dates carry a numeric offset plus a redundant, + # equivalent timezone abbreviation in parentheses. + param( + "Thu, 30 May 2024 10:13:10 -0500 (CDT)", + datetime(2024, 5, 30, 15, 13, 10), + ), + param( + "30 May 2024 10:13:10 -0500 CDT", + datetime(2024, 5, 30, 15, 13, 10), + ), + param( + "Mon, 15 Jan 2024 09:30:00 +0000 (UTC)", + datetime(2024, 1, 15, 9, 30, 0), + ), + param("2019-09-28WIB19:17:34+07:00", datetime(2019, 9, 28, 12, 17, 34)), ] ) def test_parsing_with_utc_offsets(self, date_string, expected): diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index 6691b69d5..3d92e4d58 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -88,6 +88,15 @@ def test_extracting_valid_offset(self, initial_string, expected_offset): "17th October, 2034 @ 01:08 am +0700", "17th October, 2034 @ 01:08 am " ), param("Sep 03 2014 4:32 pm +0630", "Sep 03 2014 4:32 pm "), + param( + "Thu 30 May 2024 10:13:10 -0500 CDT", + "Thu 30 May 2024 10:13:10 ", + ), + param( + "Thu 30 May 2024 10:13:10 CDT -0500", + "Thu 30 May 2024 10:13:10 ", + ), + param("2019-09-28WIB19:17:34+07:00", "2019-09-28 19:17:34"), ] ) def test_timezone_deleted_from_string(self, initial_string, result_string): From f62b33c386a76e92a1a3501932f0b1d0a9030719 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:50:07 +0200 Subject: [PATCH 066/107] Parse Thai relative dates with spaced ago/in words (#1411) --- dateparser/data/date_translation_data/th.py | 7 +++++-- .../date_translation_data/th.yaml | 3 +++ tests/test_freshness_date_parser.py | 3 +++ 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/dateparser/data/date_translation_data/th.py b/dateparser/data/date_translation_data/th.py index 53789c9da..f019337f7 100644 --- a/dateparser/data/date_translation_data/th.py +++ b/dateparser/data/date_translation_data/th.py @@ -274,10 +274,13 @@ "ago": [ "แต่ก่อน", "มาแล้ว", - "ก่อน" + "ก่อน", + "ที่แล้ว", + "ที่ผ่านมา" ], "in": [ - "ใน" + "ใน", + "อีก" ], "simplifications": [ { diff --git a/dateparser_data/supplementary_language_data/date_translation_data/th.yaml b/dateparser_data/supplementary_language_data/date_translation_data/th.yaml index 7da2a9bc2..70557eae8 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/th.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/th.yaml @@ -68,8 +68,11 @@ ago: - แต่ก่อน - มาแล้ว - ก่อน + - ที่แล้ว + - ที่ผ่านมา in: - ใน + - อีก simplifications: - วันนี้: 0 วัน diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index ef1477e9c..95c20f95e 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -1286,6 +1286,8 @@ def test_relative_past_dates(self, date_string, ago, period): }, period="day", ), + param("6 วัน ที่แล้ว", ago={"days": 6}, period="day"), + param("3 เดือน ที่ผ่านมา", ago={"months": 3}, period="month"), # Vietnamese dates param("Hôm nay", ago={"days": 0}, period="day"), param("Hôm qua", ago={"days": 1}, period="day"), @@ -2301,6 +2303,7 @@ def test_normalized_relative_dates(self, date_string, ago, period): # th param("ในอีก 6 นาที", in_future={"minutes": 6}, period="day"), param("ในอีก 3 ปี", in_future={"years": 3}, period="year"), + param("อีก 6 วัน", in_future={"days": 6}, period="day"), # to param("'i he māhina 'e 5", in_future={"months": 5}, period="month"), param("'i he houa 'e 11", in_future={"hours": 11}, period="day"), From f3672f06649eac20d6f9d62d44a0b3519228b583 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:50:34 +0200 Subject: [PATCH 067/107] Add a pull request template (#1404) --- .github/pull_request_template.md | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 .github/pull_request_template.md diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 000000000..34c3228c8 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,3 @@ +Resolves #NNNN. + +- [ ] I have read the [contributing guide](https://dateparser.readthedocs.io/en/latest/contributing.html) and [set up pre-commit](https://pre-commit.com/#quick-start). From 0f6b38903d4c190d33a0cb8e80944cc995000efa Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:50:58 +0200 Subject: [PATCH 068/107] Stop reading "Nth day" as a number of days in English dates (#1412) --- dateparser/data/date_translation_data/en.py | 3 +++ .../supplementary_language_data/date_translation_data/en.yaml | 1 + tests/test_date_parser.py | 1 + 3 files changed, 5 insertions(+) diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index 13c72da42..046ea2575 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -1165,6 +1165,9 @@ { "less than 1 minute ago": "45 second ago" }, + { + "(\\d+(?:st|nd|rd|th)) day": "\\1" + }, { "(\\d++[.,]?\\d*+|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later": "in \\1 \\2" }, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index 743d5e04b..9d27cad93 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -93,6 +93,7 @@ simplifications: - (\d+[.,]?\d*)h(\d+[.,]?\d*): \1:\2 - from\s+now: in - less than 1 minute ago: 45 second ago + - (\d+(?:st|nd|rd|th)) day: \1 - (\d+[.,]?\d*|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve) (decade|year|month|week|day|hour|minute|second)s? later: in \1 \2 - one: '1' - two: '2' diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 3a431728b..f443615bc 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -29,6 +29,7 @@ def setUp(self): param("[Sept] 04, 2014.", datetime(2014, 9, 4)), param("Tuesday Jul 22, 2014", datetime(2014, 7, 22)), param("Tues 9th Aug, 2015", datetime(2015, 8, 9)), + param("the 1st day of March 2015", datetime(2015, 3, 1)), param("10:04am", datetime(2012, 11, 13, 10, 4)), param("Friday", datetime(2012, 11, 9)), param("November 19, 2014 at noon", datetime(2014, 11, 19, 12, 0)), From e9e3cad97cfab17e4e9134e3eb3c14dd1951913d Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:51:22 +0200 Subject: [PATCH 069/107] Explain how DEFAULT_LANGUAGES relates to the languages argument (#1422) --- docs/settings.rst | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/docs/settings.rst b/docs/settings.rst index d50a753fd..6a26192a8 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -218,16 +218,22 @@ Language Detection datetime.datetime(2015, 12, 4, 0, 0) -Default Languages +Default languages +++++++++++++++++ -``DEFAULT_LANGUAGES``: It is a ``list`` of language codes in ISO 639 that will be used as default -languages for parsing when language detection fails. eg. ["en", "fr"]: +``DEFAULT_LANGUAGES``: a ``list`` of ISO 639 language codes to fall back to +when parsing fails with every other language, i.e. those given through the +``languages`` or ``locales`` arguments of :func:`dateparser.parse` or those +detected. These fallback languages are tried even if the input contains no word +of theirs: >>> from dateparser import parse - >>> parse('3 de marzo de 2020', settings={'DEFAULT_LANGUAGES': ["es"]}) + >>> parse('3 de marzo de 2020', languages=['en']) + >>> parse('3 de marzo de 2020', languages=['en'], settings={'DEFAULT_LANGUAGES': ['es']}) + datetime.datetime(2020, 3, 3, 0, 0) -.. note:: When using this setting, these languages will be tried after trying with the detected languages with no success. It is especially useful when using ``detect_languages_function``. +It is especially useful with ``detect_languages_function``, to cover input for +which language detection fails. Language Order ++++++++++++++ From bfab00c1ef4e5da1b1ab2b7533a24b6e1d3e76ed Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:51:43 +0200 Subject: [PATCH 070/107] Harden GitHub Actions and watch for new CLDR releases (#1462) --- .github/dependabot.yml | 12 ++++++++ .github/workflows/cifuzz.yml | 8 ++--- .github/workflows/cldr.yml | 54 ++++++++++++++++++++++++++++++++++ .github/workflows/codspeed.yml | 8 +++-- .github/workflows/main.yml | 11 +++++-- .github/workflows/nightly.yml | 1 - .github/workflows/publish.yml | 15 ++++++---- .pre-commit-config.yaml | 5 ++++ 8 files changed, 98 insertions(+), 16 deletions(-) create mode 100644 .github/dependabot.yml create mode 100644 .github/workflows/cldr.yml diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 000000000..623d48cfa --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,12 @@ +version: 2 +updates: + - package-ecosystem: github-actions + directory: "/" + schedule: + interval: monthly + groups: + github-actions: + patterns: + - "*" + cooldown: + default-days: 7 diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml index c32c5c9b7..72661697f 100644 --- a/.github/workflows/cifuzz.yml +++ b/.github/workflows/cifuzz.yml @@ -9,26 +9,26 @@ jobs: steps: - name: Build Fuzzers id: build - uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master + uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@2820b2b71f58013e7f2ef2f87089433a075561d8 # master with: oss-fuzz-project-name: 'dateparser' language: python - name: Run Fuzzers - uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master + uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@2820b2b71f58013e7f2ef2f87089433a075561d8 # master with: oss-fuzz-project-name: 'dateparser' language: python fuzz-seconds: 600 output-sarif: true - name: Upload Crash - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 if: failure() && steps.build.outcome == 'success' with: name: artifacts path: ./out/artifacts - name: Upload Sarif if: always() && steps.build.outcome == 'success' - uses: github/codeql-action/upload-sarif@v4 + uses: github/codeql-action/upload-sarif@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2 with: # Path to SARIF file relative to the root of the repository sarif_file: cifuzz-sarif/results.sarif diff --git a/.github/workflows/cldr.yml b/.github/workflows/cldr.yml new file mode 100644 index 000000000..b0a1cdeb4 --- /dev/null +++ b/.github/workflows/cldr.yml @@ -0,0 +1,54 @@ +name: CLDR +on: + # CLDR releases come every few months, so a monthly check is timely enough. + schedule: + - cron: "43 5 1 * *" + workflow_dispatch: + +permissions: + contents: read + +jobs: + check: + name: Check for a newer CLDR release + if: github.ref == 'refs/heads/master' + runs-on: ubuntu-latest + timeout-minutes: 5 + permissions: + contents: read + issues: write + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + - name: File an issue if the bundled CLDR data is out of date + env: + GH_TOKEN: ${{ github.token }} + GH_REPO: ${{ github.repository }} + LABEL: cldr-update + run: | + set -euo pipefail + current="$(grep -oP 'cldr_version = "\K[^"]+' dateparser_scripts/utils.py)" + # The latest release excludes alphas and betas. + latest="$(gh api repos/unicode-org/cldr-json/releases/latest --jq .tag_name)" + echo "Bundled: $current, latest: $latest." + if [ "$current" = "$latest" ]; then + exit 0 + fi + gh label create "$LABEL" --force --color 5319e7 \ + --description "Filed by the CLDR workflow" + existing="$(gh issue list --state open --label "$LABEL" --limit 1 \ + --json number --jq '.[0].number // empty')" + if [ -n "$existing" ]; then + echo "Already tracked in #$existing." + exit 0 + fi + gh issue create --title "Update the CLDR data to $latest" \ + --label "$LABEL" --label "Type: Maintenance" --body-file - < Date: Wed, 30 Sep 2026 10:52:04 +0200 Subject: [PATCH 071/107] Document search_dates parameters and add it to the API reference (#1468) --- README.rst | 14 ++++++++++++++ docs/dateparser.rst | 8 ++++++++ 2 files changed, 22 insertions(+) diff --git a/README.rst b/README.rst index 2b0ac941b..4d2ed7ad2 100644 --- a/README.rst +++ b/README.rst @@ -273,6 +273,20 @@ list of ``(substring, datetime)`` tuples: >>> search_dates('Today is 25 of October 2017, so the 27th is in 2 days.') [('25 of October 2017', datetime.datetime(2017, 10, 25, 0, 0)), ('the 27th is in 2 days', datetime.datetime(2017, 10, 27, 0, 0))] +Pass ``languages`` when you know them: language detection is slow and +error-prone on short text. If no date is found, ``None`` is returned: + +.. code:: python + + >>> search_dates('Lancé le 4 octobre 1957.', languages=['fr']) + [('le 4 octobre 1957', datetime.datetime(1957, 10, 4, 0, 0))] + >>> search_dates('Rien à voir.', languages=['fr']) + None + +See the `API reference +`__ +for other parameters, such as ``strategy``. + Time Span Detection ------------------- diff --git a/docs/dateparser.rst b/docs/dateparser.rst index d28072706..75c32ba27 100644 --- a/docs/dateparser.rst +++ b/docs/dateparser.rst @@ -44,6 +44,14 @@ dateparser.freshness_date_parser module :undoc-members: :show-inheritance: +dateparser.search module +------------------------ + +.. automodule:: dateparser.search + :members: + :undoc-members: + :show-inheritance: + dateparser.timezone_parser module --------------------------------- From 7d50f3bab2816ef41b1f51eb0a9e010e2e62c697 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:52:25 +0200 Subject: [PATCH 072/107] Add a performance section to the docs (#1494) --- docs/index.rst | 1 + docs/performance.rst | 47 ++++++++++++++++++++++++++++++++++++++++++++ docs/usage.rst | 3 +-- 3 files changed, 49 insertions(+), 2 deletions(-) create mode 100644 docs/performance.rst diff --git a/docs/index.rst b/docs/index.rst index c3e8bb058..d805b246e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -18,6 +18,7 @@ Contents: usage settings custom_language_detection + performance supported_locales contributing modules diff --git a/docs/performance.rst b/docs/performance.rst new file mode 100644 index 000000000..1e863593e --- /dev/null +++ b/docs/performance.rst @@ -0,0 +1,47 @@ +.. _performance: + +=========== +Performance +=========== + +Limit the languages +------------------- + +By default, the language of each input string is detected among all supported +languages. If you know which languages your input can be in, pass them through +the ``languages`` or ``locales`` parameter: + + >>> import dateparser + >>> dateparser.parse('12 de marzo de 2020', languages=['es']) + datetime.datetime(2020, 3, 12, 0, 0) + +Reuse a parser +-------------- + +:func:`dateparser.parse` creates a new :class:`DateDataParser +` on every call that sets any parameter or +setting. To parse many strings with the same parameters and settings, create a +:class:`DateDataParser ` once and reuse it: + + >>> from dateparser.date import DateDataParser + >>> ddp = DateDataParser(languages=['es'], settings={'PARSERS': ['absolute-time']}) + >>> ddp.get_date_data('12 de marzo de 2020') + DateData(date_obj=datetime.datetime(2020, 3, 12, 0, 0), period='day', locale='es') + +Limit the parsers +----------------- + +Set the ``PARSERS`` :ref:`setting ` to the parsers that your input +needs, as in the example above, which skips relative dates like “3 days ago”. + +Try previous locales first +-------------------------- + +With ``try_previous_locales=True``, a :class:`DateDataParser +` first tries the locales that parsed earlier +strings, which is faster when most strings share a locale: + + >>> ddp = DateDataParser(try_previous_locales=True) + +The result for a string that is valid in more than one locale, e.g. with a +different date order, then depends on the strings parsed before it. diff --git a/docs/usage.rst b/docs/usage.rst index 3aa9edf0c..e8ca40f4a 100644 --- a/docs/usage.rst +++ b/docs/usage.rst @@ -11,8 +11,7 @@ from the same source. :class:`DateDataParser ` provides an alternate and efficient way to control language detection behavior. -The instance of :class:`DateDataParser ` caches the found -languages and will prioritize them when trying to parse the next string. +See :ref:`performance` for ways to make parsing faster. :class:`dateparser.date.DateDataParser` can also be initialized with known languages: From 49ee527869e122e3465709b39b72421c83c64150 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:55:23 +0200 Subject: [PATCH 073/107] Cover every reachable time span path and drop the unreachable ones (#1393) --- README.rst | 12 +- dateparser/utils/time_spans.py | 96 ++++----------- tests/test_search.py | 219 ++++++++++++++++----------------- 3 files changed, 138 insertions(+), 189 deletions(-) diff --git a/README.rst b/README.rst index 4d2ed7ad2..871e4c562 100644 --- a/README.rst +++ b/README.rst @@ -290,15 +290,17 @@ for other parameters, such as ``strategy``. Time Span Detection ------------------- -The ``search_dates`` function can also detect time spans such as -"past month" or "last week". When ``RETURN_TIME_SPAN`` is enabled it -returns start and end dates for the detected period: +The ``search_dates`` function can also detect time spans such as "past month" +or "last week". When ``RETURN_TIME_SPAN`` is enabled it returns start and end +dates for the detected period. + +For example, assuming the current date and time is `December 7, 2024, 15:30`: .. code:: python >>> search_dates("Messages from the past month", settings={'RETURN_TIME_SPAN': True}) - [('past month (start)', datetime.datetime(2024, 11, 7, 0, 0)), - ('past month (end)', datetime.datetime(2024, 12, 7, 23, 59, 59, 999999))] + [('past month (start)', datetime.datetime(2024, 11, 7, 15, 30)), + ('past month (end)', datetime.datetime(2024, 12, 7, 15, 30))] Settings -------- diff --git a/dateparser/utils/time_spans.py b/dateparser/utils/time_spans.py index fcf7e06be..0099933e5 100644 --- a/dateparser/utils/time_spans.py +++ b/dateparser/utils/time_spans.py @@ -1,26 +1,7 @@ -""" -Utilities for handling time spans and date ranges. -""" - import re -from datetime import datetime, timedelta -from dateutil.relativedelta import relativedelta - - -def get_week_start(date, start_of_week="monday"): - """Get the start of the week for a given date.""" - if start_of_week == "monday": - days_back = date.weekday() - else: # sunday - days_back = (date.weekday() + 1) % 7 +from datetime import timedelta - return date - timedelta(days=days_back) - - -def get_week_end(date, start_of_week="monday"): - """Get the end of the week for a given date.""" - week_start = get_week_start(date, start_of_week) - return week_start + timedelta(days=6) +from dateutil.relativedelta import relativedelta def detect_time_span(text): @@ -97,56 +78,31 @@ def detect_time_span(text): return None -def generate_time_span(span_info, base_date=None, settings=None): - """Generate start and end dates for a time span.""" - if base_date is None: - base_date = datetime.now() - - if settings is None: - start_of_week = "monday" - days_in_month = 30 - else: - start_of_week = getattr(settings, "DEFAULT_START_OF_WEEK", "monday") - days_in_month = getattr(settings, "DEFAULT_DAYS_IN_MONTH", 30) - +def generate_time_span(span_info, base_date, settings): + """Return the start and end dates of the span described by *span_info*.""" span_type = span_info["type"] - direction = span_info["direction"] number = span_info.get("number", 1) - - if direction == "past": - end_date = base_date - - if span_type == "month": - start_date = end_date - relativedelta(days=days_in_month) - elif span_type == "week": - week_start = get_week_start(end_date, start_of_week) - start_date = week_start - timedelta(days=7) - end_date = week_start - timedelta(days=1) - elif span_type == "days": - start_date = end_date - timedelta(days=number) - elif span_type == "weeks": - start_date = end_date - timedelta(weeks=number) - elif span_type == "months": - start_date = end_date - relativedelta(months=number) - else: - start_date = end_date - timedelta(days=1) - + past = span_info["direction"] == "past" + + if span_type == "week": + days_back = base_date.weekday() + if settings.DEFAULT_START_OF_WEEK == "sunday": + days_back = (days_back + 1) % 7 + week_start = base_date - timedelta(days=days_back) + if past: + return week_start - timedelta(days=7), week_start - timedelta(days=1) + start_date = week_start + timedelta(days=7) + return start_date, start_date + timedelta(days=6) + + if span_type == "month": + span = timedelta(days=settings.DEFAULT_DAYS_IN_MONTH) + elif span_type == "days": + span = timedelta(days=number) + elif span_type == "weeks": + span = timedelta(weeks=number) else: - start_date = base_date - - if span_type == "month": - end_date = start_date + relativedelta(days=days_in_month) - elif span_type == "week": - week_start = get_week_start(start_date, start_of_week) - start_date = week_start + timedelta(days=7) - end_date = start_date + timedelta(days=6) - elif span_type == "days": - end_date = start_date + timedelta(days=number) - elif span_type == "weeks": - end_date = start_date + timedelta(weeks=number) - elif span_type == "months": - end_date = start_date + relativedelta(months=number) - else: - end_date = start_date + timedelta(days=1) + span = relativedelta(months=number) - return (start_date, end_date) + if past: + return base_date - span, base_date + return base_date, base_date + span diff --git a/tests/test_search.py b/tests/test_search.py index bfed0520d..365925c8e 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1364,124 +1364,115 @@ def test_search_dates_multi_word_expression( ] self.assertEqual(result, expected) - def test_search_dates_time_span_past_month(self): - """Test search_dates with 'past month' time span.""" - text = "messages received for the past month" - settings = { - "RETURN_TIME_SPAN": True, - "RELATIVE_BASE": datetime.datetime(2025, 2, 15, 12, 0, 0), - "DEFAULT_DAYS_IN_MONTH": 30, - } + # A Tuesday, so that the start of the week is neither the base date itself + # nor the day before it under either DEFAULT_START_OF_WEEK value. + TIME_SPAN_BASE = datetime.datetime(2025, 2, 18, 12, 0) - result = search_dates(text, settings=settings) - - self.assertIsNotNone(result) - self.assertIsInstance(result, list) - if result is not None: - self.assertGreaterEqual(len(result), 2) - - span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] - self.assertEqual(len(span_results), 2) - - start_result = next(r for r in span_results if "(start)" in r[0]) - end_result = next(r for r in span_results if "(end)" in r[0]) - self.assertEqual(end_result[1], datetime.datetime(2025, 2, 15, 12, 0, 0)) - - expected_start = datetime.datetime(2025, 2, 15, 12, 0, 0) - timedelta( - days=30 - ) - self.assertEqual(start_result[1], expected_start) - - def test_search_dates_time_span_last_week(self): - """Test search_dates with 'last week' time span.""" - text = "messages received last week" - settings = { - "RETURN_TIME_SPAN": True, - "RELATIVE_BASE": datetime.datetime(2025, 2, 18, 12, 0, 0), # Tuesday - "DEFAULT_START_OF_WEEK": "monday", - } - - result = search_dates(text, settings=settings) - - self.assertIsNotNone(result) - self.assertIsInstance(result, list) - if result is not None: - self.assertGreaterEqual(len(result), 2) - - span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] - self.assertEqual(len(span_results), 2) - - start_result = next(r for r in span_results if "(start)" in r[0]) - end_result = next(r for r in span_results if "(end)" in r[0]) - expected_start = datetime.datetime(2025, 2, 10, 12, 0, 0) - expected_end = datetime.datetime(2025, 2, 16, 12, 0, 0) - - self.assertEqual(start_result[1], expected_start) - self.assertEqual(end_result[1], expected_end) - - def test_search_dates_time_span_custom_start_of_week(self): - """Test search_dates with custom start_of_week setting.""" - text = "messages received last week" - settings = { - "RETURN_TIME_SPAN": True, - "RELATIVE_BASE": datetime.datetime(2025, 2, 18, 12, 0, 0), # Tuesday - "DEFAULT_START_OF_WEEK": "sunday", # Custom start of week - } - - result = search_dates(text, settings=settings) - self.assertIsNotNone(result) - self.assertIsInstance(result, list) - if result is not None: - self.assertGreaterEqual(len(result), 2) - - span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] - self.assertEqual(len(span_results), 2) - - start_result = next(r for r in span_results if "(start)" in r[0]) - end_result = next(r for r in span_results if "(end)" in r[0]) - expected_start = datetime.datetime(2025, 2, 9, 12, 0, 0) - expected_end = datetime.datetime(2025, 2, 15, 12, 0, 0) - - self.assertEqual(start_result[1], expected_start) - self.assertEqual(end_result[1], expected_end) - - def test_search_dates_time_span_custom_days_in_month(self): - """Test search_dates with custom days_in_month setting.""" - text = "messages received for the past month" - settings = { - "RETURN_TIME_SPAN": True, - "RELATIVE_BASE": datetime.datetime(2025, 2, 15, 12, 0, 0), - "DEFAULT_DAYS_IN_MONTH": 28, # Custom month length - } - - result = search_dates(text, settings=settings) - - self.assertIsNotNone(result) - self.assertIsInstance(result, list) - if result is not None: - self.assertGreaterEqual(len(result), 2) - - span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] - self.assertEqual(len(span_results), 2) - - start_result = next(r for r in span_results if "(start)" in r[0]) - end_result = next(r for r in span_results if "(end)" in r[0]) - self.assertEqual(end_result[1], datetime.datetime(2025, 2, 15, 12, 0, 0)) + @parameterized.expand( + [ + param( + "for the past month", + start=datetime.datetime(2025, 1, 19, 12, 0), + end=datetime.datetime(2025, 2, 18, 12, 0), + ), + param( + "for the past month", + start=datetime.datetime(2025, 1, 21, 12, 0), + end=datetime.datetime(2025, 2, 18, 12, 0), + settings={"DEFAULT_DAYS_IN_MONTH": 28}, + ), + param( + "last week", + start=datetime.datetime(2025, 2, 10, 12, 0), + end=datetime.datetime(2025, 2, 16, 12, 0), + ), + param( + "last week", + start=datetime.datetime(2025, 2, 9, 12, 0), + end=datetime.datetime(2025, 2, 15, 12, 0), + settings={"DEFAULT_START_OF_WEEK": "sunday"}, + ), + param( + "in the past 5 days", + start=datetime.datetime(2025, 2, 13, 12, 0), + end=datetime.datetime(2025, 2, 18, 12, 0), + ), + param( + "previous 3 weeks", + start=datetime.datetime(2025, 1, 28, 12, 0), + end=datetime.datetime(2025, 2, 18, 12, 0), + ), + param( + "during the last 2 months", + start=datetime.datetime(2024, 12, 18, 12, 0), + end=datetime.datetime(2025, 2, 18, 12, 0), + ), + param( + "next month", + start=datetime.datetime(2025, 2, 18, 12, 0), + end=datetime.datetime(2025, 3, 20, 12, 0), + ), + param( + "coming week", + start=datetime.datetime(2025, 2, 24, 12, 0), + end=datetime.datetime(2025, 3, 2, 12, 0), + ), + param( + "coming week", + start=datetime.datetime(2025, 2, 23, 12, 0), + end=datetime.datetime(2025, 3, 1, 12, 0), + settings={"DEFAULT_START_OF_WEEK": "sunday"}, + ), + param( + "in the next 10 days", + start=datetime.datetime(2025, 2, 18, 12, 0), + end=datetime.datetime(2025, 2, 28, 12, 0), + ), + param( + "following 2 weeks", + start=datetime.datetime(2025, 2, 18, 12, 0), + end=datetime.datetime(2025, 3, 4, 12, 0), + ), + param( + "next 6 months", + start=datetime.datetime(2025, 2, 18, 12, 0), + end=datetime.datetime(2025, 8, 18, 12, 0), + ), + ] + ) + def test_search_dates_time_span(self, expression, start, end, settings=None): + result = search_dates( + "messages received " + expression, + languages=["en"], + settings={ + "RETURN_TIME_SPAN": True, + "RELATIVE_BASE": self.TIME_SPAN_BASE, + **(settings or {}), + }, + ) + self.assertEqual( + [item for item in result if item[0].startswith(expression + " (")], + [(expression + " (start)", start), (expression + " (end)", end)], + ) - expected_start = datetime.datetime(2025, 2, 15, 12, 0, 0) - timedelta( - days=28 - ) - self.assertEqual(start_result[1], expected_start) + def test_search_dates_time_span_without_a_span_expression(self): + result = search_dates( + "messages received yesterday", + languages=["en"], + settings={ + "RETURN_TIME_SPAN": True, + "RELATIVE_BASE": self.TIME_SPAN_BASE, + }, + ) + self.assertEqual(result, [("yesterday", datetime.datetime(2025, 2, 17, 12, 0))]) def test_search_dates_time_span_disabled_by_default(self): - """Test that time span functionality is disabled by default.""" - text = "messages received for the past month" - - result = search_dates(text) - - if result: - span_results = [r for r in result if "(start)" in r[0] or "(end)" in r[0]] - self.assertEqual(len(span_results), 0) + result = search_dates( + "messages received for the past month", + languages=["en"], + settings={"RELATIVE_BASE": self.TIME_SPAN_BASE}, + ) + self.assertIsNone(result) class TestNgramSearch(BaseTestCase): From afe7a4c6ccf9d90edd7b00d68d1c2a26cd68384c Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 10:55:42 +0200 Subject: [PATCH 074/107] Parse French Republican calendar dates (#1483) --- README.rst | 18 ++++- dateparser/calendars/french_republican.py | 96 +++++++++++++++++++++++ tests/test_french_republican.py | 73 +++++++++++++++++ 3 files changed, 183 insertions(+), 4 deletions(-) create mode 100644 dateparser/calendars/french_republican.py create mode 100644 tests/test_french_republican.py diff --git a/README.rst b/README.rst index 871e4c562..6135bd218 100644 --- a/README.rst +++ b/README.rst @@ -350,7 +350,7 @@ Dateparser supports Python 3.10+. You can install it by doing: $ pip install dateparser -If you want to use the jalali or hijri calendar, you need to install the +If you want to use a non-Gregorian calendar, you need to install the ``calendars`` extra: :: @@ -360,8 +360,8 @@ If you want to use the jalali or hijri calendar, you need to install the Supported Calendars =================== -Apart from the Gregorian calendar, `dateparser` supports the -`Persian Jalali calendar` and the `Hijri/Islamic calendar`. +Apart from the Gregorian calendar, `dateparser` supports the `Persian Jalali +calendar`, the `Hijri/Islamic calendar` and the `French Republican calendar`. To use them, install the ``calendars`` extra (see `Installation`_). Example using the `Persian Jalali calendar @@ -382,13 +382,23 @@ Example using the `Hijri/Islamic calendar >>> HijriCalendar('17-01-1437 هـ 08:30 مساءً').get_date() DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None) +Example using the `French Republican calendar +`_: + +.. code:: python + + >>> from dateparser.calendars.french_republican import FrenchRepublicanCalendar + >>> FrenchRepublicanCalendar('18 brumaire an VIII').get_date() + DateData(date_obj=datetime.datetime(1799, 11, 9, 0, 0), period='day', locale=None) + Dependencies ============ `dateparser` relies on the following libraries: * dateutil_'s module ``relativedelta`` for its freshness parser. -* convertdate_ to convert *Jalali* dates to *Gregorian*. +* convertdate_ to convert *Jalali* and *French Republican* dates to + *Gregorian*. * hijridate_ to convert *Hijri* dates to *Gregorian*. * tzlocal_ to reliably get local timezone. * ruamel.yaml_ (optional) for operations on language files. diff --git a/dateparser/calendars/french_republican.py b/dateparser/calendars/french_republican.py new file mode 100644 index 000000000..58cc06a38 --- /dev/null +++ b/dateparser/calendars/french_republican.py @@ -0,0 +1,96 @@ +import re +import unicodedata +from datetime import datetime, timezone + +from convertdate import french_republican + +from dateparser.calendars import CalendarBase + +_MONTHS = { + name: index + for index, names in enumerate( + ( + ("vendemiaire",), + ("brumaire",), + ("frimaire",), + ("nivose",), + ("pluviose",), + ("ventose",), + ("germinal",), + ("floreal",), + ("prairial",), + ("messidor",), + ("thermidor",), + ("fructidor",), + ("sansculottides", "sans-culottides", "jours complementaires"), + ), + start=1, + ) + for name in names +} +_RE_DATE = re.compile( + rf"(?:(?:(?P\d{{1,2}})(?:er)?\s+)?(?P{'|'.join(_MONTHS)})\s+)?" + r"an\.?\s+(?:(?P\d{1,3})|(?P" + r"C{0,3}(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})))\.?(?:er|e|eme|me)?\.?", + flags=re.IGNORECASE, +) +_ROMAN_NUMERAL_VALUES = {"C": 100, "L": 50, "X": 10, "V": 5, "I": 1} + + +def _roman_to_int(numeral): + values = [_ROMAN_NUMERAL_VALUES[char] for char in numeral.upper()] + return sum( + -value if value < next_value else value + for value, next_value in zip(values, values[1:] + [0]) + ) + + +def _month_length(year, month): + if month < 13: + return 30 + return 6 if french_republican.leap(year) else 5 + + +class _french_republican_parser: + @classmethod + def parse(cls, datestring, settings): + normalized = "".join( + char + for char in unicodedata.normalize("NFKD", datestring.strip()) + if not unicodedata.combining(char) + ) + match = _RE_DATE.fullmatch(normalized) + if not match or not (match["year"] or match["roman"]): + raise ValueError(datestring) + year = int(match["year"]) if match["year"] else _roman_to_int(match["roman"]) + if not year: + raise ValueError(datestring) + now = settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( + tzinfo=None + ) + _, now_month, now_day = french_republican.from_gregorian( + now.year, now.month, now.day + ) + if match["month"]: + month = _MONTHS[match["month"].lower()] + else: + month = {"first": 1, "last": 13}.get( + settings.PREFER_MONTH_OF_YEAR, now_month + ) + if match["day"]: + day = int(match["day"]) + else: + day = min( + {"first": 1, "last": 30}.get(settings.PREFER_DAY_OF_MONTH, now_day), + _month_length(year, month), + ) + date = datetime(*french_republican.to_gregorian(year, month, day)) + period = "day" if match["day"] else "month" if match["month"] else "year" + return date, period + + +class FrenchRepublicanCalendar(CalendarBase): + """Calendar class for the `French Republican calendar + `_.""" + + parser = _french_republican_parser diff --git a/tests/test_french_republican.py b/tests/test_french_republican.py new file mode 100644 index 000000000..bcf6af774 --- /dev/null +++ b/tests/test_french_republican.py @@ -0,0 +1,73 @@ +import pytest + +pytest.importorskip("convertdate") + +from datetime import datetime + +from parameterized import param, parameterized + +from dateparser.calendars.french_republican import ( + FrenchRepublicanCalendar, + _french_republican_parser, +) +from dateparser.conf import settings +from tests import BaseTestCase + + +class TestFrenchRepublicanCalendar(BaseTestCase): + @parameterized.expand( + [ + param("18 brumaire an VIII", datetime(1799, 11, 9)), + param("1er Vendémiaire an II", datetime(1793, 9, 22)), + param("6 jours complémentaires an iii", datetime(1795, 9, 22)), + param("1 Floréal an. 79", datetime(1871, 4, 21)), + ] + ) + def test_dates(self, date_string, expected): + date_data = FrenchRepublicanCalendar(date_string).get_date() + self.assertEqual(date_data.date_obj, expected) + self.assertEqual(date_data.period, "day") + + @parameterized.expand( + [ + param("An XIV", datetime(1805, 9, 23), "year"), + param("An 3.eme", datetime(1794, 9, 22), "year"), + param("An IVme.", datetime(1795, 9, 23), "year"), + param("Sans-culottides an I", datetime(1793, 9, 17), "month"), + ] + ) + def test_prefer_first(self, date_string, expected, period): + first = settings.replace( + PREFER_DAY_OF_MONTH="first", PREFER_MONTH_OF_YEAR="first" + ) + self.assertEqual( + _french_republican_parser.parse(date_string, first), (expected, period) + ) + + def test_prefer_current(self): + current = settings.replace(RELATIVE_BASE=datetime(2026, 9, 29)) + self.assertEqual( + _french_republican_parser.parse("an VIII", current), + (datetime(1799, 9, 29), "year"), + ) + + def test_prefer_last(self): + last = settings.replace(PREFER_DAY_OF_MONTH="last", PREFER_MONTH_OF_YEAR="last") + self.assertEqual( + _french_republican_parser.parse("an III", last), + (datetime(1795, 9, 22), "year"), + ) + + @parameterized.expand( + [ + param("31 brumaire an VIII"), + param("6 sansculottides an II"), + param("An 0"), + param("An"), + param("An XIIII"), + param("brumaire"), + param("18 brumaire 1799"), + ] + ) + def test_invalid(self, date_string): + self.assertIsNone(FrenchRepublicanCalendar(date_string).get_date()) From 2d06c1cec0bb5f5fd662144a2ff340e3b8675c89 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 11:20:48 +0200 Subject: [PATCH 075/107] Raise a clear error when the local timezone cannot be determined (#1403) --- dateparser/date.py | 4 ++-- dateparser/date_parser.py | 6 ++---- dateparser/freshness_date_parser.py | 10 +++++++--- dateparser/utils/__init__.py | 13 ++++++++++++- tests/test_utils.py | 23 +++++++++++++++++++++++ 5 files changed, 46 insertions(+), 10 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index 3bafddf5e..c9942fdcc 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -5,7 +5,6 @@ import regex as re from dateutil.relativedelta import relativedelta -from tzlocal import get_localzone from dateparser.conf import apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages @@ -15,6 +14,7 @@ from dateparser.parser import _parse_absolute, _parse_nospaces from dateparser.timezone_parser import pop_tz_offset_from_string from dateparser.utils import ( + _get_localzone, _get_missing_parts, apply_timezone_from_settings, get_next_leap_year, @@ -203,7 +203,7 @@ def get_date_from_timestamp(date_string, settings, negative=False): ): # If the timezone in settings is unset, or it's 'local', use the # local timezone - timezone = get_localzone() + timezone = _get_localzone() else: # Otherwise, use the timezone given in settings timezone = get_timezone_from_tz_string(settings.TIMEZONE) diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py index ccba0427b..a23f5e339 100644 --- a/dateparser/date_parser.py +++ b/dateparser/date_parser.py @@ -1,10 +1,8 @@ import sys -from tzlocal import get_localzone - from .conf import apply_settings from .timezone_parser import pop_tz_offset_from_string -from .utils import apply_timezone, localize_timezone, strip_braces +from .utils import _get_localzone, apply_timezone, localize_timezone, strip_braces class DateParser: @@ -33,7 +31,7 @@ def parse(self, date_string, parse_method, settings=None, date_order=None): date_obj = apply_timezone(date_obj, settings.TIMEZONE) else: if "local" in _settings_tz: - stz = get_localzone() + stz = _get_localzone() if hasattr(stz, "localize") and sys.version_info < (3, 6): date_obj = stz.localize(date_obj) else: diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index a96136baf..7ab8eebd4 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -2,9 +2,13 @@ import regex as re from dateutil.relativedelta import relativedelta -from tzlocal import get_localzone -from dateparser.utils import apply_timezone, localize_timezone, strip_braces +from dateparser.utils import ( + _get_localzone, + apply_timezone, + localize_timezone, + strip_braces, +) from .parser import time_parser from .timezone_parser import pop_tz_offset_from_string @@ -35,7 +39,7 @@ def _parse_time(self, date_string, settings): pass def get_local_tz(self): - return get_localzone() + return _get_localzone() def parse(self, date_string, settings): date_string = strip_braces(date_string) diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 9b6678054..e9756ae8f 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -1,5 +1,6 @@ import calendar import logging +import os import threading import types import unicodedata @@ -13,6 +14,16 @@ from dateparser.timezone_parser import StaticTzInfo, _tz_offsets +def _get_localzone(): + try: + return get_localzone() + except ValueError as error: + raise RuntimeError( + f"Could not determine the local timezone " + f"(TZ={os.environ.get('TZ')!r}): {error}" + ) from error + + def strip_braces(date_string): return re.sub(r"[{}()<>\[\]]+", "", date_string) @@ -140,7 +151,7 @@ def apply_timezone(date_time, tz_string): def apply_timezone_from_settings(date_obj, settings): - tz = get_localzone() + tz = _get_localzone() if settings is None: return date_obj diff --git a/tests/test_utils.py b/tests/test_utils.py index 9b71c9b90..515a6e0af 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,12 +1,15 @@ import calendar import itertools from datetime import datetime +from unittest.mock import patch import pytest from parameterized import param, parameterized from pytz import UnknownTimeZoneError, utc +import dateparser from dateparser.conf import settings +from dateparser.search import search_dates from dateparser.utils import ( apply_timezone, apply_timezone_from_settings, @@ -214,3 +217,23 @@ def test_get_previous_leap_year(year, expected_previous_leap_year): ) def test_get_next_leap_year(year, expected_next_leap_year): assert get_next_leap_year(year) == expected_next_leap_year + + +@pytest.mark.parametrize( + "parse", + [ + lambda: dateparser.parse("4 October 1957"), + lambda: dateparser.parse("yesterday"), + lambda: dateparser.parse("1570308760"), + lambda: search_dates("It was launched on 4 October 1957.", languages=["en"]), + ], +) +def test_broken_local_timezone(parse): + with patch( + "dateparser.utils.get_localzone", + side_effect=ValueError("ZoneInfo keys may not be absolute paths"), + ): + with pytest.raises( + RuntimeError, match="Could not determine the local timezone" + ): + parse() From ed396fcfb2cd62013a123bdc9f72b77e1e10837f Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 11:57:35 +0200 Subject: [PATCH 076/107] Upgrade ruff (#1406) --- .pre-commit-config.yaml | 4 +- dateparser/__init__.py | 5 +- dateparser/calendars/__init__.py | 9 +- dateparser/calendars/french_republican.py | 2 +- dateparser/calendars/hijri_parser.py | 13 +- dateparser/calendars/jalali_parser.py | 16 +- dateparser/conf.py | 25 +- .../custom_language_detection/langdetect.py | 8 +- dateparser/date.py | 56 +++-- dateparser/date_parser.py | 13 +- dateparser/freshness_date_parser.py | 46 ++-- dateparser/languages/dictionary.py | 29 ++- dateparser/languages/loader.py | 45 ++-- dateparser/languages/locale.py | 145 +++++------- dateparser/languages/validation.py | 8 +- dateparser/parser.py | 220 ++++++++---------- dateparser/search/__init__.py | 3 +- dateparser/search/detection.py | 10 +- dateparser/search/ngram_search.py | 2 +- dateparser/search/search.py | 29 ++- dateparser/search/text_detection.py | 9 +- dateparser/timezone_parser.py | 5 +- dateparser/utils/__init__.py | 26 +-- dateparser/utils/strptime.py | 34 ++- dateparser_cli/cli.py | 4 +- dateparser_cli/exceptions.py | 2 - dateparser_cli/fasttext_manager.py | 42 ---- dateparser_cli/utils.py | 13 +- dateparser_scripts/get_cldr_data.py | 24 +- dateparser_scripts/order_languages.py | 43 ++-- .../tz_abbreviation_conflicts.py | 11 +- .../update_supported_languages_and_locales.py | 12 +- dateparser_scripts/utils.py | 10 +- dateparser_scripts/write_complete_data.py | 30 ++- docs/conf.py | 7 +- fuzzing/dateparser_fuzzer.py | 11 +- fuzzing/fuzz_helpers.py | 4 +- pyproject.toml | 171 +++++++++++++- setup.py | 5 +- tests/__init__.py | 3 +- tests/test_data.py | 56 ++--- tests/test_date.py | 20 +- tests/test_date_data.py | 11 +- tests/test_date_parser.py | 10 +- tests/test_dateparser_data_integrity.py | 11 +- tests/test_freshness_date_parser.py | 53 ++--- tests/test_hijri.py | 3 +- tests/test_jalali.py | 1 + tests/test_languages.py | 4 +- tests/test_parser.py | 35 ++- tests/test_settings.py | 11 +- tests/test_thread_safety.py | 13 +- tests/test_timezone_parser.py | 3 +- tests/test_utils.py | 30 +-- tests/test_utils_strptime.py | 4 +- 55 files changed, 708 insertions(+), 711 deletions(-) delete mode 100644 dateparser_cli/exceptions.py delete mode 100644 dateparser_cli/fasttext_manager.py diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 12515f933..ec408e775 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,8 +1,8 @@ repos: - repo: https://github.com/astral-sh/ruff-pre-commit - rev: v0.9.3 + rev: v0.16.8 hooks: - - id: ruff + - id: ruff-check args: [ --fix ] - id: ruff-format - repo: https://github.com/zizmorcore/zizmor-pre-commit diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 565965882..f0bc28c3a 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -76,7 +76,4 @@ def parse( detect_languages_function=detect_languages_function, ) - data = parser.get_date_data(date_string, date_formats) - - if data: - return data["date_obj"] + return parser.get_date_data(date_string, date_formats)["date_obj"] diff --git a/dateparser/calendars/__init__.py b/dateparser/calendars/__init__.py index eabb6f5f1..796e9f314 100644 --- a/dateparser/calendars/__init__.py +++ b/dateparser/calendars/__init__.py @@ -72,9 +72,7 @@ def to_latin(cls, source): result = cls._replace_time(result) result = cls._replace_time_conventions(result) - result = result.strip() - - return result + return result.strip() def handle_two_digit_year(self, year): raise ValueError @@ -91,7 +89,7 @@ def _get_datetime_obj(self, **params): year=year, month=month, day=day ) c_params = params.copy() - c_params.update(dict(year=year, month=month, day=day)) + c_params.update({"year": year, "month": month, "day": day}) return datetime(**c_params) def _get_datetime_obj_params(self): @@ -100,7 +98,7 @@ def _get_datetime_obj_params(self): now_year, now_month, now_day = self.calendar_converter.from_gregorian( self.now.year, self.now.month, self.now.day ) - params = { + return { "day": self.day or now_day, "month": self.month or now_month, "year": self.year or now_year, @@ -109,7 +107,6 @@ def _get_datetime_obj_params(self): "second": 0, "microsecond": 0, } - return params def _get_date_obj(self, token, directive): year, month, day = self.default_year, self.default_month, self.default_day diff --git a/dateparser/calendars/french_republican.py b/dateparser/calendars/french_republican.py index 58cc06a38..b986a7d1d 100644 --- a/dateparser/calendars/french_republican.py +++ b/dateparser/calendars/french_republican.py @@ -41,7 +41,7 @@ def _roman_to_int(numeral): values = [_ROMAN_NUMERAL_VALUES[char] for char in numeral.upper()] return sum( -value if value < next_value else value - for value, next_value in zip(values, values[1:] + [0]) + for value, next_value in zip(values, [*values[1:], 0], strict=True) ) diff --git a/dateparser/calendars/hijri_parser.py b/dateparser/calendars/hijri_parser.py index 716d88d4e..5ff47bd2d 100644 --- a/dateparser/calendars/hijri_parser.py +++ b/dateparser/calendars/hijri_parser.py @@ -1,3 +1,5 @@ +from typing import ClassVar + from hijridate import Gregorian, Hijri from dateparser.calendars import non_gregorian_parser @@ -26,12 +28,6 @@ def __init__(self, year, month, day): self.month = month self.day = day - def weekday(self): - for week in hijri.monthcalendar(self.year, self.month): - for idx, day in enumerate(week): - if day == self.day: - return idx - class hijri_parser(non_gregorian_parser): calendar_converter = hijri @@ -40,7 +36,7 @@ class hijri_parser(non_gregorian_parser): default_day = 1 non_gregorian_date_cls = HijriDate - _time_conventions = { + _time_conventions: ClassVar[dict[str, list[str]]] = { "am": ["صباحاً"], "pm": ["مساءً"], } @@ -56,5 +52,4 @@ def _replace_time_conventions(cls, source): def handle_two_digit_year(self, year): if year >= 90: return year + 1300 - else: - return year + 1400 + return year + 1400 diff --git a/dateparser/calendars/jalali_parser.py b/dateparser/calendars/jalali_parser.py index 602493ce4..edfa7e0de 100644 --- a/dateparser/calendars/jalali_parser.py +++ b/dateparser/calendars/jalali_parser.py @@ -1,5 +1,6 @@ import re from functools import reduce +from typing import ClassVar from convertdate import persian @@ -17,6 +18,7 @@ def weekday(self): for idx, day in enumerate(week): if day == self.day: return idx + return None class jalali_parser(non_gregorian_parser): @@ -26,7 +28,7 @@ class jalali_parser(non_gregorian_parser): default_day = 1 non_gregorian_date_cls = PersianDate - _digits = { + _digits: ClassVar[dict[str, int]] = { "۰": 0, "۱": 1, "۲": 2, @@ -39,7 +41,7 @@ class jalali_parser(non_gregorian_parser): "۹": 9, } - _months = { + _months: ClassVar[dict[str, tuple[int, int, list[str]]]] = { # pinglish : (persian literals, month index, number of days) "Farvardin": (1, 31, ["فروردین"]), "Ordibehesht": (2, 31, ["اردیبهشت"]), @@ -55,7 +57,7 @@ class jalali_parser(non_gregorian_parser): "Esfand": (12, 29, ["اسفند"]), } - _weekdays = { + _weekdays: ClassVar[dict[str, list[str]]] = { "Sunday": ["یکشنبه"], "Monday": ["دوشنبه"], "Tuesday": ["سهشنبه", "سه شنبه"], @@ -65,7 +67,7 @@ class jalali_parser(non_gregorian_parser): "Saturday": ["روز شنبه", "شنبه"], } - _number_letters = { + _number_letters: ClassVar[dict[int, list[str]]] = { 0: ["صفر"], 1: ["یک", "اول"], 2: ["دو"], @@ -146,8 +148,7 @@ def only_numbers(match_obj): result = re.sub(minute_pattern, only_numbers, result) result = re.sub(second_pattern, only_numbers, result) result = re.sub(r"\s+و\s+", ":", result) - result = result.replace("ساعت", "") - return result + return result.replace("ساعت", "") @classmethod def _replace_days(cls, source): @@ -175,5 +176,4 @@ def comp_key(tup): def handle_two_digit_year(self, year): if year > 60: return year + 1300 - else: - return year + 1400 + return year + 1400 diff --git a/dateparser/conf.py b/dateparser/conf.py index fb533fa76..f02330a6e 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -1,6 +1,9 @@ import hashlib +from collections.abc import Mapping from datetime import datetime from functools import wraps +from types import MappingProxyType +from typing import Any from dateparser.data.languages_info import language_order @@ -40,7 +43,7 @@ class Settings: _default = True _pyfile_data = None - _mod_settings = dict() + _mod_settings: Mapping[str, Any] = MappingProxyType({}) def __init__(self, settings=None): if settings: @@ -53,7 +56,7 @@ def get_key(cls, settings=None): if not settings: return "default" - keys = sorted(["%s-%s" % (key, str(settings[key])) for key in settings]) + keys = sorted([f"{key}-{settings[key]}" for key in settings]) return hashlib.md5( "".join(keys).encode("utf-8"), usedforsecurity=False ).hexdigest() @@ -61,7 +64,7 @@ def get_key(cls, settings=None): @classmethod def _get_settings_from_pyfile(cls): if not cls._pyfile_data: - from dateparser_data import settings + from dateparser_data import settings # noqa: PLC0415 cls._pyfile_data = settings.settings return cls._pyfile_data @@ -73,9 +76,9 @@ def _updateall(self, iterable): def replace(self, mod_settings=None, **kwds): for k, v in kwds.items(): if v is None: - raise TypeError('Invalid {{"{}": {}}}'.format(k, v)) + raise TypeError(f'Invalid {{"{k}": {v}}}') - for x in self._get_settings_from_pyfile().keys(): + for x in self._get_settings_from_pyfile(): kwds.setdefault(x, getattr(self, x)) kwds["_default"] = False @@ -116,9 +119,8 @@ class SettingValidationError(ValueError): def _check_repeated_values(setting_name, setting_value): if len(setting_value) != len(set(setting_value)): raise SettingValidationError( - 'There are repeated values in the "{}" setting'.format(setting_name) + f'There are repeated values in the "{setting_name}" setting' ) - return def _check_require_part(setting_name, setting_value): @@ -168,11 +170,8 @@ def _check_between_0_and_1(setting_name, setting_value): is_valid = 0 <= setting_value <= 1 if not is_valid: raise SettingValidationError( - "{} is not a valid value for {}. It can take values between 0 and " - "1.".format( - setting_value, - setting_name, - ) + f"{setting_value} is not a valid value for {setting_name}. It can take " + "values between 0 and 1." ) @@ -253,7 +252,7 @@ def check_settings(settings): # check settings keys: for setting in modified_settings: if setting not in settings_values: - raise SettingValidationError('"{}" is not a valid setting'.format(setting)) + raise SettingValidationError(f'"{setting}" is not a valid setting') for setting_name, setting_value in modified_settings.items(): setting_type = type(setting_value) diff --git a/dateparser/custom_language_detection/langdetect.py b/dateparser/custom_language_detection/langdetect.py index d105631e7..e885a4936 100644 --- a/dateparser/custom_language_detection/langdetect.py +++ b/dateparser/custom_language_detection/langdetect.py @@ -27,9 +27,11 @@ def detect_languages(text, confidence_threshold): language_codes = [] try: parser_data = _get_language_probablities(text) - for language_candidate in parser_data: - if language_candidate.prob > confidence_threshold: - language_codes.append(language_candidate.lang) + language_codes.extend( + language_candidate.lang + for language_candidate in parser_data + if language_candidate.prob > confidence_threshold + ) except langdetect.lang_detect_exception.LangDetectException: # This exception can be produced with empty strings or inputs without letters like `10-10-2021`. # As this could be really common, we ignore them. diff --git a/dateparser/date.py b/dateparser/date.py index c9942fdcc..a4cb01908 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -1,6 +1,6 @@ import collections import threading -from collections.abc import Set +from collections.abc import Set as AbstractSet from datetime import datetime, timedelta, timezone import regex as re @@ -99,8 +99,7 @@ def sanitize_spaces(date_string): date_string = RE_NBSP.sub(" ", date_string) date_string = RE_SPACES.sub(" ", date_string) - date_string = RE_TRIM_SPACES.sub(r"\1", date_string) - return date_string + return RE_TRIM_SPACES.sub(r"\1", date_string) def date_range(begin, end, **kwargs): @@ -115,7 +114,7 @@ def date_range(begin, end, **kwargs): ] for arg in dateutil_error_prone_args: if arg in kwargs: - raise ValueError("Invalid argument: %s" % arg) + raise ValueError(f"Invalid argument: {arg}") step = relativedelta(**kwargs) if kwargs else relativedelta(days=1) @@ -140,7 +139,7 @@ def get_intersecting_periods(low, high, period="day"): "second", "microsecond", ]: - raise ValueError("Invalid period: {}".format(period)) + raise ValueError(f"Invalid period: {period}") if high <= low: return @@ -185,8 +184,7 @@ def sanitize_date(date_string): date_string = RE_TRIM_COLONS.sub(r"\1", date_string) date_string = RE_SANITIZE_APOSTROPHE.sub("'", date_string) date_string = RE_SANITIZE_DASH.sub("-", date_string) - date_string = date_string.strip() - return date_string + return date_string.strip() def get_date_from_timestamp(date_string, settings, negative=False): @@ -214,8 +212,8 @@ def get_date_from_timestamp(date_string, settings, negative=False): date_obj = datetime.fromtimestamp(seconds, timezone).replace( microsecond=millis * 1000 + micros, tzinfo=None ) - date_obj = apply_timezone_from_settings(date_obj, settings) - return date_obj + return apply_timezone_from_settings(date_obj, settings) + return None def _apply_century_preference(date_obj, now, prefer_from): @@ -291,8 +289,7 @@ def parse_with_formats(date_string, date_formats, settings): date_obj = apply_timezone_from_settings(date_obj, settings) return DateData(date_obj=date_obj, period=period) - else: - return DateData(date_obj=None, period=period) + return DateData(date_obj=None, period=period) class _DateLocaleParser: @@ -305,7 +302,9 @@ def __init__( ignore_surrounding_text=False, ): self._settings = settings - if not (date_formats is None or isinstance(date_formats, (list, tuple, Set))): + if not ( + date_formats is None or isinstance(date_formats, (list, tuple, AbstractSet)) + ): raise TypeError("Date formats should be list, tuple or set of strings") self.locale = locale @@ -342,8 +341,7 @@ def _parse(self): date_data = self._parsers[parser_name]() if self._is_valid_date_data(date_data): return date_data - else: - return None + return None def _try_timestamp_parser(self, negative=False): return DateData( @@ -416,7 +414,7 @@ def _try_parser(self, parse_method): def _try_given_formats(self): if not self.date_formats: - return + return None return parse_with_formats( self._get_translated_date_with_formatting(), @@ -451,9 +449,7 @@ def _is_valid_date_data(self, date_data): return False if date_data["date_obj"] and not isinstance(date_data["date_obj"], datetime): return False - if date_data["period"] not in ("time", "day", "week", "month", "year"): - return False - return True + return date_data["period"] in ("time", "day", "week", "month", "year") class DateData: @@ -479,10 +475,10 @@ def __setitem__(self, k, v): def __repr__(self): properties_text = ", ".join( - "{}={}".format(prop, val.__repr__()) for prop, val in self.__dict__.items() + f"{prop}={val!r}" for prop, val in self.__dict__.items() ) - return "{}({})".format(self.__class__.__name__, properties_text) + return f"{self.__class__.__name__}({properties_text})" class DateDataParser: @@ -548,29 +544,29 @@ def __init__( settings=None, detect_languages_function=None, ): - if languages is not None and not isinstance(languages, (list, tuple, Set)): + if languages is not None and not isinstance( + languages, (list, tuple, AbstractSet) + ): raise TypeError( - "languages argument must be a list (%r given)" % type(languages) + f"languages argument must be a list ({type(languages)!r} given)" ) - if locales is not None and not isinstance(locales, (list, tuple, Set)): + if locales is not None and not isinstance(locales, (list, tuple, AbstractSet)): raise TypeError( - "locales argument must be a list (%r given)" % type(locales) + f"locales argument must be a list ({type(locales)!r} given)" ) if region is not None and not isinstance(region, str): - raise TypeError("region argument must be str (%r given)" % type(region)) + raise TypeError(f"region argument must be str ({type(region)!r} given)") if not isinstance(try_previous_locales, bool): raise TypeError( - "try_previous_locales argument must be a boolean (%r given)" - % type(try_previous_locales) + f"try_previous_locales argument must be a boolean ({type(try_previous_locales)!r} given)" ) if not isinstance(use_given_order, bool): raise TypeError( - "use_given_order argument must be a boolean (%r given)" - % type(use_given_order) + f"use_given_order argument must be a boolean ({type(use_given_order)!r} given)" ) if not locales and not languages and use_given_order: @@ -680,7 +676,7 @@ def _parse_using_applicable_locales( def get_date_tuple(self, *args, **kwargs): date_data = self.get_date_data(*args, **kwargs) fields = date_data.__dict__.keys() - date_tuple = collections.namedtuple("DateData", fields) + date_tuple = collections.namedtuple("DateData", fields) # noqa: PYI024 return date_tuple(**date_data.__dict__) def _get_applicable_locales(self, date_string, ignore_surrounding_text=False): diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py index a23f5e339..c650db7e2 100644 --- a/dateparser/date_parser.py +++ b/dateparser/date_parser.py @@ -1,5 +1,3 @@ -import sys - from .conf import apply_settings from .timezone_parser import pop_tz_offset_from_string from .utils import _get_localzone, apply_timezone, localize_timezone, strip_braces @@ -29,15 +27,10 @@ def parse(self, date_string, parse_method, settings=None, date_order=None): date_obj = date_obj.replace(tzinfo=ptz) if "local" not in _settings_tz: date_obj = apply_timezone(date_obj, settings.TIMEZONE) + elif "local" in _settings_tz: + date_obj = date_obj.replace(tzinfo=_get_localzone()) else: - if "local" in _settings_tz: - stz = _get_localzone() - if hasattr(stz, "localize") and sys.version_info < (3, 6): - date_obj = stz.localize(date_obj) - else: - date_obj = date_obj.replace(tzinfo=stz) - else: - date_obj = localize_timezone(date_obj, settings.TIMEZONE) + date_obj = localize_timezone(date_obj, settings.TIMEZONE) if settings.TO_TIMEZONE: date_obj = apply_timezone(date_obj, settings.TO_TIMEZONE) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 7ab8eebd4..e682c0b93 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -1,3 +1,4 @@ +import contextlib from datetime import datetime, time, timezone import regex as re @@ -14,11 +15,11 @@ from .timezone_parser import pop_tz_offset_from_string _UNITS = r"decade|year|month|week|day|hour|minute|second" -PATTERN = re.compile(r"([+-]?\s*\d++[.,]?\d*+)\s*(%s)\b" % _UNITS, re.I | re.S | re.U) +PATTERN = re.compile(rf"([+-]?\s*\d++[.,]?\d*+)\s*({_UNITS})\b", re.I | re.S | re.U) class FreshnessDateDataParser: - """Parses date string like "1 year, 2 months ago" and "3 hours, 50 minutes ago" """ + """Parses date string like "1 year, 2 months ago" and "3 hours, 50 minutes ago".""" def _are_all_words_units(self, date_string): skip = [_UNITS, r"ago|in|\d+", r":|[ap]m"] @@ -26,22 +27,20 @@ def _are_all_words_units(self, date_string): date_string = re.sub(r"\s+", " ", date_string.strip()) words = [x for x in re.split(r"\W", date_string) if x] - words = [x for x in words if not re.match(r"%s" % "|".join(skip), x)] + words = [x for x in words if not re.match("|".join(skip), x)] return not words def _parse_time(self, date_string, settings): """Attempts to parse time part of date strings like '1 day ago, 2 PM'""" date_string = PATTERN.sub("", date_string) date_string = re.sub(r"\b(?:ago|in)\b", "", date_string) - try: + with contextlib.suppress(Exception): return time_parser(date_string) - except Exception: - pass def get_local_tz(self): return _get_localzone() - def parse(self, date_string, settings): + def parse(self, date_string, settings): # noqa: PLR0912 date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) _time = self._parse_time(date_string, settings) @@ -66,13 +65,7 @@ def apply_time(dateobj, timeobj): now = localize_timezone(now, settings.TIMEZONE) if ptz: - if now.tzinfo: - now = now.astimezone(ptz) - else: - if hasattr(ptz, "localize"): - now = ptz.localize(now) - else: - now = now.replace(tzinfo=ptz) + now = now.astimezone(ptz) if now.tzinfo else ptz.localize(now) if not now.tzinfo: now = now.replace(tzinfo=self.get_local_tz()) @@ -85,12 +78,11 @@ def apply_time(dateobj, timeobj): else: now = apply_timezone(localized_now, settings.TIMEZONE) + elif "local" not in _settings_tz: + utc_dt = datetime.now(tz=timezone.utc) + now = apply_timezone(utc_dt, settings.TIMEZONE) else: - if "local" not in _settings_tz: - utc_dt = datetime.now(tz=timezone.utc) - now = apply_timezone(utc_dt, settings.TIMEZONE) - else: - now = datetime.now(self.get_local_tz()) + now = datetime.now(self.get_local_tz()) date, period = self._parse_date(date_string, now, settings.PREFER_DATES_FROM) @@ -132,21 +124,17 @@ def _parse_date(self, date_string, now, prefer_dates_from): period = "year" if k == "decades" else k[:-1] break - going_forward = ( - re.search(r"\bin\b", date_string) - or re.search(r"\bfuture\b", prefer_dates_from) + going_forward = re.search(r"\bin\b", date_string) or ( + re.search(r"\bfuture\b", prefer_dates_from) and not re.search(r"\bago\b", date_string) ) adjusted_kwargs = {} for key, value in kwargs.items(): - if explicit_signs.get(key, False): + if explicit_signs.get(key, False) or going_forward: adjusted_kwargs[key] = value else: - if going_forward: - adjusted_kwargs[key] = value - else: - adjusted_kwargs[key] = -value + adjusted_kwargs[key] = -value # Fold ``decades`` into ``years`` after each component's sign has been # resolved so that an unsigned component combined with an explicitly @@ -172,14 +160,14 @@ def get_kwargs(self, date_string): explicit_signs = {} for num, unit in m: - has_explicit_sign = num.startswith("+") or num.startswith("-") + has_explicit_sign = num.startswith(("+", "-")) explicit_signs[unit + "s"] = has_explicit_sign kwargs[unit + "s"] = float(num.replace(",", ".").replace(" ", "")) return kwargs, explicit_signs def get_date_data(self, date_string, settings=None): - from dateparser.date import DateData + from dateparser.date import DateData # noqa: PLC0415 date, period = self.parse(date_string, settings) return DateData(date_obj=date, period=period) diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index dbba8a14b..1b8993531 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -1,6 +1,7 @@ import threading from itertools import chain, zip_longest from operator import methodcaller +from typing import ClassVar import regex as re @@ -9,7 +10,7 @@ PARSER_HARDCODED_TOKENS = [":", ".", " ", "-", "/"] PARSER_KNOWN_TOKENS = ["am", "pm", "UTC", "GMT", "Z"] -ALWAYS_KEEP_TOKENS = ["+"] + PARSER_HARDCODED_TOKENS +ALWAYS_KEEP_TOKENS = ["+", *PARSER_HARDCODED_TOKENS] KNOWN_WORD_TOKENS = [ "monday", "tuesday", @@ -79,11 +80,11 @@ class Dictionary: :return: a Dictionary instance. """ - _split_regex_cache = {} - _sorted_words_cache = {} - _split_relative_regex_cache = {} - _sorted_relative_strings_cache = {} - _match_relative_regex_cache = {} + _split_regex_cache: ClassVar[dict[str, dict[str, re.Pattern[str]]]] = {} + _sorted_words_cache: ClassVar[dict[str, dict[str, list[str]]]] = {} + _split_relative_regex_cache: ClassVar[dict[str, dict[str, re.Pattern[str]]]] = {} + _sorted_relative_strings_cache: ClassVar[dict[str, dict[str, list[str]]]] = {} + _match_relative_regex_cache: ClassVar[dict[str, dict[str, re.Pattern[str]]]] = {} # The caches above are shared across all Dictionary instances and threads. # The lock keeps each check-populate-evict-read sequence atomic, so a @@ -349,7 +350,7 @@ def _get_sorted_words_from_cache(self): ): self._add_to_cache( cache=self._sorted_words_cache, - value=sorted([key for key in self], key=len, reverse=True), + value=sorted(self, key=len, reverse=True), ) return self._sorted_words_cache[self._settings.registry_key][ self.info["name"] @@ -372,11 +373,9 @@ def _construct_split_regex(self): map(re.escape, self._get_sorted_words_from_cache()) ) if self._no_word_spacing: - regex = r"^(.*?)({})(.*)$".format(known_words_group) + regex = rf"^(.*?)({known_words_group})(.*)$" else: - regex = r"^(.*?(?:\A|\W|_|\d))({})((?:\Z|\W|_|\d).*)$".format( - known_words_group - ) + regex = rf"^(.*?(?:\A|\W|_|\d))({known_words_group})((?:\Z|\W|_|\d).*)$" self._add_to_cache( cache=self._split_regex_cache, value=re.compile(regex, re.UNICODE | re.IGNORECASE), @@ -421,10 +420,10 @@ def _construct_split_relative_regex(self): self._get_sorted_relative_strings_from_cache() ) if self._no_word_spacing: - regex = "({})".format(known_relative_strings_group) + regex = f"({known_relative_strings_group})" else: - regex = "(?<=(?:\\A|\\W|_))({})(?=(?:\\Z|\\W|_))".format( - known_relative_strings_group + regex = ( + f"(?<=(?:\\A|\\W|_))({known_relative_strings_group})(?=(?:\\Z|\\W|_))" ) self._add_to_cache( cache=self._split_relative_regex_cache, @@ -447,7 +446,7 @@ def _construct_match_relative_regex(self): known_relative_strings_group = "|".join( self._get_sorted_relative_strings_from_cache() ) - regex = "^({})$".format(known_relative_strings_group) + regex = f"^({known_relative_strings_group})$" self._add_to_cache( cache=self._match_relative_regex_cache, value=re.compile(regex, re.UNICODE | re.IGNORECASE), diff --git a/dateparser/languages/loader.py b/dateparser/languages/loader.py index 138340a7c..56a4ee90e 100644 --- a/dateparser/languages/loader.py +++ b/dateparser/languages/loader.py @@ -3,10 +3,12 @@ from copy import deepcopy from importlib import import_module from itertools import zip_longest +from typing import Any, ClassVar import regex as re -from ..data import language_locale_dict, language_order +from dateparser.data import language_locale_dict, language_order + from .locale import Locale LOCALE_SPLIT_PATTERN = re.compile(r"-(?=[A-Z0-9]+$)") @@ -16,12 +18,8 @@ def _isvalidlocale(locale): language = LOCALE_SPLIT_PATTERN.split(locale)[0] if language not in language_order: return False - else: - locales_list = language_locale_dict[language] - if locale == language or locale in locales_list: - return True - else: - return False + locales_list = language_locale_dict[language] + return locale == language or locale in locales_list def _filter_valid_locales(locales): @@ -40,8 +38,8 @@ def _construct_locales(languages, region): class LocaleDataLoader: """Class that handles loading of locale instances.""" - _loaded_languages = {} - _loaded_locales = {} + _loaded_languages: ClassVar[dict[str, dict[str, Any]]] = {} + _loaded_locales: ClassVar[dict[str, Locale]] = {} _load_lock = threading.Lock() def get_locale_map( @@ -150,9 +148,9 @@ def get_locale(self, shortname): :return: locale instance """ - return list(self.get_locales(locales=[shortname]))[0] + return next(iter(self.get_locales(locales=[shortname]))) - def _load_data( + def _load_data( # noqa: PLR0912 self, languages=None, locales=None, @@ -172,14 +170,15 @@ def _load_data( invalid_locales.append(locale) if invalid_locales: raise ValueError( - "Unknown locale(s): %s" % ", ".join(map(repr, invalid_locales)) + f"Unknown locale(s): {', '.join(map(repr, invalid_locales))}" ) - if not allow_conflicting_locales: - if len(set(locales)) > len({t[0] for t in locale_dict.values()}): - raise ValueError( - "Locales should not have same language and different region" - ) + if not allow_conflicting_locales and len(set(locales)) > len( + {t[0] for t in locale_dict.values()} + ): + raise ValueError( + "Locales should not have same language and different region" + ) else: if languages is None: @@ -187,8 +186,7 @@ def _load_data( unsupported_languages = set(languages) - set(language_order) if unsupported_languages: raise ValueError( - "Unknown language(s): %s" - % ", ".join(map(repr, unsupported_languages)) + f"Unknown language(s): {', '.join(map(repr, unsupported_languages))}" ) if region is None: region = "" @@ -207,19 +205,18 @@ def _load_data( for shortname, lang_reg in locale_dict.items(): with self._load_lock: if shortname not in self._loaded_locales: - lang, reg = lang_reg + lang, _reg = lang_reg if lang in self._loaded_languages: locale = Locale( shortname, language_info=deepcopy(self._loaded_languages[lang]), ) else: - language_info = getattr( + language_info = ( import_module( "dateparser.data.date_translation_data." + lang - ), - "info", - ) + ) + ).info locale = Locale( shortname, language_info=deepcopy(language_info) ) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index dd3bed76f..4c5316f12 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -132,15 +132,12 @@ def _count_words_present_in_the_dictionary(self, words, settings=None): @staticmethod def clean_dictionary(dictionary, threshold=2): - del_keys = [] - for key in dictionary: - if len(key) < threshold: - del_keys.append(key) + del_keys = [key for key in dictionary if len(key) < threshold] for del_key in del_keys: del dictionary[del_key] return dictionary - def translate( + def translate( # noqa: PLR0912 self, date_string, keep_formatting=False, @@ -188,8 +185,8 @@ def translate( for token in date_string_tokens ) - for i, word in enumerate(date_string_tokens): - word = word.lower() + for i, token in enumerate(date_string_tokens): + word = token.lower() for pattern, replacement in relative_translations.items(): if pattern.match(word): date_string_tokens[i] = pattern.sub(replacement, word) @@ -237,8 +234,7 @@ def translate( # Add back the maximum number of spaces max_spaces = max(prev_spaces, next_spaces) - for _ in range(max_spaces): - filtered_tokens.append(" ") + filtered_tokens.extend(" " * max_spaces) # Skip the empty token and all following spaces i += next_spaces + 1 @@ -271,28 +267,24 @@ def _get_relative_translations(self, settings=None): self._generate_relative_translations(normalize=True) ) return self._normalized_relative_translations - else: - if self._relative_translations is None: - self._relative_translations = self._generate_relative_translations( - normalize=False - ) - return self._relative_translations + if self._relative_translations is None: + self._relative_translations = self._generate_relative_translations( + normalize=False + ) + return self._relative_translations def _generate_relative_translations(self, normalize=False): relative_translations = self.info.get("relative-type-regex", {}) relative_dictionary = {} for key, value in relative_translations.items(): - if normalize: - value = list(map(normalize_unicode, value)) - pattern = "|".join(sorted(value, key=len, reverse=True)) + translations = map(normalize_unicode, value) if normalize else value + pattern = "|".join(sorted(translations, key=len, reverse=True)) pattern = pattern.replace(r"(\d+", r"(?P\d+") - pattern = re.compile( - r"^(?:{})$".format(pattern), re.UNICODE | re.IGNORECASE - ) + pattern = re.compile(rf"^(?:{pattern})$", re.UNICODE | re.IGNORECASE) relative_dictionary[pattern] = key return relative_dictionary - def translate_search(self, search_string, settings=None): + def translate_search(self, search_string, settings=None): # noqa: PLR0912 dashes = ["-", "——", "—", "~"] word_joint_unsupported_languages = ["zh", "ja"] sentences = self._sentence_split(search_string, settings=settings) @@ -316,7 +308,7 @@ def translate_search(self, search_string, settings=None): skip_next_token = False continue - if word == "" or word == " ": + if word in {"", " "}: translated_chunk.append(word) original_chunk.append(original_tokens[i]) elif ( @@ -343,19 +335,16 @@ def translate_search(self, search_string, settings=None): else: translated_chunk.append(dictionary[bare_word]) original_chunk.append(original_tokens[i]) - elif self._token_with_digits_is_ok(word): - translated_chunk.append(word) - original_chunk.append(original_tokens[i]) - # Use original token because word_is_tz is case sensitive - elif translated_chunk and word_is_tz(original_tokens[i]): + elif self._token_with_digits_is_ok(word) or ( + translated_chunk and word_is_tz(original_tokens[i]) + ): translated_chunk.append(word) original_chunk.append(original_tokens[i]) - else: - if translated_chunk: - translated.append(translated_chunk) - translated_chunk = [] - original.append(original_chunk) - original_chunk = [] + elif translated_chunk: + translated.append(translated_chunk) + translated_chunk = [] + original.append(original_chunk) + original_chunk = [] if translated_chunk: translated.append(translated_chunk) original.append(original_chunk) @@ -374,11 +363,9 @@ def _get_abbreviations(self, settings): dictionary = self._get_dictionary(settings=settings) with self._lock: if self._abbreviations is None: - abbreviations = [] - for item in dictionary: - if item.endswith(".") and len(item) > 1: - abbreviations.append(item) - self._abbreviations = abbreviations + self._abbreviations = [ + item for item in dictionary if item.endswith(".") and len(item) > 1 + ] return self._abbreviations def _sentence_split(self, string, settings): @@ -415,10 +402,9 @@ def _sentence_split(self, string, settings): ) sentences = re.split(split_reg, string) - sentences = filter(None, sentences) - return sentences + return filter(None, sentences) - def _simplify_split_align(self, original, settings): + def _simplify_split_align(self, original, settings): # noqa: PLR0912 # TODO: Switch to new split method. original_tokens = self._word_split(original, settings=settings) simplified_tokens = self._word_split( @@ -428,18 +414,17 @@ def _simplify_split_align(self, original, settings): if len(original_tokens) == len(simplified_tokens): return original_tokens, simplified_tokens - elif len(original_tokens) < len(simplified_tokens): + if len(original_tokens) < len(simplified_tokens): add_empty = False for i, token in enumerate(simplified_tokens): if i < len(original_tokens): if token == normalize_unicode(original_tokens[i].lower()): add_empty = False + elif not add_empty: + add_empty = True + continue else: - if not add_empty: - add_empty = True - continue - else: - original_tokens.insert(i, "") + original_tokens.insert(i, "") else: original_tokens.insert(i, "") else: @@ -448,12 +433,11 @@ def _simplify_split_align(self, original, settings): if i < len(simplified_tokens): if normalize_unicode(token.lower()) == simplified_tokens[i]: add_empty = False + elif not add_empty: + add_empty = True + continue else: - if not add_empty: - add_empty = True - continue - else: - simplified_tokens.insert(i, "") + simplified_tokens.insert(i, "") else: simplified_tokens.insert(i, "") @@ -489,18 +473,16 @@ def _split_dict(self, dictionary): def _word_split(self, string, settings): if "no_word_spacing" in self.info: return self._split(string, keep_formatting=True, settings=settings) - else: - return string.split() + return string.split() def _split(self, date_string, keep_formatting, settings=None): tokens = [date_string] tokens = list(self._split_tokens_with_regex(tokens, r"(\d+)")) - tokens = list( + return list( self._split_tokens_by_known_words( tokens, keep_formatting, settings=settings ) ) - return tokens def _split_tokens_with_regex(self, tokens, regex): tokens = tokens[:] @@ -517,21 +499,13 @@ def _split_tokens_by_known_words(self, tokens, keep_formatting, settings=None): def _join_chunk(self, chunk, settings): if "no_word_spacing" in self.info: return self._join(chunk, separator="", settings=settings) - else: - return re.sub(r"\s{2,}", " ", " ".join(chunk)) + return re.sub(r"\s{2,}", " ", " ".join(chunk)) def _token_with_digits_is_ok(self, token): if "no_word_spacing" in self.info: - if re.search(r"[\d\.:\-/]+", token) is not None: - return True - else: - return False + return re.search(r"[\d\.:\-/]+", token) is not None - else: - if re.search(r"\d+", token) is not None: - return True - else: - return False + return re.search(r"\d+", token) is not None def _simplify(self, date_string, settings=None): date_string = date_string.lower() @@ -548,7 +522,7 @@ def _simplify(self, date_string, settings=None): def _apply_simplifications(self, date_string, simplifications): for simplification in simplifications: - pattern, replacement = list(simplification.items())[0] + pattern, replacement = next(iter(simplification.items())) date_string = pattern.sub(replacement, date_string).lower() return date_string @@ -565,9 +539,7 @@ def replace_number_pairs(match): return match.group(0) number_pair_pattern = r"\b(\d+)\s+(\d+)\b" - date_string = re.sub(number_pair_pattern, replace_number_pairs, date_string) - - return date_string + return re.sub(number_pair_pattern, replace_number_pairs, date_string) def _get_simplifications(self, settings=None): no_word_spacing = _parse_bool(self.info.get("no_word_spacing", False)) @@ -577,9 +549,9 @@ def _get_simplifications(self, settings=None): normalized_simplifications = [] simplifications = self._generate_simplifications(normalize=True) for simplification in simplifications: - pattern, replacement = list(simplification.items())[0] + pattern, replacement = next(iter(simplification.items())) if not no_word_spacing: - pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern + pattern = rf"(?<=\A|\W|_){pattern}(?=\Z|\W|_)" pattern = re.compile(pattern, flags=re.I | re.U) normalized_simplifications.append({pattern: replacement}) # Assign only once fully built so other threads never observe @@ -587,24 +559,23 @@ def _get_simplifications(self, settings=None): self._normalized_simplifications = normalized_simplifications return self._normalized_simplifications - else: - if self._simplifications is None: - simplifications_built = [] - simplifications = self._generate_simplifications(normalize=False) - for simplification in simplifications: - pattern, replacement = list(simplification.items())[0] - if not no_word_spacing: - pattern = r"(?<=\A|\W|_)%s(?=\Z|\W|_)" % pattern - pattern = re.compile(pattern, flags=re.I | re.U) - simplifications_built.append({pattern: replacement}) - self._simplifications = simplifications_built - return self._simplifications + if self._simplifications is None: + simplifications_built = [] + simplifications = self._generate_simplifications(normalize=False) + for simplification in simplifications: + pattern, replacement = next(iter(simplification.items())) + if not no_word_spacing: + pattern = rf"(?<=\A|\W|_){pattern}(?=\Z|\W|_)" + pattern = re.compile(pattern, flags=re.I | re.U) + simplifications_built.append({pattern: replacement}) + self._simplifications = simplifications_built + return self._simplifications def _generate_simplifications(self, normalize=False): simplifications = [] for simplification in self.info.get("simplifications", []): c_simplification = {} - key, value = list(simplification.items())[0] + key, value = next(iter(simplification.items())) if normalize: key = normalize_unicode(key) diff --git a/dateparser/languages/validation.py b/dateparser/languages/validation.py index 3b4233869..2c57f281d 100644 --- a/dateparser/languages/validation.py +++ b/dateparser/languages/validation.py @@ -1,3 +1,5 @@ +from typing import ClassVar + import regex as re from dateparser.utils import get_logger @@ -6,7 +8,7 @@ class LanguageValidator: logger = None - VALID_KEYS = [ + VALID_KEYS: ClassVar[list[str]] = [ "name", "skip", "pertain", @@ -380,7 +382,7 @@ def _validate_simplifications(cls, language_id, info): result = False continue - key, value = list(simplification.items())[0] + key, value = next(iter(simplification.items())) if not isinstance(key, str) or not isinstance(value, (str, int)): cls.get_logger().error( "Invalid simplification %(simplification)r for '%(id)s' language: " @@ -414,7 +416,7 @@ def _validate_simplifications(cls, language_id, info): result = False used_groups = set(map(int, groups)) - expected_groups = set(range(0, compiled_key.groups + 1)) + expected_groups = set(range(compiled_key.groups + 1)) extra_groups = used_groups - expected_groups not_used_groups = expected_groups - used_groups not_used_groups -= {0} # Entire substring is not required to be used diff --git a/dateparser/parser.py b/dateparser/parser.py index 74cf14518..61fa7d4b7 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -1,6 +1,8 @@ import calendar +import contextlib from datetime import datetime, timedelta, timezone from io import StringIO +from typing import ClassVar import pytz import regex as re @@ -25,9 +27,7 @@ def no_space_parser_eligibile(datestring): src = NSP_COMPATIBLE.search(datestring) - if not src or ":" == src.group(): - return True - return False + return not src or src.group() == ":" def get_unresolved_attrs(parser_object): @@ -74,7 +74,7 @@ def _parse_nospaces(datestring, settings, tz=None, date_order=None): class _time_parser: - time_directives = [ + time_directives: ClassVar[list[str]] = [ "%H:%M:%S", "%I:%M:%S %p", "%H:%M", @@ -92,15 +92,14 @@ def __call__(self, timestring): return strptime(timestring.strip(), directive).time() except ValueError: pass - else: - raise ValueError("%s does not seem to be a valid time string" % _timestring) + raise ValueError(f"{_timestring} does not seem to be a valid time string") time_parser = _time_parser() class _no_spaces_parser: - _dateformats = [ + _dateformats: ClassVar[list[str]] = [ "%Y%m%d", "%Y%d%m", "%m%Y%d", @@ -115,9 +114,13 @@ class _no_spaces_parser: "%d%m%y", ] - _preferred_formats = ["%Y%m%d%H%M", "%Y%m%d%H%M%S", "%Y%m%d%H%M%S.%f"] + _preferred_formats: ClassVar[list[str]] = [ + "%Y%m%d%H%M", + "%Y%m%d%H%M%S", + "%Y%m%d%H%M%S.%f", + ] - _preferred_formats_ordered_8_digit = [ + _preferred_formats_ordered_8_digit: ClassVar[list[str]] = [ "%m%d%Y", "%d%m%Y", "%Y%m%d", @@ -126,9 +129,12 @@ class _no_spaces_parser: "%d%Y%m", ] - _timeformats = ["%H%M%S.%f", "%H%M%S", "%H%M", "%H"] + _timeformats: ClassVar[list[str]] = ["%H%M%S.%f", "%H%M%S", "%H%M", "%H"] - period = {"day": ["%d", "%H", "%M", "%S"], "month": ["%m"]} + period: ClassVar[dict[str, list[str]]] = { + "day": ["%d", "%H", "%M", "%S"], + "month": ["%m"], + } _default_order = resolve_date_order("MDY") @@ -171,24 +177,21 @@ def _get_period(cls, format_string): for drv in pdrv: if drv in format_string: return pname - else: - return "year" + return "year" @classmethod def _find_best_matching_date(cls, datestring): for fmt in cls._preferred_formats_ordered_8_digit: - try: + with contextlib.suppress(Exception): dt = strptime(datestring, fmt), cls._get_period(fmt) if len(str(dt[0].year)) == 4: return dt - except Exception: - pass return None @classmethod def parse(cls, datestring, settings, date_order=None): if not no_space_parser_eligibile(datestring): - raise ValueError("Unable to parse date from: %s" % datestring) + raise ValueError(f"Unable to parse date from: {datestring}") datestring = datestring.replace(":", "") if not datestring: @@ -207,7 +210,7 @@ def parse(cls, datestring, settings, date_order=None): ambiguous_date = None for token, _ in tokens.tokenize(): for fmt in nsp.date_formats[order]: - try: + with contextlib.suppress(Exception): dt = strptime(token, fmt), cls._get_period(fmt) if len(str(dt[0].year)) < 4: ambiguous_date = dt @@ -216,13 +219,9 @@ def parse(cls, datestring, settings, date_order=None): missing = _get_missing_parts(fmt) _check_strict_parsing(missing, settings) return dt - except Exception: - pass - else: - if ambiguous_date: - return ambiguous_date - else: - raise ValueError("Unable to parse date from: %s" % datestring) + if ambiguous_date: + return ambiguous_date + raise ValueError(f"Unable to parse date from: {datestring}") def _get_missing_error(missing): @@ -232,25 +231,25 @@ def _get_missing_error(missing): def _check_strict_parsing(missing, settings): if settings.STRICT_PARSING and missing: raise ValueError(_get_missing_error(missing)) - elif settings.REQUIRE_PARTS and missing: + if settings.REQUIRE_PARTS and missing: errors = [part for part in settings.REQUIRE_PARTS if part in missing] if errors: raise ValueError(_get_missing_error(errors)) class _parser: - alpha_directives = { + alpha_directives: ClassVar[dict[str, list[str]]] = { "weekday": ["%A", "%a"], "month": ["%B", "%b"], } - num_directives = { + num_directives: ClassVar[dict[str, list[str]]] = { "month": ["%m"], "day": ["%d"], "year": ["%y", "%Y"], } - def __init__(self, tokens, settings, date_order=None): + def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 self.settings = settings self._date_order = date_order or settings.DATE_ORDER self.tokens = [(t[0].strip(), t[1]) for t in list(tokens)] @@ -285,7 +284,7 @@ def __init__(self, tokens, settings, date_order=None): if index in skip_index: continue - token, type, original_index = token_type_original_index + token, token_type, original_index = token_type_original_index if token in skip_tokens: continue @@ -293,7 +292,7 @@ def __init__(self, tokens, settings, date_order=None): if self.time is None: meridian_index = index + 1 - try: + with contextlib.suppress(Exception): # try case where hours and minutes are separated by a period. Example: 13.20. _is_before_period = self.tokens[original_index + 1][0] == "." _is_after_period = ( @@ -320,8 +319,6 @@ def __init__(self, tokens, settings, date_order=None): token = new_token skip_index.append(index + 1) meridian_index += 1 - except Exception: - pass try: microsecond = MICROSECOND.search( @@ -346,13 +343,13 @@ def __init__(self, tokens, settings, date_order=None): if any([":" in token, meridian, microsecond]): if meridian and not microsecond: - self._token_time = "%s %s" % (token, meridian) + self._token_time = f"{token} {meridian}" skip_index.append(meridian_index) elif microsecond and not meridian: - self._token_time = "%s.%s" % (token, microsecond) + self._token_time = f"{token}.{microsecond}" skip_index.append(index + 1) elif meridian and microsecond: - self._token_time = "%s.%s %s" % (token, microsecond, meridian) + self._token_time = f"{token}.{microsecond} {meridian}" skip_index.append(index + 1) skip_index.append(meridian_index) else: @@ -360,7 +357,7 @@ def __init__(self, tokens, settings, date_order=None): self.time = lambda: time_parser(self._token_time) continue - results = self._parse(type, token, skip_component=skip_component) + results = self._parse(token_type, token, skip_component=skip_component) for res in results: if len(token) == 4 and res[0] == "year": skip_component = "year" @@ -371,16 +368,16 @@ def __init__(self, tokens, settings, date_order=None): for attr in known: params.update({attr: getattr(self, attr)}) for attr in unknown: - for token, type, _ in self.unset_tokens: - if type == 0: + for token, token_type, _ in self.unset_tokens: + if token_type == 0: params.update({attr: int(token)}) - setattr(self, "_token_%s" % attr, token) + setattr(self, f"_token_{attr}", token) setattr(self, attr, int(token)) @classmethod def _has_month_name(cls, tokens): - for token, type in tokens: - if type != 1: + for token, token_type in tokens: + if token_type != 1: continue for directive in cls.alpha_directives["month"]: try: @@ -391,9 +388,8 @@ def _has_month_name(cls, tokens): return False def _get_period(self): - if self.settings.RETURN_TIME_AS_PERIOD: - if getattr(self, "time", None): - return "time" + if self.settings.RETURN_TIME_AS_PERIOD and getattr(self, "time", None): + return "time" for period in ["time", "day"]: if getattr(self, period, None): @@ -403,8 +399,7 @@ def _get_period(self): if getattr(self, period, None): return period - if self._results(): - return "day" + return "day" def _get_datetime_obj(self, **params): try: @@ -419,7 +414,7 @@ def _get_datetime_obj(self, **params): params["year"], params["month"] ) return datetime(**params) - elif ( + if ( not self._token_year and params["day"] == 29 and params["month"] == 2 @@ -430,7 +425,7 @@ def _get_datetime_obj(self, **params): self.settings.PREFER_DATES_FROM, params["year"] ) return datetime(**params) - raise e + raise def _get_correct_leap_year(self, prefer_dates_from, current_year): if prefer_dates_from == "future": @@ -455,7 +450,7 @@ def _get_datetime_obj_params(self): if not self.now: self._set_relative_base() - params = { + return { "day": self.day or self.now.day, "month": self.month or self.now.month, "year": self.year or self.now.year, @@ -464,7 +459,6 @@ def _get_datetime_obj_params(self): "second": 0, "microsecond": 0, } - return params def _get_date_obj(self, token, directive): return strptime(token, directive) @@ -481,17 +475,17 @@ def _results(self): if time: params.update( - dict( - hour=time.hour, - minute=time.minute, - second=time.second, - microsecond=time.microsecond, - ) + { + "hour": time.hour, + "minute": time.minute, + "second": time.second, + "microsecond": time.microsecond, + } ) return self._get_datetime_obj(**params) - def _correct_for_time_frame(self, dateobj, tz): + def _correct_for_time_frame(self, dateobj, tz): # noqa: PLR0912, PLR0915 days = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] token_weekday, _ = getattr(self, "_token_weekday", (None, None)) @@ -512,10 +506,7 @@ def _correct_for_time_frame(self, dateobj, tz): delta = timedelta(days=steps) else: if days[day_index] == day: - if self.settings.PREFER_DATES_FROM == "past": - steps = 7 - else: - steps = 0 + steps = 7 if self.settings.PREFER_DATES_FROM == "past" else 0 else: while days[day_index] != day: day_index -= 1 @@ -548,25 +539,23 @@ def _correct_for_time_frame(self, dateobj, tz): if self.now < dateobj: if self.settings.PREFER_DATES_FROM == "past": dateobj = dateobj.replace(year=dateobj.year - 1) - else: - if self.settings.PREFER_DATES_FROM == "future": - dateobj = dateobj.replace(year=dateobj.year + 1) - except ValueError as e: + elif self.settings.PREFER_DATES_FROM == "future": + dateobj = dateobj.replace(year=dateobj.year + 1) + except ValueError: if dateobj.day == 29 and dateobj.month == 2: valid_year = self._get_correct_leap_year( self.settings.PREFER_DATES_FROM, dateobj.year ) dateobj = dateobj.replace(year=valid_year) else: - raise e + raise if self._token_year and len(self._token_year[0]) == 2: if self.now < dateobj: if "past" in self.settings.PREFER_DATES_FROM: dateobj = dateobj.replace(year=dateobj.year - 100) - else: - if "future" in self.settings.PREFER_DATES_FROM: - dateobj = dateobj.replace(year=dateobj.year + 100) + elif "future" in self.settings.PREFER_DATES_FROM: + dateobj = dateobj.replace(year=dateobj.year + 100) if self._token_time and not any( [ @@ -583,18 +572,20 @@ def _correct_for_time_frame(self, dateobj, tz): except (pytz.UnknownTimeZoneError, pytz.NonExistentTimeError): tz_offset = timedelta(hours=0) - if "past" in self.settings.PREFER_DATES_FROM: - if self.now < dateobj - tz_offset: - dateobj = dateobj + timedelta(days=-1) - if "future" in self.settings.PREFER_DATES_FROM: - if self.now > dateobj - tz_offset: - dateobj = dateobj + timedelta(days=1) + if ( + "past" in self.settings.PREFER_DATES_FROM + and self.now < dateobj - tz_offset + ): + dateobj = dateobj + timedelta(days=-1) + if ( + "future" in self.settings.PREFER_DATES_FROM + and self.now > dateobj - tz_offset + ): + dateobj = dateobj + timedelta(days=1) # Reset dateobj to the original value, thus removing any offset awareness that may # have been set earlier. - dateobj = dateobj.replace(tzinfo=original_dateobj.tzinfo) - - return dateobj + return dateobj.replace(tzinfo=original_dateobj.tzinfo) def _correct_for_day(self, dateobj): if ( @@ -604,19 +595,17 @@ def _correct_for_day(self, dateobj): ): return dateobj - dateobj = set_correct_day_from_settings( + return set_correct_day_from_settings( dateobj, self.settings, current_day=self.now.day ) - return dateobj def _correct_for_month(self, dateobj): if getattr(self, "_token_month", None): return dateobj - dateobj = set_correct_month_from_settings( + return set_correct_month_from_settings( dateobj, self.settings, current_month=self.now.month ) - return dateobj @classmethod def parse(cls, datestring, settings, tz=None, date_order=None): @@ -652,15 +641,17 @@ def parse(cls, datestring, settings, tz=None, date_order=None): return dateobj, period - def _parse(self, type, token, skip_component=None): - def set_and_return(token, type, component, dateobj, skip_date_order=False): + def _parse(self, token_type, token, skip_component=None): + def set_and_return( + token, token_type, component, dateobj, skip_date_order=False + ): if not skip_date_order: self.auto_order.append(component) - setattr(self, "_token_%s" % component, (token, type)) + setattr(self, f"_token_{component}", (token, token_type)) return [(component, getattr(dateobj, component))] def parse_number(token, skip_component=None): - type = 0 + token_type = 0 num_directives = self.ordered_num_directives if ( @@ -688,23 +679,21 @@ def try_directives(skip_directive=None): do = self._get_date_obj(token, directive) prev_value = getattr(self, component, None) if not prev_value: - return set_and_return(token, type, component, do) - else: - try: - prev_token, prev_type = getattr( - self, "_token_%s" % component - ) - if prev_type == type: - do = self._get_date_obj(prev_token, directive) - except ValueError: - self.unset_tokens.append( - (prev_token, prev_type, component) - ) - return set_and_return(token, type, component, do) + return set_and_return(token, token_type, component, do) + try: + prev_token, prev_type = getattr( + self, f"_token_{component}" + ) + if prev_type == token_type: + do = self._get_date_obj(prev_token, directive) + except ValueError: + self.unset_tokens.append( + (prev_token, prev_type, component) + ) + return set_and_return(token, token_type, component, do) except ValueError: pass - else: - raise ValueError("Unable to parse: %s" % token) + raise ValueError(f"Unable to parse: {token}") order = list(self.ordered_num_directives) components_after_year = order[order.index("year") + 1 :] @@ -726,35 +715,32 @@ def try_directives(skip_directive=None): return try_directives() def parse_alpha(token, skip_component=None): - type = 1 + token_type = 1 for component, directives in self.alpha_directives.items(): if skip_component == component: continue for directive in directives: - try: + with contextlib.suppress(Exception): do = self._get_date_obj(token, directive) prev_value = getattr(self, component, None) if not prev_value: return set_and_return( - token, type, component, do, skip_date_order=True + token, token_type, component, do, skip_date_order=True ) - elif component == "month": + if component == "month": index = self.auto_order.index("month") self.auto_order[index] = "day" - setattr(self, "_token_day", self._token_month) - setattr(self, "_token_month", (token, type)) + self._token_day = self._token_month + self._token_month = token, token_type return [ (component, getattr(do, component)), ("day", prev_value), ] - except Exception: - pass - else: - raise ValueError("Unable to parse: %s" % token) + raise ValueError(f"Unable to parse: {token}") handlers = {0: parse_number, 1: parse_alpha} - return handlers[type](token, skip_component) + return handlers[token_type](token, skip_component) class tokenizer: @@ -788,17 +774,17 @@ def tokenize(self): if not nextchar: EOF = True - type, _ = self._switch(token[-1], nextchar) - yield token, type + token_type, _ = self._switch(token[-1], nextchar) + yield token, token_type return if token: - type, switch = self._switch(token[-1], nextchar) + token_type, switch = self._switch(token[-1], nextchar) if not switch: token += nextchar else: - yield token, type + yield token, token_type token = nextchar else: token += nextchar diff --git a/dateparser/search/__init__.py b/dateparser/search/__init__.py index 7016c6fcd..03bffd711 100644 --- a/dateparser/search/__init__.py +++ b/dateparser/search/__init__.py @@ -78,5 +78,6 @@ def search_dates( if dates: if add_detected_language: language = result.get("Language") - dates = [date + (language,) for date in dates] + dates = [(*date, language) for date in dates] return dates + return None diff --git a/dateparser/search/detection.py b/dateparser/search/detection.py index 9103d0513..a49f06beb 100644 --- a/dateparser/search/detection.py +++ b/dateparser/search/detection.py @@ -5,10 +5,8 @@ def _restore_languages_on_generator_exit(method): @wraps(method) def wrapped(self, *args, **kwargs): stored_languages = self.languages[:] - for language in method(self, *args, **kwargs): - yield language - else: - self.languages[:] = stored_languages + yield from method(self, *args, **kwargs) + self.languages[:] = stored_languages return wrapped @@ -28,9 +26,7 @@ def _filter_languages(date_string, languages, settings=None): language = languages[0] if language.is_applicable( date_string, strip_timezone=False, settings=settings - ): - yield language - elif language.is_applicable( + ) or language.is_applicable( date_string, strip_timezone=True, settings=settings ): yield language diff --git a/dateparser/search/ngram_search.py b/dateparser/search/ngram_search.py index 56957a7f7..f3e483147 100644 --- a/dateparser/search/ngram_search.py +++ b/dateparser/search/ngram_search.py @@ -30,7 +30,7 @@ # false positives. They can still be parsed as part of a longer candidate. _BAD_CANDIDATE_RE = re.compile( "^(" - + "|".join( + + "|".join( # noqa: FLY002 [ r"\d{1,3}", # bare numbers of less than 4 digits r"#\d+", # sequence numbers diff --git a/dateparser/search/search.py b/dateparser/search/search.py index c818f2522..fcc9d6fc1 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -1,4 +1,4 @@ -from collections.abc import Set +from collections.abc import Set as AbstractSet from datetime import datetime import regex as re @@ -18,7 +18,7 @@ # turns into several words ("0 day ago"), which is why the translation of a # chunk can hold more words than the text it was translated from. TRANSLATED_RELATIVE_REG = re.compile( - r"\bin \d+ (?:{units})s?\b|\b\d+ (?:{units})s? ago\b".format(units=_UNITS) + rf"\bin \d+ (?:{_UNITS})s?\b|\b\d+ (?:{_UNITS})s? ago\b" ) @@ -48,8 +48,7 @@ def get_current_language(self, shortname): def search(self, shortname, text, settings): language = self.get_current_language(shortname) - result = language.translate_search(text, settings=settings) - return result + return language.translate_search(text, settings=settings) @staticmethod def set_relative_base(substring, already_parsed): @@ -86,7 +85,7 @@ def choose_best_split(self, possible_parsed_splits, possible_substrings_splits): else (float(num_substrings_without_digits) / float(num_substrings)), ] ) - best_index, best_rating = min( + best_index, _best_rating = min( enumerate(rating), key=lambda p: (p[1][1], p[1][0], p[1][2]) ) return ( @@ -222,7 +221,7 @@ def parse_found_objects( parsed_jtem, is_relative_jtem = self.parse_item( parser, jtem, - split_translated[j], + jtem, current_parsed, need_relative_base, ) @@ -263,7 +262,7 @@ def search_parse(self, shortname, text, settings): language=language, ) - results = list(zip(substrings, [i[0]["date_obj"] for i in parsed])) + results = list(zip(substrings, [i[0]["date_obj"] for i in parsed], strict=True)) _add_time_span_results(results, text, settings) @@ -288,7 +287,7 @@ def _get_candidate_languages(self, detected_language, languages): if detected_language: candidates.append(detected_language) - if isinstance(languages, (list, tuple, Set)) and len(languages) > 1: + if isinstance(languages, (list, tuple, AbstractSet)) and len(languages) > 1: candidates.extend(languages) seen = set() @@ -312,8 +311,8 @@ def detect_language( ) return detected_languages[0] if detected_languages else None - if isinstance(languages, (list, tuple, Set)): - if all([language in self.available_language_map for language in languages]): + if isinstance(languages, (list, tuple, AbstractSet)): + if all(language in self.available_language_map for language in languages): languages = [ self.available_language_map[language] for language in languages ] @@ -322,12 +321,11 @@ def detect_language( self.available_language_map.keys() ) raise ValueError( - "Unknown language(s): %s" - % ", ".join(map(repr, unsupported_languages)) + f"Unknown language(s): {', '.join(map(repr, unsupported_languages))}" ) elif languages is not None: raise TypeError( - "languages argument must be a list (%r given)" % type(languages) + f"languages argument must be a list ({type(languages)!r} given)" ) if languages: @@ -337,10 +335,9 @@ def detect_language( list(self.available_language_map.values()) ) - detected_language = language_detector._best_language(text) or ( + return language_detector._best_language(text) or ( settings.DEFAULT_LANGUAGES[0] if settings.DEFAULT_LANGUAGES else None ) - return detected_language @apply_settings def search_dates( @@ -389,7 +386,7 @@ def search_dates( """ if strategy not in ("split", "ngram"): raise ValueError( - 'strategy must be "split" or "ngram" (%r given)' % strategy + f'strategy must be "split" or "ngram" ({strategy!r} given)' ) check_settings(settings) diff --git a/dateparser/search/text_detection.py b/dateparser/search/text_detection.py index e05efecfb..d84d2087b 100644 --- a/dateparser/search/text_detection.py +++ b/dateparser/search/text_detection.py @@ -57,10 +57,11 @@ def character_check(self, date_string, settings): if char.lower() in date_string.lower(): self.languages = [self.languages[i]] return - indices_to_pop = [] - for i in range(len(self.languages)): - if len(date_string_set & self.language_chars[i]) == 0: - indices_to_pop.append(i) + indices_to_pop = [ + i + for i in range(len(self.languages)) + if len(date_string_set & self.language_chars[i]) == 0 + ] self.languages = [ i for j, i in enumerate(self.languages) if j not in indices_to_pop ] diff --git a/dateparser/timezone_parser.py b/dateparser/timezone_parser.py index 58aa2c0c8..53124970c 100644 --- a/dateparser/timezone_parser.py +++ b/dateparser/timezone_parser.py @@ -20,7 +20,7 @@ def dst(self, dt): return timedelta(0) def __repr__(self): - return "<%s '%s'>" % (self.__class__.__name__, self.__name) + return f"<{self.__class__.__name__} '{self.__name}'>" def localize(self, dt, is_dst=False): if dt.tzinfo is not None: @@ -130,8 +130,7 @@ def get_offset(tz_obj, regex, repl="", replw=""): def get_local_tz_offset(): offset = datetime.now() - datetime.now(tz=timezone.utc).replace(tzinfo=None) - offset = timedelta(days=offset.days, seconds=round(offset.seconds, -1)) - return offset + return timedelta(days=offset.days, seconds=round(offset.seconds, -1)) _search_regex_parts = [] diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index e9756ae8f..8ab149986 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -47,19 +47,18 @@ def combine_dicts(primary_dict, supplementary_dict): else: combined_dict[key] = supplementary_dict[key] else: - combined_dict[key] = primary_dict[key] - remaining_keys = [ - key for key in supplementary_dict.keys() if key not in primary_dict.keys() - ] + combined_dict[key] = value + remaining_keys = [key for key in supplementary_dict if key not in primary_dict] for key in remaining_keys: combined_dict[key] = supplementary_dict[key] return combined_dict -def find_date_separator(format): +def find_date_separator(format): # noqa: A002 m = re.search(r"(?:(?:%[dbBmaA])(\W))+", format) if m: return m.group(1) + return None def _get_missing_parts(fmt): @@ -86,23 +85,21 @@ def _get_missing_parts(fmt): "year": ["%y", "%-y", "%Y"], } - missing = [ + return [ field for field in ("day", "month", "year") if not any(directive in fmt for directive in directive_mapping[field]) ] - return missing def get_timezone_from_tz_string(tz_string): try: return timezone(tz_string) - except UnknownTimeZoneError as e: + except UnknownTimeZoneError: for name, info in _tz_offsets: - if info["regex"].search(" %s" % tz_string): + if info["regex"].search(f" {tz_string}"): return StaticTzInfo(name, info["offset"]) - else: - raise e + raise def localize_timezone(date_time, tz_string): @@ -130,9 +127,10 @@ def apply_tzdatabase_timezone(date_time, pytz_string): def apply_dateparser_timezone(utc_datetime, offset_or_timezone_abb): for name, info in _tz_offsets: - if info["regex"].search(" %s" % offset_or_timezone_abb): + if info["regex"].search(f" {offset_or_timezone_abb}"): tz = StaticTzInfo(name, info["offset"]) return utc_datetime.astimezone(tz) + return None def apply_timezone(date_time, tz_string): @@ -237,7 +235,7 @@ def constructor(cls, *args, **kwargs): instance = creator(cls, *args) # Set the key before publishing the instance so other # threads never observe an entry without ``registry_key``. - setattr(instance, "registry_key", key) + instance.registry_key = key registry_dict[key] = instance return registry_dict[key] @@ -252,7 +250,7 @@ def constructor(cls, *args, **kwargs): "Registry classes require to implement class method get_key" ) - setattr(cls, "__new__", choose(cls.__new__)) + cls.__new__ = choose(cls.__new__) return cls diff --git a/dateparser/utils/strptime.py b/dateparser/utils/strptime.py index 2dfaa86f7..968c40f7d 100644 --- a/dateparser/utils/strptime.py +++ b/dateparser/utils/strptime.py @@ -17,16 +17,6 @@ MS_SEARCHER = re.compile(r"\.(?P[0-9]{1,6})") -def _exec_module(spec, module): - if hasattr(spec.loader, "exec_module"): - spec.loader.exec_module(module) - else: - # This can happen before Python 3.10 - # if spec.loader is a zipimporter and the Python runtime is in a zipfile - code = spec.loader.get_code(module.__name__) - exec(code, module.__dict__) - - def patch_strptime(): """Monkey patching _strptime to avoid problems related with non-english locale changes on the system. @@ -36,7 +26,7 @@ def patch_strptime(): """ _strptime_spec = importlib.util.find_spec("_strptime") _strptime = importlib.util.module_from_spec(_strptime_spec) - _exec_module(_strptime_spec, _strptime) + _strptime_spec.loader.exec_module(_strptime) sys.modules["strptime_patched"] = _strptime # Copy the namespace without re-executing calendar, whose enum decorators @@ -96,9 +86,9 @@ def patch_strptime(): def _prepare_format(date_string: str, og_format: str) -> tuple[str, str, bool]: # Adapted from std lib: https://github.com/python/cpython/blob/e34a5e33049ce845de646cf24a498766a2da3586/Lib/_strptime.py#L448 - format = re.sub(r"([\\.^$*+?\(\){}\[\]|])", r"\\\1", og_format) - format = re.sub(r"\s+", r"\\s+", format) - format = re.sub(r"'", "['\u02bc]", format) + regex_format = re.sub(r"([\\.^$*+?\(\){}\[\]|])", r"\\\1", og_format) + regex_format = re.sub(r"\s+", r"\\s+", regex_format) + regex_format = re.sub(r"'", "['\u02bc]", regex_format) year_in_format = False day_of_month_in_format = False day_of_year_in_format = False @@ -108,16 +98,16 @@ def repl(m: re.Match[str]) -> str: if format_char in ("Y", "y", "G"): nonlocal year_in_format year_in_format = True - elif format_char in ("d",): + elif format_char == "d": nonlocal day_of_month_in_format day_of_month_in_format = True - elif format_char in ("j",): + elif format_char == "j": nonlocal day_of_year_in_format day_of_year_in_format = True return "" - _ = re.sub(r"%[-_0^#]*[0-9]*([OE]?\\?.?)", repl, format) + _ = re.sub(r"%[-_0^#]*[0-9]*([OE]?\\?.?)", repl, regex_format) if day_of_month_in_format and not year_in_format: current_year = datetime.today().year return ( @@ -128,9 +118,11 @@ def repl(m: re.Match[str]) -> str: return date_string, og_format, day_of_year_in_format -def strptime(date_string: str, format: str) -> datetime: - date_string, format, day_of_year_in_format = _prepare_format(date_string, format) - time_tuple = __strptime(date_string, format) +def strptime(date_string: str, format: str) -> datetime: # noqa: A002 + date_string, prepared_format, day_of_year_in_format = _prepare_format( + date_string, format + ) + time_tuple = __strptime(date_string, prepared_format) obj = datetime(*time_tuple[:-3]) if day_of_year_in_format and time_tuple.tm_yday != obj.timetuple().tm_yday: @@ -142,7 +134,7 @@ def strptime(date_string: str, format: str) -> datetime: f"day of year {time_tuple.tm_yday} is out of range for year {obj.year - 1}" ) - if "%f" in format: + if "%f" in prepared_format: try: match_groups = TIME_MATCHER.match(date_string).groupdict() ms = match_groups["microsecond"] diff --git a/dateparser_cli/cli.py b/dateparser_cli/cli.py index 82acb3047..b557d3bc5 100644 --- a/dateparser_cli/cli.py +++ b/dateparser_cli/cli.py @@ -4,6 +4,8 @@ from .utils import clear_cache +logger = logging.getLogger(__name__) + def entrance(): dateparser_argparse = argparse.ArgumentParser( @@ -25,7 +27,7 @@ def entrance(): if args.clear: clear_cache() - logging.info("dateparser-download: All cache deleted") + logger.info("dateparser-download: All cache deleted") if args.fasttext: warnings.warn( diff --git a/dateparser_cli/exceptions.py b/dateparser_cli/exceptions.py deleted file mode 100644 index 8bf38679b..000000000 --- a/dateparser_cli/exceptions.py +++ /dev/null @@ -1,2 +0,0 @@ -class FastTextModelNotFoundException(Exception): - pass diff --git a/dateparser_cli/fasttext_manager.py b/dateparser_cli/fasttext_manager.py deleted file mode 100644 index a6ced6a2d..000000000 --- a/dateparser_cli/fasttext_manager.py +++ /dev/null @@ -1,42 +0,0 @@ -import logging -import os -import urllib.request -from pathlib import Path - -from .exceptions import FastTextModelNotFoundException -from .utils import create_data_model_home, dateparser_model_home - - -def fasttext_downloader(model_name): - create_data_model_home() - models = { - "small": "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.ftz", - "large": "https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin", - } - if model_name not in models: - message = 'dateparser-download: Couldn\'t find a model called "{}". Supported models are: {}'.format( - model_name, ", ".join(models.keys()) - ) - raise FastTextModelNotFoundException(message) - - models_directory_path = os.path.join(dateparser_model_home, (model_name + ".bin")) - - if not Path(models_directory_path).is_file(): - model_url = models[model_name] - logging.info( - 'dateparser-download: Downloading model "{}" from "{}"...'.format( - model_name, model_url - ) - ) - try: - urllib.request.urlretrieve(model_url, models_directory_path) - except urllib.error.HTTPError as e: - raise Exception( - "dateparser-download: Fasttext model cannot be downloaded due to HTTP error" - ) from e - else: - logging.info( - 'dateparser-download: The model "{}" is already downloaded'.format( - model_name - ) - ) diff --git a/dateparser_cli/utils.py b/dateparser_cli/utils.py index 796f01b39..5a6d1006b 100644 --- a/dateparser_cli/utils.py +++ b/dateparser_cli/utils.py @@ -1,11 +1,10 @@ -import os import sys from pathlib import Path DEFAULT_DIR_NAME = "dateparser_models" DEFAULT_UNIX_CACHE_DIR = "~/.cache" -DEFAULT_WINDOWS_CACHE_DIR = os.path.join(Path.home(), "AppData", "Roaming") +DEFAULT_WINDOWS_CACHE_DIR = Path.home() / "AppData" / "Roaming" if sys.platform.startswith("win"): @@ -15,13 +14,9 @@ # UNIX & OS X: _cache_dir = DEFAULT_UNIX_CACHE_DIR -dateparser_model_home = os.path.expanduser(os.path.join(_cache_dir, DEFAULT_DIR_NAME)) - - -def create_data_model_home(): - os.makedirs(dateparser_model_home, exist_ok=True) +dateparser_model_home = (Path(_cache_dir) / DEFAULT_DIR_NAME).expanduser() def clear_cache(*args): - for path in Path(dateparser_model_home).rglob("*.*"): - os.remove(path) + for path in dateparser_model_home.rglob("*.*"): + path.unlink() diff --git a/dateparser_scripts/get_cldr_data.py b/dateparser_scripts/get_cldr_data.py index ff3c0cded..d2a6e762d 100644 --- a/dateparser_scripts/get_cldr_data.py +++ b/dateparser_scripts/get_cldr_data.py @@ -1,11 +1,11 @@ import json -import os import shutil +from pathlib import Path import regex as re from dateparser_scripts.order_languages import _get_language_locale_dict -from dateparser_scripts.utils import get_dict_difference, get_raw_data, CLDR_JSON_DIR +from dateparser_scripts.utils import CLDR_JSON_DIR, get_dict_difference, get_raw_data APOSTROPHE_LOOK_ALIKE_CHARS = [ "\N{RIGHT SINGLE QUOTATION MARK}", # '\u2019' @@ -42,7 +42,7 @@ def _filter_month_name(month_name): return not DEFAULT_MONTH_PATTERN.match(month_name) -def _retrieve_locale_data(locale): +def _retrieve_locale_data(locale): # noqa: PLR0915 def load(scope, file_id): file_path = ( CLDR_JSON_DIR @@ -543,13 +543,12 @@ def _clean_dict(json_dict): def main(): get_raw_data() language_locale_dict = _get_language_locale_dict() - parent_directory = "../dateparser_data/cldr_language_data" - directory = "../dateparser_data/cldr_language_data/date_translation_data/" - if not os.path.isdir(parent_directory): - os.mkdir(parent_directory) - if os.path.isdir(directory): + parent_directory = Path("../dateparser_data/cldr_language_data") + directory = parent_directory / "date_translation_data" + parent_directory.mkdir(exist_ok=True) + if directory.is_dir(): shutil.rmtree(directory) - os.mkdir(directory) + directory.mkdir() for language in language_locale_dict: json_language_dict = _clean_dict(_retrieve_locale_data(language)) @@ -563,13 +562,12 @@ def main(): json_language_dict["locale_specific"] = dict( sorted(locale_specific_dict.items()) ) - filename = directory + language + ".json" - print("writing " + filename) + filename = directory / f"{language}.json" + print(f"writing {filename}") json_string = json.dumps( json_language_dict, indent=4, separators=(",", ": "), ensure_ascii=False ).encode("utf-8") - with open(filename, "wb") as f: - f.write(json_string) + filename.write_bytes(json_string) if __name__ == "__main__": diff --git a/dateparser_scripts/order_languages.py b/dateparser_scripts/order_languages.py index 14b32d163..82970df54 100644 --- a/dateparser_scripts/order_languages.py +++ b/dateparser_scripts/order_languages.py @@ -1,13 +1,15 @@ +import contextlib import json import os +from pathlib import Path import regex as re import requests from parsel import Selector -from dateparser_scripts.utils import get_raw_data, CLDR_JSON_DIR +from dateparser_scripts.utils import CLDR_JSON_DIR, get_raw_data -os.chdir(os.path.dirname(os.path.abspath(__file__))) +os.chdir(Path(__file__).resolve().parent) # Languages with insufficient translation data are excluded avoid_languages = {"cu", "kkj", "nds", "prg", "tk", "vai", "vai-Latn", "vai-Vaii", "vo"} @@ -167,7 +169,7 @@ def _get_language_locale_dict(): cldr_dates_full_dir = CLDR_JSON_DIR / "cldr-json/cldr-dates-full/main/" - available_locale_names = os.listdir(cldr_dates_full_dir) + available_locale_names = [path.name for path in cldr_dates_full_dir.iterdir()] available_language_names = [ shortname for shortname in available_locale_names @@ -181,8 +183,7 @@ def _get_language_locale_dict(): language_locale_dict[language_name].append(locale_name) for language in avoid_languages: - if language in language_locale_dict: - del language_locale_dict[language] + language_locale_dict.pop(language, None) return language_locale_dict @@ -232,7 +233,7 @@ def get_most_common_locales(): ] response = requests.get( - "https://w3techs.com/technologies/overview/content_language" + "https://w3techs.com/technologies/overview/content_language", timeout=60 ) sel = Selector(text=response.text) if response.ok: @@ -259,14 +260,14 @@ def get_most_common_locales(): territory_info_file = ( CLDR_JSON_DIR / "cldr-json/cldr-core/supplemental/territoryInfo.json" ) - with open(territory_info_file) as f: + with territory_info_file.open() as f: territory_content = json.load(f) territory_info_data = territory_content["supplemental"]["territoryInfo"] language_population_dict = {} for territory in territory_info_data: population = int(territory_info_data[territory]["_population"]) - try: + with contextlib.suppress(Exception): lang_dict = territory_info_data[territory]["languagePopulation"] for language in lang_dict: language_population = ( @@ -276,8 +277,6 @@ def get_most_common_locales(): language_population_dict[language] += language_population else: language_population_dict[language] = language_population - except Exception: - pass most_common_locales = get_most_common_locales() language_order_with_duplicates = most_common_locales + sorted( @@ -287,17 +286,19 @@ def get_most_common_locales(): ) language_order = sorted( set(language_order_with_duplicates), - key=lambda x: language_order_with_duplicates.index(x), + key=language_order_with_duplicates.index, ) - for index in range(0, len(language_order)): + for index in range(len(language_order)): language_order[index] = re.sub(r"_", r"-", language_order[index]) cldr_languages = language_locale_dict.keys() - supplementary_date_directory = ( + supplementary_date_directory = Path( "../dateparser_data/supplementary_language_data/date_translation_data" ) - supplementary_languages = [x[:-5] for x in os.listdir(supplementary_date_directory)] + supplementary_languages = [ + path.stem for path in supplementary_date_directory.iterdir() + ] available_languages = set(cldr_languages).union(set(supplementary_languages)) language_order = [ shortname for shortname in language_order if shortname in available_languages @@ -311,8 +312,7 @@ def get_most_common_locales(): else: remaining_languages.append(language) language_order = language_order + sorted(remaining_languages) - language_order = list(map(str, language_order)) - return language_order + return list(map(str, language_order)) def generate_language_map(language_order): @@ -330,17 +330,15 @@ def main(): language_locale_dict = _get_language_locale_dict() language_order = _get_language_order(language_locale_dict) - parent_directory = "../dateparser/data/" - filename = "../dateparser/data/languages_info.py" - if not os.path.isdir(parent_directory): - os.mkdir(parent_directory) + parent_directory = Path("../dateparser/data") + parent_directory.mkdir(exist_ok=True) language_order_string = "language_order = " + json.dumps( language_order, separators=(",", ": "), indent=4 ) complete_language_locale_dict = {} for key in language_order: - if key in language_locale_dict.keys(): + if key in language_locale_dict: complete_language_locale_dict[key] = sorted(language_locale_dict[key]) else: complete_language_locale_dict[key] = [] @@ -361,8 +359,7 @@ def main(): + language_locale_dict_string + "\n" ) - with open(filename, "w") as f: - f.write(languages_info_string) + (parent_directory / "languages_info.py").write_text(languages_info_string) if __name__ == "__main__": diff --git a/dateparser_scripts/tz_abbreviation_conflicts.py b/dateparser_scripts/tz_abbreviation_conflicts.py index f5ccfc067..af7048e9a 100644 --- a/dateparser_scripts/tz_abbreviation_conflicts.py +++ b/dateparser_scripts/tz_abbreviation_conflicts.py @@ -53,8 +53,8 @@ python -m dateparser_scripts.tz_abbreviation_conflicts """ -from collections import namedtuple from datetime import datetime +from typing import NamedTuple import pytz import regex as re @@ -87,9 +87,12 @@ # offsets through separate UTC/GMT patterns, so they are ignored here. _NUMERIC_ZONE_NAME = re.compile(r"[+-]\d{2,4}") -Conflict = namedtuple( - "Conflict", ["abbreviation", "kind", "dateparser_offset", "tz_database_offsets"] -) + +class Conflict(NamedTuple): + abbreviation: str + kind: str + dateparser_offset: int + tz_database_offsets: list[int] def static_tz_abbreviations(): diff --git a/dateparser_scripts/update_supported_languages_and_locales.py b/dateparser_scripts/update_supported_languages_and_locales.py index 53d5d8c45..8d3252652 100755 --- a/dateparser_scripts/update_supported_languages_and_locales.py +++ b/dateparser_scripts/update_supported_languages_and_locales.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 -import os +from pathlib import Path from tempfile import TemporaryFile from dateparser.data.languages_info import language_locale_dict @@ -14,18 +14,16 @@ def to_string(data): locales = data[language] if locales: result += " " * (language_column_width - len(language)) - result += ", ".join("'{}'".format(locale) for locale in sorted(locales)) + result += ", ".join(f"'{locale}'" for locale in sorted(locales)) result += "\n" return result def main(): - readme_path = os.path.join( - os.path.dirname(__file__), "..", "docs", "supported_locales.rst" - ) + readme_path = Path(__file__).parent.parent / "docs" / "supported_locales.rst" new_data = to_string(language_locale_dict) temporary_file = TemporaryFile("w+") - with open(readme_path) as readme_file: + with readme_path.open() as readme_file: delimiter = "============ ================================================================\n" delimiters_seen = 0 is_inside_table = False @@ -39,7 +37,7 @@ def main(): if is_inside_table: temporary_file.write(new_data) temporary_file.seek(0) - with open(readme_path, "w") as readme_file: + with readme_path.open("w") as readme_file: readme_file.write(temporary_file.read()) temporary_file.close() diff --git a/dateparser_scripts/utils.py b/dateparser_scripts/utils.py index 020689175..9f6c4f27b 100644 --- a/dateparser_scripts/utils.py +++ b/dateparser_scripts/utils.py @@ -1,17 +1,15 @@ -import os import shutil from pathlib import Path from git import Repo - CLDR_JSON_DIR = (Path(__file__).parent / "../cldr-json").resolve() def get_raw_data(): cldr_version = "44.1.0" url = "https://github.com/unicode-org/cldr-json.git" - if os.path.isdir(CLDR_JSON_DIR): + if CLDR_JSON_DIR.is_dir(): shutil.rmtree(CLDR_JSON_DIR) print(f"Clonning {url} @ {cldr_version} on {CLDR_JSON_DIR}...") @@ -47,10 +45,8 @@ def combine_dicts(primary_dict, supplementary_dict): else: combined_dict[key] = supplementary_dict[key] else: - combined_dict[key] = primary_dict[key] - remaining_keys = [ - key for key in supplementary_dict.keys() if key not in primary_dict.keys() - ] + combined_dict[key] = value + remaining_keys = [key for key in supplementary_dict if key not in primary_dict] for key in remaining_keys: combined_dict[key] = supplementary_dict[key] return combined_dict diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index 39c991f90..f2cc79239 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -1,5 +1,4 @@ import json -import os import shutil from pathlib import Path @@ -20,9 +19,9 @@ date_translation_directory = root / "dateparser/data/date_translation_data" cldr_languages = list( - set(map(lambda x: x[:-5], os.listdir(cldr_date_directory))) - avoid_languages + {path.stem for path in cldr_date_directory.iterdir()} - avoid_languages ) -supplementary_languages = [x[:-5] for x in os.listdir(supplementary_date_directory)] +supplementary_languages = [path.stem for path in supplementary_date_directory.iterdir()] all_languages = set(cldr_languages).union(set(supplementary_languages)) RELATIVE_PATTERN = re.compile(r"\{0\}") @@ -47,7 +46,7 @@ def _to_plain_types(obj): """ if isinstance(obj, dict): return {k: _to_plain_types(v) for k, v in obj.items()} - elif isinstance(obj, list): + if isinstance(obj, list): return [_to_plain_types(v) for v in obj] return obj @@ -56,9 +55,9 @@ def _modify_relative_data(relative_data): modified_relative_data = {} for key, value in relative_data.items(): for i, string in enumerate(value): - string = RELATIVE_PATTERN.sub(r"(\\d++[.,]?\\d*+)", string) - string = _make_possessive(string) - value[i] = string + value[i] = _make_possessive( + RELATIVE_PATTERN.sub(r"(\\d++[.,]?\\d*+)", string) + ) modified_relative_data[key] = value return modified_relative_data @@ -77,7 +76,7 @@ def _modify_data(language_data): simplifications = language_data.get("simplifications", []) _modify_simplifications(simplifications) locale_specific_data = language_data.get("locale_specific", {}) - for _, info in locale_specific_data.items(): + for info in locale_specific_data.values(): locale_relative_data = info.get("relative-type-regex", {}) locale_relative_data = _modify_relative_data(locale_relative_data) @@ -86,10 +85,10 @@ def _get_complete_date_translation_data(language): cldr_data = {} supplementary_data = {} if language in cldr_languages: - with open(cldr_date_directory / f"{language}.json") as f: + with (cldr_date_directory / f"{language}.json").open() as f: cldr_data = json.load(f) if language in supplementary_languages: - with open(supplementary_date_directory / f"{language}.yaml") as g: + with (supplementary_date_directory / f"{language}.yaml").open() as g: yaml = YAML() supplementary_data = dict(yaml.load(g)) complete_data = combine_dicts(cldr_data, supplementary_data) @@ -102,7 +101,7 @@ def _write_file(filename, text, mode, in_memory, in_memory_result): if in_memory: in_memory_result[filename] = text else: - with open(filename, mode) as out: + with Path(filename).open(mode) as out: out.write(text) @@ -117,13 +116,12 @@ def write_complete_data(in_memory=False): in_memory_result = {} if not in_memory: - if not os.path.isdir(translation_data_directory): - os.mkdir(translation_data_directory) - if os.path.isdir(date_translation_directory): + translation_data_directory.mkdir(exist_ok=True) + if date_translation_directory.is_dir(): shutil.rmtree(date_translation_directory) - os.mkdir(date_translation_directory) + date_translation_directory.mkdir() - with open(supplementary_directory / "base_data.yaml") as f: + with (supplementary_directory / "base_data.yaml").open() as f: yaml = YAML() base_data = yaml.load(f) diff --git a/docs/conf.py b/docs/conf.py index 3035675d7..66888071a 100755 --- a/docs/conf.py +++ b/docs/conf.py @@ -10,14 +10,13 @@ # file. -import os import sys +from pathlib import Path import dateparser # Get the project root dir, which is the parent dir of this -cwd = os.getcwd() -project_root = os.path.dirname(cwd) +project_root = str(Path.cwd().parent) # Insert the project root dir as the first element in the PYTHONPATH. # This lets us ensure that the source package is imported, and that its @@ -46,7 +45,7 @@ # General information about the project. project = "DateParser" -copyright = "2014, Scrapinghub" +project_copyright = "2014, Scrapinghub" # The version info for the project you're documenting, acts as replacement # for |version| and |release|, also used in various other places throughout diff --git a/fuzzing/dateparser_fuzzer.py b/fuzzing/dateparser_fuzzer.py index b8ca8bf12..8bd21c999 100644 --- a/fuzzing/dateparser_fuzzer.py +++ b/fuzzing/dateparser_fuzzer.py @@ -1,5 +1,4 @@ import sys -from typing import List import atheris from fuzz_helpers import EnhancedFuzzedDataProvider @@ -60,11 +59,11 @@ ] -def _get_format_strings(fdp: EnhancedFuzzedDataProvider) -> List[str]: - format_strings = [] - for _ in range(fdp.ConsumeIntInRange(0, 5)): - format_strings.append(fdp.ConsumeString(1).join(fdp.ConsumeSublist(directives))) - return format_strings +def _get_format_strings(fdp: EnhancedFuzzedDataProvider) -> list[str]: + return [ + fdp.ConsumeString(1).join(fdp.ConsumeSublist(directives)) + for _ in range(fdp.ConsumeIntInRange(0, 5)) + ] def TestOneInput(data): diff --git a/fuzzing/fuzz_helpers.py b/fuzzing/fuzz_helpers.py index 1ed057131..54d576af3 100644 --- a/fuzzing/fuzz_helpers.py +++ b/fuzzing/fuzz_helpers.py @@ -2,7 +2,7 @@ import datetime import io import tempfile -from typing import List, TypeVar +from typing import TypeVar import atheris @@ -24,7 +24,7 @@ def ConsumeRemainingString(self) -> str: def ConsumeRemainingBytes(self) -> bytes: return self.ConsumeBytes(self.remaining_bytes()) - def ConsumeSublist(self, source: List[T]) -> List[T]: + def ConsumeSublist(self, source: list[T]) -> list[T]: """ Returns a shuffled sub-list of the given list of len [1, len(source)] """ diff --git a/pyproject.toml b/pyproject.toml index c48563cae..7241a6328 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -81,10 +81,175 @@ serialize = ["{major}.{minor}"] exclude = ["date_translation_data"] [tool.ruff.lint] -# An invalid string escape warns at compile time, which pip's byte-compilation -# absorbs before the test suite's warnings-as-errors setting can see it. -extend-select = ["W605"] +extend-select = [ + # flake8-builtins + "A", + # flake8-async + "ASYNC", + # flake8-bugbear + "B", + # flake8-comprehensions + "C4", + # flake8-commas + "COM", + # pydocstyle + "D", + # pycodestyle + "E4", + "E7", + "E9", + # Pyflakes + "F", + # flake8-future-annotations + "FA", + # flynt + "FLY", + # refurb + "FURB", + # isort + "I", + # flake8-implicit-str-concat + "ISC", + # flake8-logging + "LOG", + # Perflint + "PERF", + # pygrep-hooks + "PGH", + # flake8-pie + "PIE", + # pylint + "PL", + # flake8-pytest-style + "PT", + # flake8-use-pathlib + "PTH", + # flake8-pyi + "PYI", + # flake8-quotes + "Q", + # flake8-return + "RET", + # flake8-raise + "RSE", + # Ruff-specific rules + "RUF", + # flake8-bandit + "S", + # flake8-simplify + "SIM", + # flake8-slots + "SLOT", + # flake8-debugger + "T10", + # flake8-type-checking + "TC", + # flake8-tidy-imports + "TID", + # pyupgrade + "UP", + # pycodestyle warnings + "W", + # flake8-2020 + "YTT", +] +ignore = [ + # Do not catch blind exception + "BLE001", + # Trailing comma missing + "COM812", + # Missing docstring in public module + "D100", + # Missing docstring in public class + "D101", + # Missing docstring in public method + "D102", + # Missing docstring in public function + "D103", + # Missing docstring in public package + "D104", + # Missing docstring in magic method + "D105", + # Missing docstring in public nested class + "D106", + # Missing docstring in __init__ + "D107", + # One-line docstring should fit on one line with quotes + "D200", + # No blank lines allowed after function docstring + "D202", + # 1 blank line required between summary line and description + "D205", + # Multi-line docstring closing quotes should be on a separate line + "D209", + # First line should end with a period + "D400", + # First line should be in imperative mood; try rephrasing + "D401", + # First line should not be the function's "signature" + "D402", + # First word of the first line should be properly capitalized + "D403", + # Naive datetime objects are part of the dateparser API + "DTZ", + # `try`-`except` within a loop incurs performance overhead + "PERF203", + # Too many return statements + "PLR0911", + # Too many arguments in function definition + "PLR0913", + # Too many positional arguments + "PLR0917", + # Magic value used in comparison + "PLR2004", + # String contains ambiguous {}. + "RUF001", + # Docstring contains ambiguous {}. + "RUF002", + # Comment contains ambiguous {}. + "RUF003", + # Use of `assert` detected; needed for mypy + "S101", + # Use a context manager for opening files + "SIM115", + # Yoda condition detected + "SIM300", + # Prefer `TypeError` exception for invalid type + "TRY004", +] + +[tool.ruff.lint.isort] +split-on-trailing-comma = false [tool.ruff.lint.per-file-ignores] "dateparser/data/__init__.py" = ["F401"] "dateparser/languages/__init__.py" = ["F401"] +"tests/**" = [ + # Skip bandit and allow blocking file I/O in tests + "ASYNC240", + "S", + # Assigning to `os.environ` doesn't clear the environment. + "B003", + # Do not use mutable data structures for argument defaults. + "B006", + # Found useless expression. + "B018", + # No explicit stacklevel argument found. + "B028", + # Within an `except` clause, raise exceptions with `raise ... from` + "B904", + # `for` loop variable overwritten by assignment target + "PLW2901", + # Tests are unittest-based + "PT009", + "PT027", + # Default values of parameterized test parameters are optional parameters + "PT028", + # Mutable class attributes should be annotated with `typing.ClassVar` + "RUF012", + # Use capitalized environment variable + "SIM112", +] + +[tool.ruff.lint.pydocstyle] +convention = "pep257" diff --git a/setup.py b/setup.py index 13c90073b..f9be80fbe 100644 --- a/setup.py +++ b/setup.py @@ -1,12 +1,13 @@ import re +from pathlib import Path from setuptools import setup -readme = open("README.rst", encoding="utf-8").read() +readme = Path("README.rst").read_text(encoding="utf-8") # Remove `.. raw:: html` blocks, which are not supported by PyPI. readme = re.sub(r"(?m)^\.\. raw:: html\n(?:^[ \t].*\n|^[ \t]*\n)*?\n\n", "", readme) history = re.sub( - r":mod:|:class:|:func:", "", open("HISTORY.rst", encoding="utf-8").read() + r":mod:|:class:|:func:", "", Path("HISTORY.rst").read_text(encoding="utf-8") ) setup( diff --git a/tests/__init__.py b/tests/__init__.py index 7132fb98c..4f91b2349 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -21,6 +21,5 @@ def then_error_was_raised(self, error_cls, allowed_substrings=()): self.assertIsInstance(self.error, error_cls) self.assertTrue( any(mesg in str(self.error) for mesg in allowed_substrings), - "Didn't found any of the expected messages (%r) -- message was: %r" - % (allowed_substrings, self.error), + f"Didn't found any of the expected messages ({allowed_substrings!r}) -- message was: {self.error!r}", ) diff --git a/tests/test_data.py b/tests/test_data.py index b8c6deae6..06430dc9a 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -132,7 +132,7 @@ def is_invalid_am_pm_translation(translation): def is_invalid_simplification(simplification): if not isinstance(simplification, dict) or len(simplification) != 1: return True - key, value = list(simplification.items())[0] + key, value = next(iter(simplification.items())) return not isinstance(key, str) or not isinstance(value, str) @@ -140,14 +140,14 @@ def is_invalid_relative_mapping(relative_mapping): key, value = relative_mapping if not (key and value and isinstance(key, str) and isinstance(value, list)): return True - return not all([isinstance(x, str) for x in value]) + return not all(isinstance(x, str) for x in value) def is_invalid_relative_regex_mapping(relative_regex_mapping): key, value = relative_regex_mapping if not (key and value and isinstance(key, str) and isinstance(value, list)): return True - return not all([isinstance(x, str) for x in value]) + return not all(isinstance(x, str) for x in value) class TestLocaleInfo(BaseTestCase): @@ -161,7 +161,7 @@ def test_extra_keys(self, locale): self.given_locale_info(locale) extra_keys = list(set(self.info.keys()) - set(VALID_KEYS)) self.assertFalse( - extra_keys, "Extra keys found for {}: {}".format(self.shortname, extra_keys) + extra_keys, f"Extra keys found for {self.shortname}: {extra_keys}" ) @parameterized.expand(all_locale_params) @@ -385,14 +385,12 @@ def then_name_is_valid(self): self.assertIsInstance( name, str, - "Invalid type for name: {} for locale {}".format( - type(name).__name__, self.shortname - ), + f"Invalid type for name: {type(name).__name__} for locale {self.shortname}", ) self.assertEqual( name, self.shortname, - "Invalid name: {} for locale {}".format(name, self.shortname), + f"Invalid name: {name} for locale {self.shortname}", ) def then_date_order_is_valid(self): @@ -401,14 +399,12 @@ def then_date_order_is_valid(self): self.assertIsInstance( date_order, str, - "Invalid type for date_order: {} for locale {}".format( - type(date_order).__name__, self.shortname - ), + f"Invalid type for date_order: {type(date_order).__name__} for locale {self.shortname}", ) self.assertIn( date_order, ["DMY", "DYM", "MDY", "MYD", "YDM", "YMD"], - "Invalid date_order {} for {}".format(date_order, self.shortname), + f"Invalid date_order {date_order} for {self.shortname}", ) def then_month_translations_are_valid(self, month): @@ -417,9 +413,7 @@ def then_month_translations_are_valid(self, month): self.assertIsInstance( month_translations, list, - "Invalid type for {}: {} for locale {}".format( - month, type(month_translations).__name__, self.shortname - ), + f"Invalid type for {month}: {type(month_translations).__name__} for locale {self.shortname}", ) invalid_translations = list( filter(is_invalid_month_translation, month_translations) @@ -437,9 +431,7 @@ def then_am_pm_translations_are_valid(self, key): self.assertIsInstance( translations_list, list, - "Invalid type for {}: {} for locale {}".format( - key, type(translations_list).__name__, self.shortname - ), + f"Invalid type for {key}: {type(translations_list).__name__} for locale {self.shortname}", ) invalid_translations = list( filter(is_invalid_am_pm_translation, translations_list) @@ -457,9 +449,7 @@ def then_translations_are_valid(self, key): self.assertIsInstance( translations_list, list, - "Invalid type for {}: {} for locale {}".format( - key, type(translations_list).__name__, self.shortname - ), + f"Invalid type for {key}: {type(translations_list).__name__} for locale {self.shortname}", ) invalid_translations = list( filter(is_invalid_translation, translations_list) @@ -477,9 +467,7 @@ def then_skip_pertain_tokens_are_valid(self, key): self.assertIsInstance( tokens_list, list, - "Invalid type for {}: {} for locale {}".format( - key, type(tokens_list).__name__, self.shortname - ), + f"Invalid type for {key}: {type(tokens_list).__name__} for locale {self.shortname}", ) invalid_tokens = [ token @@ -499,9 +487,7 @@ def then_simplifications_are_valid(self): self.assertIsInstance( simplifications_list, list, - "Invalid type for simplifications: {} for locale {}".format( - type(simplifications_list).__name__, self.shortname - ), + f"Invalid type for simplifications: {type(simplifications_list).__name__} for locale {self.shortname}", ) invalid_simplifications = list( filter(is_invalid_simplification, simplifications_list) @@ -520,9 +506,7 @@ def then_relative_type_is_valid(self): self.assertIsInstance( relative_type_dict, dict, - "Invalid type for relative-type: {} for locale {}".format( - type(relative_type_dict).__name__, self.shortname - ), + f"Invalid type for relative-type: {type(relative_type_dict).__name__} for locale {self.shortname}", ) invalid_relative_type = list( filter(is_invalid_relative_mapping, relative_type_dict.items()) @@ -541,9 +525,7 @@ def then_relative_type_regex_is_valid(self): self.assertIsInstance( relative_type_dict, dict, - "Invalid type for relative-type-regex: {} for locale {}".format( - type(relative_type_dict).__name__, self.shortname - ), + f"Invalid type for relative-type-regex: {type(relative_type_dict).__name__} for locale {self.shortname}", ) invalid_relative_type_regex = list( filter(is_invalid_relative_regex_mapping, relative_type_dict.items()) @@ -562,14 +544,10 @@ def then_no_word_spacing_is_valid(self): self.assertIsInstance( no_word_spacing, str, - "Invalid type for no_word_spacing: {} for locale {}".format( - type(no_word_spacing).__name__, self.shortname - ), + f"Invalid type for no_word_spacing: {type(no_word_spacing).__name__} for locale {self.shortname}", ) self.assertIn( no_word_spacing, ["True", "False"], - "Invalid no_word_spacing {} for {}".format( - no_word_spacing, self.shortname - ), + f"Invalid no_word_spacing {no_word_spacing} for {self.shortname}", ) diff --git a/tests/test_date.py b/tests/test_date.py index 8ade54321..70e647abe 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1,5 +1,3 @@ -#!/usr/bin/env python - import datetime as real_datetime import os import unittest @@ -109,7 +107,7 @@ def then_range_is_in_ascending_order(self): self.assertLess(self.result[i], self.result[i + 1]) def then_period_was_rejected(self, period): - self.then_error_was_raised(ValueError, ["Invalid argument: {}".format(period)]) + self.then_error_was_raised(ValueError, [f"Invalid argument: {period}"]) class TestGetIntersectingPeriodsFunction(BaseTestCase): @@ -936,7 +934,7 @@ def test_parsing_date_using_invalid_type_date_format_must_raise_error( TypeError, [ "Date formats should be list, tuple or set of strings", - "'{}' object is not iterable".format(type(date_formats).__name__), + f"'{type(date_formats).__name__}' object is not iterable", ], ) @@ -1187,7 +1185,7 @@ def test_error_raised_for_invalid_languages_argument(self, languages): self.when_parser_is_initialized(languages=languages) self.then_error_was_raised( TypeError, - ["languages argument must be a list (%r given)" % type(languages)], + [f"languages argument must be a list ({type(languages)!r} given)"], ) @parameterized.expand( @@ -1199,7 +1197,7 @@ def test_error_raised_for_invalid_languages_argument(self, languages): def test_error_raised_for_invalid_locales_argument(self, locales): self.when_parser_is_initialized(locales=locales) self.then_error_was_raised( - TypeError, ["locales argument must be a list (%r given)" % type(locales)] + TypeError, [f"locales argument must be a list ({type(locales)!r} given)"] ) @parameterized.expand( @@ -1211,7 +1209,7 @@ def test_error_raised_for_invalid_locales_argument(self, locales): def test_error_raised_for_invalid_region_argument(self, region): self.when_parser_is_initialized(region=region) self.then_error_was_raised( - TypeError, ["region argument must be str (%r given)" % type(region)] + TypeError, [f"region argument must be str ({type(region)!r} given)"] ) @parameterized.expand( @@ -1229,8 +1227,7 @@ def test_error_raised_for_invalid_try_previous_locales_argument( self.then_error_was_raised( TypeError, [ - "try_previous_locales argument must be a boolean (%r given)" - % type(try_previous_locales) + f"try_previous_locales argument must be a boolean ({type(try_previous_locales)!r} given)" ], ) @@ -1249,8 +1246,7 @@ def test_error_raised_for_invalid_use_given_order_argument(self, use_given_order self.then_error_was_raised( TypeError, [ - "use_given_order argument must be a boolean (%r given)" - % type(use_given_order) + f"use_given_order argument must be a boolean ({type(use_given_order)!r} given)" ], ) @@ -1359,7 +1355,7 @@ def given_parser(self, **params): def given_tzstr(self, tzstr): # Save the existing value - self.old_tzstr = os.environ["TZ"] if "TZ" in os.environ else None + self.old_tzstr = os.environ.get("TZ", None) # Overwrite the value, or remove it if tzstr is not None: diff --git a/tests/test_date_data.py b/tests/test_date_data.py index f96d670d2..8868f6fb3 100644 --- a/tests/test_date_data.py +++ b/tests/test_date_data.py @@ -15,10 +15,8 @@ def test_get_item_like_dict(self): def test_get_item_like_dict_keyerror(self): dd = DateData(date_obj=None, period="day", locale="de") - with pytest.raises(KeyError) as e: - date_obj = dd["date"] - assert e == "date" - assert not date_obj + with pytest.raises(KeyError, match="date"): + dd["date"] def test_set_item_like_dict(self): dd = DateData() @@ -30,12 +28,11 @@ def test_set_item_like_dict(self): def test_set_item_like_dict_keyerror(self): dd = DateData() - with pytest.raises(KeyError) as e: + with pytest.raises(KeyError, match="date"): dd["date"] = datetime(year=5432, month=3, day=1) - assert e == "date" @pytest.mark.parametrize( - "date,period,locale,expected", + ("date", "period", "locale", "expected"), [ ( datetime(year=2020, month=10, day=28), diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index f443615bc..3c947d096 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1,5 +1,5 @@ import unittest -from datetime import datetime, timedelta +from datetime import datetime, timedelta, timezone from functools import wraps from unittest.mock import Mock, patch @@ -151,7 +151,7 @@ def setUp(self): param("Thứ sáu", datetime(2012, 11, 9)), # Friday param( "Tháng Mười Hai 29, 2013, 14:14", datetime(2013, 12, 29, 14, 14) - ), # bpsosrcs.wordpress.com # NOQA + ), # bpsosrcs.wordpress.com param("05 Tháng một 2015 - 03:54 AM", datetime(2015, 1, 5, 3, 54)), # Belarusian dates param("11 траўня", datetime(2012, 5, 11)), @@ -393,7 +393,7 @@ def test_stringified_datetime_should_parse_fine(self): param("Thứ sáu", datetime(2012, 11, 9)), # Friday param( "Tháng Mười Hai 29, 2013, 14:14", datetime(2013, 12, 29, 14, 14) - ), # bpsosrcs.wordpress.com # NOQA + ), # bpsosrcs.wordpress.com param("05 Tháng một 2015 - 03:54 AM", datetime(2015, 1, 5, 3, 54)), # Belarusian dates param("11 траўня", datetime(2012, 5, 11)), @@ -1944,14 +1944,12 @@ def test_prefer_dates_from_with_date_formats_and_relative_base(self): def test_prefer_dates_from_with_date_formats_tz_aware_relative_base(self): """Test that a tz-aware RELATIVE_BASE does not crash (Bug #1 fix).""" - from datetime import timezone as tz - result = parse( "1/15/64", date_formats=["%m/%d/%y"], settings={ "PREFER_DATES_FROM": "past", - "RELATIVE_BASE": datetime(1980, 1, 1, tzinfo=tz.utc), + "RELATIVE_BASE": datetime(1980, 1, 1, tzinfo=timezone.utc), }, ) self.assertIsNotNone(result) diff --git a/tests/test_dateparser_data_integrity.py b/tests/test_dateparser_data_integrity.py index 7e58e81d4..f81a300a7 100644 --- a/tests/test_dateparser_data_integrity.py +++ b/tests/test_dateparser_data_integrity.py @@ -1,3 +1,5 @@ +from pathlib import Path + import pytest pytest.importorskip("ruamel") @@ -9,8 +11,7 @@ def test_dateparser_data_integrity(): files = write_complete_data(in_memory=True) for filename in files: - with open(filename, "rb") as f: - assert f.read().strip() == files[filename].strip(), ( - 'The content of the file "{}" doesn\'t match the content' - " of the generated file.".format(filename) - ) + assert Path(filename).read_bytes().strip() == files[filename].strip(), ( + f'The content of the file "{filename}" doesn\'t match the content' + " of the generated file." + ) diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 95c20f95e..df78b4c35 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -1,19 +1,20 @@ import unittest from datetime import date, datetime, time, timedelta from functools import wraps - -import pytz - -from zoneinfo import ZoneInfo - +from time import monotonic from unittest.mock import Mock, patch +from zoneinfo import ZoneInfo +import pytz from dateutil.relativedelta import relativedelta from parameterized import param, parameterized import dateparser +import dateparser.data.date_translation_data.en as en_data from dateparser.conf import settings from dateparser.date import DateDataParser, freshness_date_parser +from dateparser.freshness_date_parser import PATTERN +from dateparser.languages.dictionary import Dictionary from dateparser.utils import normalize_unicode from tests import BaseTestCase @@ -106,7 +107,7 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) ), # We've fixed .now in setUp param("5000 months ago", ago={"years": 416, "months": 8}, period="month"), param( - "{} months ago".format(2013 * 12 + 8), + f"{2013 * 12 + 8} months ago", ago={"years": 2013, "months": 8}, period="month", ), @@ -545,7 +546,7 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) param("1000 বছর আগে", ago={"years": 1000}, period="year"), param("5000 মাস আগে", ago={"years": 416, "months": 8}, period="month"), param( - "{} মাস আগে".format(2013 * 12 + 8), + f"{2013 * 12 + 8} মাস আগে", ago={"years": 2013, "months": 8}, period="month", ), @@ -809,7 +810,7 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) # kl param("for 6 ulloq unnuarlu siden", ago={"days": 6}, period="day"), # km - param("11 សប្ដាហ៍​មុន", ago={"weeks": 11}, period="week"), + param("11 សប្ដាហ៍\u200bមុន", ago={"weeks": 11}, period="week"), # kn param("15 ಸೆಕೆಂಡುಗಳ ಹಿಂದೆ", ago={"seconds": 15}, period="day"), # ko @@ -974,7 +975,7 @@ def test_relative_past_dates(self, date_string, ago, period): ), # We've fixed .now in setUp param("5000 months ago", ago={"years": 416, "months": 8}, period="month"), param( - "{} months ago".format(2013 * 12 + 8), + f"{2013 * 12 + 8} months ago", ago={"years": 2013, "months": 8}, period="month", ), @@ -1370,7 +1371,7 @@ def test_relative_past_dates(self, date_string, ago, period): param("1000 বছর আগে", ago={"years": 1000}, period="year"), param("5000 মাস আগে", ago={"years": 416, "months": 8}, period="month"), param( - "{} মাস আগে".format(2013 * 12 + 8), + f"{2013 * 12 + 8} মাস আগে", ago={"years": 2013, "months": 8}, period="month", ), @@ -1628,7 +1629,7 @@ def test_relative_past_dates(self, date_string, ago, period): # kl param("for 6 ulloq unnuarlu siden", ago={"days": 6}, period="day"), # km - param("11 សប្ដាហ៍​មុន", ago={"weeks": 11}, period="week"), + param("11 សប្ដាហ៍\u200bមុន", ago={"weeks": 11}, period="week"), # kn param("15 ಸೆಕೆಂಡುಗಳ ಹಿಂದೆ", ago={"seconds": 15}, period="day"), # ko @@ -1801,7 +1802,7 @@ def test_normalized_relative_dates(self, date_string, ago, period): "in 5000 months", in_future={"years": 416, "months": 8}, period="month" ), param( - "in {} months".format(2013 * 12 + 8), + f"in {2013 * 12 + 8} months", in_future={"years": 2013, "months": 8}, period="month", ), @@ -2370,7 +2371,7 @@ def test_insane_dates(self, date_string): [ param("5000 years ago"), param("2014 years ago"), # We've fixed .now in setUp - param("{} months ago".format(2013 * 12 + 9)), + param(f"{2013 * 12 + 9} months ago"), param("123456789 hour"), param("123456789123 hour"), param("1234567 days"), @@ -2500,11 +2501,9 @@ def test_freshness_date_with_timezone_conversion( def test_freshness_date_with_to_timezone_setting(self): _settings = settings.replace( - **{ - "TIMEZONE": "local", - "TO_TIMEZONE": "UTC", - "RELATIVE_BASE": datetime(2014, 9, 1, 10, 30), - } + TIMEZONE="local", + TO_TIMEZONE="UTC", + RELATIVE_BASE=datetime(2014, 9, 1, 10, 30), ) parser = dateparser.freshness_date_parser.FreshnessDateDataParser() @@ -2580,7 +2579,7 @@ def test_freshness_date_with_timezone_utc_offset( param("1000 years ago", date(1010, 6, 4), time(13, 15)), param("2008 years ago", date(2, 6, 4), time(13, 15)), param("5000 months ago", date(1593, 10, 4), time(13, 15)), - param("{} months ago".format(2008 * 12 + 8), date(1, 10, 4), time(13, 15)), + param(f"{2008 * 12 + 8} months ago", date(1, 10, 4), time(13, 15)), param( "1 year, 1 month, 1 week, 1 day, 1 hour and 1 minute ago", date(2009, 4, 26), @@ -2640,25 +2639,19 @@ def test_freshness_date_with_relative_base_future(self, date_string, date, time) def test_long_digit_run_does_not_hang(self): # Possessive quantifiers (\d++[.,]?\d*+) prevent quadratic backtracking. # Without the fix, PATTERN.findall('9' * 3200) takes ~23 s; with it, ~0.02 s. - import time - from dateparser.freshness_date_parser import PATTERN - from dateparser.languages.dictionary import Dictionary - from dateparser.conf import settings - import dateparser.data.date_translation_data.en as en_data - long_digits = "9" * 3200 - start = time.monotonic() + start = monotonic() PATTERN.findall(long_digits) - elapsed = time.monotonic() - start + elapsed = monotonic() - start self.assertLess(elapsed, 1.0, "PATTERN.findall backtracked on long digit run") d = Dictionary(en_data.info, settings) split_re = d._get_split_relative_regex_cache() - start = time.monotonic() + start = monotonic() split_re.split(long_digits) - elapsed = time.monotonic() - start + elapsed = monotonic() - start self.assertLess( elapsed, 1.0, "split_relative_regex backtracked on long digit run" ) @@ -2723,7 +2716,7 @@ def then_date_obj_is_exactly_this_time_in_future(self, in_future): def then_date_was_not_parsed(self): self.assertIsNone( - self.result["date_obj"], '"%s" should not be parsed' % self.date_string + self.result["date_obj"], f'"{self.date_string}" should not be parsed' ) def then_date_was_parsed_by_freshness_parser(self): diff --git a/tests/test_hijri.py b/tests/test_hijri.py index 00b58da61..8f0bc2a39 100644 --- a/tests/test_hijri.py +++ b/tests/test_hijri.py @@ -7,6 +7,7 @@ from parameterized import param, parameterized from dateparser.calendars.hijri import HijriCalendar +from dateparser.conf import settings from tests import BaseTestCase @@ -60,8 +61,6 @@ def then_parsed_datetime_is(self, dt): def test_datetime_parsing( self, dt_string, dt_obj, date_formats=None, languages=None ): - from dateparser.conf import settings - settings.DATE_ORDER = "DMY" self.when_date_is_given(dt_string, date_formats, languages) self.then_parsed_datetime_is(dt_obj) diff --git a/tests/test_jalali.py b/tests/test_jalali.py index 7511f1661..859c8e204 100644 --- a/tests/test_jalali.py +++ b/tests/test_jalali.py @@ -28,6 +28,7 @@ def then_weekday_is(self, weekday): param(year=1348, month=2, day=28, weekday=0), param(year=1348, month=3, day=27, weekday=2), param(year=1348, month=4, day=11, weekday=3), + param(year=1348, month=12, day=31, weekday=None), ] ) def test_weekday(self, year, month, day, weekday): diff --git a/tests/test_languages.py b/tests/test_languages.py index e466abe56..bcfd0304e 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -20,7 +20,7 @@ class TestLocaleTranslation: @pytest.mark.parametrize( - "date_string,expected,locale,keep_formatting", + ("date_string", "expected", "locale", "keep_formatting"), [ ( "December 04, 1999, 11:04:59 PM", @@ -1746,7 +1746,7 @@ def test_translation(self, shortname, datetime_string, expected_translation): # km param("km", "ម៉ោងនេះ", "0 hour ago"), param("km", "19 ខែមុន", "19 month ago"), - param("km", "ក្នុង​រយៈ​ពេល 23 ម៉ោង", "in 23 hour"), + param("km", "ក្នុង\u200bរយៈ\u200bពេល 23 ម៉ោង", "in 23 hour"), # kn param("kn", "18 ತಿಂಗಳುಗಳ ಹಿಂದೆ", "18 month ago"), param("kn", "26 ಸೆಕೆಂಡ್‌ನಲ್ಲಿ", "in 26 second"), diff --git a/tests/test_parser.py b/tests/test_parser.py index c1c5f6def..47aa434cd 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -1,5 +1,5 @@ -from datetime import datetime, time import warnings +from datetime import datetime, time from parameterized import param, parameterized @@ -117,7 +117,7 @@ def test_date_with_spaces_is_not_parsed(self): self.given_settings() self.when_date_is_parsed(datestring) self.then_error_was_raised( - ValueError, ["Unable to parse date from: %s" % datestring] + ValueError, [f"Unable to parse date from: {datestring}"] ) @parameterized.expand( @@ -151,7 +151,7 @@ def test_colons_string_is_not_parsed(self, date_string): self.given_settings() self.when_date_is_parsed(date_string) self.then_error_was_raised( - ValueError, ["Unable to parse date from: %s" % date_string] + ValueError, [f"Unable to parse date from: {date_string}"] ) def test_date_with_alphabets_is_not_parsed(self): @@ -160,7 +160,7 @@ def test_date_with_alphabets_is_not_parsed(self): self.given_settings() self.when_date_is_parsed(datestring) self.then_error_was_raised( - ValueError, ["Unable to parse date from: %s" % datestring] + ValueError, [f"Unable to parse date from: {datestring}"] ) @parameterized.expand( @@ -351,6 +351,11 @@ def test_default_order_used_if_date_order_not_supplied( expected_date=datetime(1234, 5, 6, 7, 8), expected_period="day", ), + param( + date_string="00592763", + expected_date=datetime(59, 6, 27, 3), + expected_period="day", + ), ] ) def test_best_order_used_if_date_order_not_supplied_to_8_digit_numbers( @@ -373,7 +378,7 @@ def test_error_is_raised_when_date_cannot_be_parsed(self, date_string, date_orde self.given_settings(settings={"DATE_ORDER": date_order}) self.when_date_is_parsed(date_string) self.then_error_was_raised( - ValueError, ["Unable to parse date from: {}".format(date_string)] + ValueError, [f"Unable to parse date from: {date_string}"] ) @parameterized.expand( @@ -491,6 +496,24 @@ def test_error_is_raised_when_year_part_missing(self, date_string): self.given_settings(settings={"REQUIRE_PARTS": ["year"]}) self.then_error_is_raised_when_date_is_parsed(date_string) + @parameterized.expand( + [ + param(relative_base=datetime(1, 1, 1), prefer_dates_from="past"), + param(relative_base=datetime(9999, 6, 1), prefer_dates_from="future"), + ] + ) + def test_error_is_raised_when_preferred_year_is_out_of_range( + self, relative_base, prefer_dates_from + ): + self.given_parser() + self.given_settings( + settings={ + "RELATIVE_BASE": relative_base, + "PREFER_DATES_FROM": prefer_dates_from, + } + ) + self.then_error_is_raised_when_date_is_parsed("March 3") + def given_parser(self): self.parser = _parser @@ -573,7 +596,7 @@ def test_error_is_raised_for_invalid_time_string(self, date_string): self.when_time_is_parsed(date_string) self.then_error_was_raised( ValueError, - ["{} does not seem to be a valid time string".format(date_string)], + [f"{date_string} does not seem to be a valid time string"], ) def given_parser(self): diff --git a/tests/test_settings.py b/tests/test_settings.py index bc4a5a7cc..605e88ad2 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -131,7 +131,7 @@ def test_apply_settings_should_return_non_default_settings_when_settings_are_sup test_func(settings={"PREFER_DATES_FROM": "past"}), self.default_settings ) - def test_apply_settings_shouldnt_create_new_settings_when_same_settings_are_supplied_to_the_decorated_function_more_than_once( # noqa E501 + def test_apply_settings_shouldnt_create_new_settings_when_same_settings_are_supplied_to_the_decorated_function_more_than_once( self, ): test_func = apply_settings(test_function) @@ -139,7 +139,7 @@ def test_apply_settings_shouldnt_create_new_settings_when_same_settings_are_supp settings_twice = test_func(settings={"PREFER_DATES_FROM": "past"}) self.assertEqual(settings_once, settings_twice) - def test_apply_settings_should_return_default_settings_when_called_with_no_settings_after_once_called_with_settings_supplied_to_the_decorated_function( # noqa E501 + def test_apply_settings_should_return_default_settings_when_called_with_no_settings_after_once_called_with_settings_supplied_to_the_decorated_function( self, ): test_func = apply_settings(test_function) @@ -211,7 +211,7 @@ def test_check_settings_wrong_setting_name(self): def test_check_settings(self, setting, wrong_type, wrong_value, valid_value): with self.assertRaisesRegex( SettingValidationError, - r'"{}" must be .*, not "{}".'.format(setting, type(wrong_type).__name__), + rf'"{setting}" must be .*, not "{type(wrong_type).__name__}".', ): DateDataParser(settings={setting: wrong_type}) @@ -272,7 +272,7 @@ def test_check_settings_extra_check_default_languages(self): @pytest.mark.parametrize( - "date_string,expected_result", + ("date_string", "expected_result"), [ # Note that these results are "valid" but probably they shouldn't be considered ("2020", datetime(1900, 1, 1, 20, 2)), @@ -296,8 +296,7 @@ def test_no_spaces_strict_parsing(date_string, expected_result): def detect_languages(text, confidence_threshold): if confidence_threshold > 0.5: return ["en"] - else: - return ["fr"] + return ["fr"] def test_confidence_threshold_setting_is_applied(): diff --git a/tests/test_thread_safety.py b/tests/test_thread_safety.py index 5d010ccfb..2d23e6538 100644 --- a/tests/test_thread_safety.py +++ b/tests/test_thread_safety.py @@ -1,3 +1,4 @@ +import contextlib import sys import threading import unittest @@ -45,7 +46,7 @@ def test_dictionary_cache_eviction_concurrently(self): dictionaries = [ Dictionary( en_data.info, - base_settings.replace(CACHE_SIZE_LIMIT=1, SKIP_TOKENS=["tok%d" % i]), + base_settings.replace(CACHE_SIZE_LIMIT=1, SKIP_TOKENS=[f"tok{i}"]), ) for i in range(24) ] @@ -141,7 +142,7 @@ def test_detect_language_does_not_leave_narrowed_detector_on_instance(self): {"ru", "en"}, "detect_language left a single-use detector narrowed in place " "on the instance; concurrent search_dates can observe this " - "(issue #1369). leftover=%r" % leftover, + f"(issue #1369). leftover={leftover!r}", ) def test_concurrent_search_dates_does_not_share_language_detector(self): @@ -163,10 +164,8 @@ def _get(self): def _set(self, value): slot["v"] = value - try: + with contextlib.suppress(threading.BrokenBarrierError): barrier.wait() - except threading.BrokenBarrierError: - pass DateSearchWithDetection.language_detector = property(_get, _set) try: @@ -197,10 +196,8 @@ def test_concurrent_search_dates_does_not_share_locale_slot(self): def patched(self, shortname): result = original(self, shortname) - try: + with contextlib.suppress(threading.BrokenBarrierError): barrier.wait() - except threading.BrokenBarrierError: - pass return result _ExactLanguageSearch.get_current_language = patched diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index 3d92e4d58..beadaa4d3 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -15,6 +15,7 @@ pop_tz_offset_from_string, word_is_tz, ) +from dateparser_scripts import tz_abbreviation_conflicts from tests import BaseTestCase @@ -334,8 +335,6 @@ class TestTzDatabasePreference(BaseTestCase): @classmethod def setUpClass(cls): super().setUpClass() - from dateparser_scripts import tz_abbreviation_conflicts - cls.checker = tz_abbreviation_conflicts # Sampling every zone takes a moment, so it is done once for the class. cls.tz_database = tz_abbreviation_conflicts.tz_database_abbreviations() diff --git a/tests/test_utils.py b/tests/test_utils.py index 515a6e0af..a7d21c2a3 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -51,8 +51,7 @@ def make_class_without_get_keys(): class SomeClass: pass - some_class = SomeClass - return some_class + return SomeClass @parameterized.expand( [ @@ -67,6 +66,11 @@ def test_separator_extraction(self, date_format, expected_sep): self.when_date_separator_is_parsed() self.then_date_separator_is(expected_sep) + def test_separator_extraction_without_separator(self): + self.given_date_format("%Y") + self.when_date_separator_is_parsed() + self.then_date_separator_is(None) + @parameterized.expand( [ param(datetime(2015, 12, 12), timezone="UTC", zone="UTC"), @@ -131,7 +135,7 @@ def test_apply_timezone_function(self, date, timezone, expected): ) def test_apply_timezone_from_settings_function(self, date, timezone, expected): result = apply_timezone_from_settings( - date, settings.replace(**{"TO_TIMEZONE": timezone, "TIMEZONE": "UTC"}) + date, settings.replace(TO_TIMEZONE=timezone, TIMEZONE="UTC") ) self.assertEqual(expected, result) @@ -158,7 +162,7 @@ def test_apply_timezone_from_settings_function_none_settings(self, date, expecte ) def test_apply_timezone_from_settings_function_should_return_tz(self, date): result = apply_timezone_from_settings( - date, settings.replace(**{"RETURN_AS_TIMEZONE_AWARE": True}) + date, settings.replace(RETURN_AS_TIMEZONE_AWARE=True) ) self.assertTrue(bool(result.tzinfo)) @@ -190,7 +194,7 @@ def test_get_last_day_of_month(self, year, month, expected_last_day): @pytest.mark.parametrize( - "year,expected_previous_leap_year", + ("year", "expected_previous_leap_year"), [ (2020, 2016), (2000, 1996), # leap and centurial year @@ -205,7 +209,7 @@ def test_get_previous_leap_year(year, expected_previous_leap_year): @pytest.mark.parametrize( - "year,expected_next_leap_year", + ("year", "expected_next_leap_year"), [ (2020, 2024), (1996, 2000), # leap and centurial year @@ -229,11 +233,11 @@ def test_get_next_leap_year(year, expected_next_leap_year): ], ) def test_broken_local_timezone(parse): - with patch( - "dateparser.utils.get_localzone", - side_effect=ValueError("ZoneInfo keys may not be absolute paths"), + with ( + patch( + "dateparser.utils.get_localzone", + side_effect=ValueError("ZoneInfo keys may not be absolute paths"), + ), + pytest.raises(RuntimeError, match="Could not determine the local timezone"), ): - with pytest.raises( - RuntimeError, match="Could not determine the local timezone" - ): - parse() + parse() diff --git a/tests/test_utils_strptime.py b/tests/test_utils_strptime.py index a76230bc4..a41fab8df 100644 --- a/tests/test_utils_strptime.py +++ b/tests/test_utils_strptime.py @@ -1,7 +1,7 @@ import locale +import warnings from datetime import datetime from unittest import SkipTest -import warnings from parameterized import param, parameterized @@ -17,7 +17,7 @@ def given_system_locale_is(self, locale_str): try: locale.setlocale(locale.LC_ALL, locale_str) except locale.Error: - raise SkipTest("Locale {} is not installed".format(locale_str)) + raise SkipTest(f"Locale {locale_str} is not installed") def when_date_string_is_parsed(self, date_string, fmt): try: From e3a38881e2a979086615f8407c5ce7470ffeca26 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 12:26:42 +0200 Subject: [PATCH 077/107] Add type hints (#1457) --- .github/workflows/main.yml | 2 + dateparser/__init__.py | 29 +- dateparser/calendars/__init__.py | 70 +-- dateparser/calendars/french_republican.py | 12 +- dateparser/calendars/hijri_parser.py | 12 +- dateparser/calendars/jalali_parser.py | 20 +- dateparser/conf.py | 68 ++- .../custom_language_detection/fasttext.py | 3 +- .../custom_language_detection/langdetect.py | 12 +- .../language_mapping.py | 4 +- dateparser/date.py | 168 ++++--- dateparser/date_parser.py | 15 +- dateparser/freshness_date_parser.py | 38 +- dateparser/languages/__init__.py | 4 +- dateparser/languages/dictionary.py | 84 ++-- dateparser/languages/loader.py | 69 +-- dateparser/languages/locale.py | 266 ++++++----- dateparser/languages/validation.py | 35 +- dateparser/parser.py | 166 ++++--- dateparser/search/__init__.py | 21 +- dateparser/search/detection.py | 48 +- dateparser/search/ngram_search.py | 15 +- dateparser/search/search.py | 141 ++++-- dateparser/search/text_detection.py | 20 +- dateparser/timezone_parser.py | 59 ++- dateparser/timezones.py | 4 +- dateparser/utils/__init__.py | 79 ++-- dateparser/utils/strptime.py | 16 +- dateparser/utils/time_spans.py | 16 +- dateparser_cli/cli.py | 2 +- dateparser_cli/utils.py | 2 +- dateparser_scripts/get_cldr_data.py | 23 +- dateparser_scripts/order_languages.py | 15 +- .../tz_abbreviation_conflicts.py | 20 +- .../update_supported_languages_and_locales.py | 5 +- dateparser_scripts/utils.py | 11 +- dateparser_scripts/write_complete_data.py | 31 +- fuzzing/dateparser_fuzzer.py | 5 +- fuzzing/fuzz_helpers.py | 39 +- pyproject.toml | 12 + stubs/parameterized/__init__.pyi | 19 + tests/__init__.py | 23 +- .../test_benchmark_freshness_date_parser.py | 4 +- tests/benchmarks/test_benchmark_parse.py | 2 +- tests/test_clean_api.py | 147 +++--- tests/test_data.py | 131 +++--- tests/test_date.py | 418 +++++++++++------- tests/test_date_data.py | 12 +- tests/test_date_parser.py | 329 +++++++++----- tests/test_dateparser_data_integrity.py | 2 +- tests/test_fasttext.py | 8 + tests/test_french_republican.py | 13 +- tests/test_freshness_date_parser.py | 135 +++--- tests/test_hijri.py | 30 +- tests/test_jalali.py | 60 ++- tests/test_language_detect.py | 56 +-- tests/test_languages.py | 254 +++++++---- tests/test_loading.py | 112 +++-- tests/test_parser.py | 113 +++-- tests/test_pickle.py | 9 +- tests/test_search.py | 122 +++-- tests/test_settings.py | 80 ++-- tests/test_thread_safety.py | 61 +-- tests/test_timezone_parser.py | 131 +++--- tests/test_utils.py | 68 ++- tests/test_utils_strptime.py | 48 +- tests/test_whitespace_preservation.py | 31 +- tox.ini | 24 +- 68 files changed, 2572 insertions(+), 1531 deletions(-) create mode 100644 stubs/parameterized/__init__.pyi create mode 100644 tests/test_fasttext.py diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 52b1e8081..eb60e95c7 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -25,6 +25,8 @@ jobs: include: - python-version: "3.14" toxenv: pre-commit + - python-version: "3.10" + toxenv: mypy - python-version: "3.10" toxenv: min - python-version: "3.10" diff --git a/dateparser/__init__.py b/dateparser/__init__.py index f0bc28c3a..906d5ad6b 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -1,21 +1,25 @@ __version__ = "1.4.3" -from .conf import apply_settings -from .date import DateDataParser +from collections.abc import Callable, Iterable +from datetime import datetime +from typing import Any + +from .conf import Settings, apply_settings +from .date import DateDataParser as DateDataParser _default_parser = DateDataParser() @apply_settings def parse( - date_string, - date_formats=None, - languages=None, - locales=None, - region=None, - settings=None, - detect_languages_function=None, -): + date_string: str, + date_formats: Iterable[str] | None = None, + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + settings: Settings | dict[str, Any] | None = None, + detect_languages_function: Callable[..., list[str]] | None = None, +) -> datetime | None: """Parse date and time from given date string. :param date_string: @@ -59,6 +63,7 @@ def parse( ``ValueError``: Unknown Language, ``TypeError``: Languages argument must be a list, ``SettingValidationError``: A provided setting is not valid. """ + assert isinstance(settings, Settings) parser = _default_parser if ( @@ -76,4 +81,6 @@ def parse( detect_languages_function=detect_languages_function, ) - return parser.get_date_data(date_string, date_formats)["date_obj"] + data = parser.get_date_data(date_string, date_formats) + date_obj: datetime | None = data["date_obj"] + return date_obj diff --git a/dateparser/calendars/__init__.py b/dateparser/calendars/__init__.py index 796e9f314..cc4b2092a 100644 --- a/dateparser/calendars/__init__.py +++ b/dateparser/calendars/__init__.py @@ -1,10 +1,18 @@ -from datetime import datetime +from collections.abc import Callable +from datetime import datetime, tzinfo +from typing import Any, ClassVar, Protocol -from dateparser.conf import settings +from dateparser.conf import Settings, settings from dateparser.date import DateData from dateparser.parser import _parser +class _CalendarParser(Protocol): + def parse( + self, datestring: str, settings: Settings + ) -> tuple[datetime, str | None]: ... + + class CalendarBase: """Base setup class for non-Gregorian calendar system. @@ -13,57 +21,57 @@ class CalendarBase: :type source: str """ - parser = NotImplemented + parser: _CalendarParser = NotImplemented - def __init__(self, source): + def __init__(self, source: str) -> None: self.source = source - def get_date(self): + def get_date(self) -> DateData | None: try: date_obj, period = self.parser.parse(self.source, settings) return DateData(date_obj=date_obj, period=period) except ValueError: - pass + return None class non_gregorian_parser(_parser): - calendar_converter = NotImplemented - default_year = NotImplemented - default_month = NotImplemented - default_day = NotImplemented - non_gregorian_date_cls = NotImplemented + calendar_converter: Any = NotImplemented + default_year: int = NotImplemented + default_month: int = NotImplemented + default_day: int = NotImplemented + non_gregorian_date_cls: Callable[[int, int, int], Any] = NotImplemented - _digits = None - _months = None - _weekdays = None - _number_letters = None + _digits: ClassVar[dict[str, int] | None] = None + _months: ClassVar[dict[str, tuple[int, int, list[str]]] | None] = None + _weekdays: ClassVar[dict[str, list[str]] | None] = None + _number_letters: ClassVar[dict[int, list[str]] | None] = None @classmethod - def _replace_time_conventions(cls, source): + def _replace_time_conventions(cls, source: str) -> str: return source @classmethod - def _replace_digits(cls, source): + def _replace_digits(cls, source: str) -> str: return source @classmethod - def _replace_months(cls, source): + def _replace_months(cls, source: str) -> str: return source @classmethod - def _replace_weekdays(cls, source): + def _replace_weekdays(cls, source: str) -> str: return source @classmethod - def _replace_time(cls, source): + def _replace_time(cls, source: str) -> str: return source @classmethod - def _replace_days(cls, source): + def _replace_days(cls, source: str) -> str: return source @classmethod - def to_latin(cls, source): + def to_latin(cls, source: str) -> str: result = source result = cls._replace_months(result) result = cls._replace_weekdays(result) @@ -74,10 +82,10 @@ def to_latin(cls, source): return result.strip() - def handle_two_digit_year(self, year): + def handle_two_digit_year(self, year: int) -> int: raise ValueError - def _get_datetime_obj(self, **params): + def _get_datetime_obj(self, **params: Any) -> datetime: day = params["day"] year = params["year"] month = params["month"] @@ -92,7 +100,7 @@ def _get_datetime_obj(self, **params): c_params.update({"year": year, "month": month, "day": day}) return datetime(**c_params) - def _get_datetime_obj_params(self): + def _get_datetime_obj_params(self) -> dict[str, int]: if not self.now: self._set_relative_base() now_year, now_month, now_day = self.calendar_converter.from_gregorian( @@ -108,7 +116,7 @@ def _get_datetime_obj_params(self): "microsecond": 0, } - def _get_date_obj(self, token, directive): + def _get_date_obj(self, token: str, directive: str) -> Any: year, month, day = self.default_year, self.default_month, self.default_day token_len = len(token) is_digit = token.isdigit() @@ -136,6 +144,12 @@ def _get_date_obj(self, token, directive): return self.non_gregorian_date_cls(year, month, day) @classmethod - def parse(cls, datestring, settings): + def parse( + cls, + datestring: str, + settings: Settings, + tz: tzinfo | None = None, + date_order: str | None = None, + ) -> tuple[datetime, str | None]: datestring = cls.to_latin(datestring) - return super().parse(datestring, settings) + return super().parse(datestring, settings, tz, date_order) diff --git a/dateparser/calendars/french_republican.py b/dateparser/calendars/french_republican.py index b986a7d1d..6634e57fe 100644 --- a/dateparser/calendars/french_republican.py +++ b/dateparser/calendars/french_republican.py @@ -1,11 +1,15 @@ import re import unicodedata from datetime import datetime, timezone +from typing import TYPE_CHECKING from convertdate import french_republican from dateparser.calendars import CalendarBase +if TYPE_CHECKING: + from dateparser.conf import Settings + _MONTHS = { name: index for index, names in enumerate( @@ -37,7 +41,7 @@ _ROMAN_NUMERAL_VALUES = {"C": 100, "L": 50, "X": 10, "V": 5, "I": 1} -def _roman_to_int(numeral): +def _roman_to_int(numeral: str) -> int: values = [_ROMAN_NUMERAL_VALUES[char] for char in numeral.upper()] return sum( -value if value < next_value else value @@ -45,7 +49,7 @@ def _roman_to_int(numeral): ) -def _month_length(year, month): +def _month_length(year: int, month: int) -> int: if month < 13: return 30 return 6 if french_republican.leap(year) else 5 @@ -53,7 +57,9 @@ def _month_length(year, month): class _french_republican_parser: @classmethod - def parse(cls, datestring, settings): + def parse( + cls, datestring: str, settings: "Settings" + ) -> tuple[datetime, str | None]: normalized = "".join( char for char in unicodedata.normalize("NFKD", datestring.strip()) diff --git a/dateparser/calendars/hijri_parser.py b/dateparser/calendars/hijri_parser.py index 5ff47bd2d..6de34e5a6 100644 --- a/dateparser/calendars/hijri_parser.py +++ b/dateparser/calendars/hijri_parser.py @@ -7,23 +7,23 @@ class hijri: @classmethod - def to_gregorian(cls, year=None, month=None, day=None): + def to_gregorian(cls, year: int, month: int, day: int) -> tuple[int, int, int]: g = Hijri(year=year, month=month, day=day, validate=False).to_gregorian() return g.datetuple() @classmethod - def from_gregorian(cls, year=None, month=None, day=None): + def from_gregorian(cls, year: int, month: int, day: int) -> tuple[int, int, int]: h = Gregorian(year, month, day).to_hijri() return h.datetuple() @classmethod - def month_length(cls, year, month): + def month_length(cls, year: int, month: int) -> int: h = Hijri(year=year, month=month, day=1) return h.month_length() class HijriDate: - def __init__(self, year, month, day): + def __init__(self, year: int, month: int, day: int) -> None: self.year = year self.month = month self.day = day @@ -42,14 +42,14 @@ class hijri_parser(non_gregorian_parser): } @classmethod - def _replace_time_conventions(cls, source): + def _replace_time_conventions(cls, source: str) -> str: result = source for latin, arabics in cls._time_conventions.items(): for arabic in arabics: result = result.replace(arabic, latin) return result - def handle_two_digit_year(self, year): + def handle_two_digit_year(self, year: int) -> int: if year >= 90: return year + 1300 return year + 1400 diff --git a/dateparser/calendars/jalali_parser.py b/dateparser/calendars/jalali_parser.py index edfa7e0de..3386398fb 100644 --- a/dateparser/calendars/jalali_parser.py +++ b/dateparser/calendars/jalali_parser.py @@ -8,12 +8,12 @@ class PersianDate: - def __init__(self, year, month, day): + def __init__(self, year: int, month: int, day: int) -> None: self.year = year self.month = month self.day = day - def weekday(self): + def weekday(self) -> int | None: for week in persian.monthcalendar(self.year, self.month): for idx, day in enumerate(week): if day == self.day: @@ -103,14 +103,14 @@ class jalali_parser(non_gregorian_parser): } @classmethod - def _replace_digits(cls, source): + def _replace_digits(cls, source: str) -> str: result = source for pers_digit, number in cls._digits.items(): result = result.replace(pers_digit, str(number)) return result @classmethod - def _replace_months(cls, source): + def _replace_months(cls, source: str) -> str: result = source for pers, latin in reduce( lambda a, b: a + b, @@ -123,7 +123,7 @@ def _replace_months(cls, source): return result @classmethod - def _replace_weekdays(cls, source): + def _replace_weekdays(cls, source: str) -> str: result = source for pers, latin in reduce( lambda a, b: a + b, @@ -136,8 +136,8 @@ def _replace_weekdays(cls, source): return result @classmethod - def _replace_time(cls, source): - def only_numbers(match_obj): + def _replace_time(cls, source: str) -> str: + def only_numbers(match_obj: re.Match[str]) -> str: matched_string = match_obj.group() return re.sub(r"\D", " ", matched_string) @@ -151,13 +151,13 @@ def only_numbers(match_obj): return result.replace("ساعت", "") @classmethod - def _replace_days(cls, source): + def _replace_days(cls, source: str) -> str: result = re.sub( r"ام|م|ین", "", source ) # removes persian variant of th/first/second/third day_pairs = list(cls._number_letters.items()) - def comp_key(tup): + def comp_key(tup: tuple[int, list[str]]) -> int: return tup[0] day_pairs.sort(key=comp_key, reverse=True) @@ -173,7 +173,7 @@ def comp_key(tup): result = result.replace(persian_number, str(number)) return result - def handle_two_digit_year(self, year): + def handle_two_digit_year(self, year: int) -> int: if year > 60: return year + 1300 return year + 1400 diff --git a/dateparser/conf.py b/dateparser/conf.py index f02330a6e..5e309ac26 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -1,15 +1,18 @@ import hashlib -from collections.abc import Mapping +from collections.abc import Callable, Iterable, Mapping from datetime import datetime from functools import wraps from types import MappingProxyType -from typing import Any +from typing import Any, Literal, ParamSpec, TypeVar from dateparser.data.languages_info import language_order from .parser import date_order_chart from .utils import registry +_P = ParamSpec("_P") +_R = TypeVar("_R") + @registry class Settings: @@ -41,18 +44,43 @@ class Settings: * `CACHE_SIZE_LIMIT` """ - _default = True - _pyfile_data = None + _default: bool = True + _pyfile_data: dict[str, Any] | None = None _mod_settings: Mapping[str, Any] = MappingProxyType({}) - def __init__(self, settings=None): + registry_key: str + DATE_ORDER: str + PREFER_LOCALE_DATE_ORDER: bool + TIMEZONE: str + TO_TIMEZONE: str | Literal[False] + RETURN_AS_TIMEZONE_AWARE: bool | Literal["default"] + PREFER_MONTH_OF_YEAR: str + PREFER_DAY_OF_MONTH: str + PREFER_DATES_FROM: str + RELATIVE_BASE: datetime | Literal[False] + STRICT_PARSING: bool + REQUIRE_PARTS: list[str] + IGNORE_SURROUNDING_TEXT: bool + SKIP_TOKENS: list[str] + NORMALIZE: bool + RETURN_TIME_AS_PERIOD: bool + RETURN_TIME_SPAN: bool + DEFAULT_START_OF_WEEK: str + DEFAULT_DAYS_IN_MONTH: int + PARSERS: list[str] + DEFAULT_LANGUAGES: list[str] + USE_GIVEN_LANGUAGE_ORDER: bool + LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD: float + CACHE_SIZE_LIMIT: int + + def __init__(self, settings: Mapping[str, Any] | None = None) -> None: if settings: self._updateall(settings.items()) else: self._updateall(self._get_settings_from_pyfile().items()) @classmethod - def get_key(cls, settings=None): + def get_key(cls, settings: Mapping[str, Any] | None = None) -> str: if not settings: return "default" @@ -62,18 +90,20 @@ def get_key(cls, settings=None): ).hexdigest() @classmethod - def _get_settings_from_pyfile(cls): + def _get_settings_from_pyfile(cls) -> dict[str, Any]: if not cls._pyfile_data: from dateparser_data import settings # noqa: PLC0415 cls._pyfile_data = settings.settings return cls._pyfile_data - def _updateall(self, iterable): + def _updateall(self, iterable: Iterable[tuple[str, Any]]) -> None: for key, value in iterable: setattr(self, key, value) - def replace(self, mod_settings=None, **kwds): + def replace( + self, mod_settings: Mapping[str, Any] | None = None, **kwds: Any + ) -> "Settings": for k, v in kwds.items(): if v is None: raise TypeError(f'Invalid {{"{k}": {v}}}') @@ -91,10 +121,10 @@ def replace(self, mod_settings=None, **kwds): settings = Settings() -def apply_settings(f): +def apply_settings(f: Callable[_P, _R]) -> Callable[_P, _R]: @wraps(f) - def wrapper(*args, **kwargs): - mod_settings = kwargs.get("settings") + def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R: + mod_settings: Any = kwargs.get("settings") kwargs["settings"] = mod_settings or settings if isinstance(kwargs["settings"], dict): @@ -116,14 +146,14 @@ class SettingValidationError(ValueError): pass -def _check_repeated_values(setting_name, setting_value): +def _check_repeated_values(setting_name: str, setting_value: list[Any]) -> None: if len(setting_value) != len(set(setting_value)): raise SettingValidationError( f'There are repeated values in the "{setting_name}" setting' ) -def _check_require_part(setting_name, setting_value): +def _check_require_part(setting_name: str, setting_value: list[str]) -> None: """Returns `True` if the provided list of parts contains valid values""" invalid_values = set(setting_value) - {"day", "month", "year"} if invalid_values: @@ -135,7 +165,7 @@ def _check_require_part(setting_name, setting_value): _check_repeated_values(setting_name, setting_value) -def _check_parsers(setting_name, setting_value): +def _check_parsers(setting_name: str, setting_value: list[str]) -> None: """Returns `True` if the provided list of parsers contains valid values""" existing_parsers = [ "timestamp", @@ -155,7 +185,7 @@ def _check_parsers(setting_name, setting_value): _check_repeated_values(setting_name, setting_value) -def _check_default_languages(setting_name, setting_value): +def _check_default_languages(setting_name: str, setting_value: list[str]) -> None: unsupported_languages = set(setting_value) - set(language_order) if unsupported_languages: raise SettingValidationError( @@ -166,7 +196,7 @@ def _check_default_languages(setting_name, setting_value): _check_repeated_values(setting_name, setting_value) -def _check_between_0_and_1(setting_name, setting_value): +def _check_between_0_and_1(setting_name: str, setting_value: float) -> None: is_valid = 0 <= setting_value <= 1 if not is_valid: raise SettingValidationError( @@ -175,12 +205,12 @@ def _check_between_0_and_1(setting_name, setting_value): ) -def check_settings(settings): +def check_settings(settings: Settings) -> None: """ Check if provided settings are valid, if not it raises `SettingValidationError`. Only checks for the modified settings. """ - settings_values = { + settings_values: dict[str, dict[str, Any]] = { "DATE_ORDER": { "values": tuple(date_order_chart.keys()), "type": str, diff --git a/dateparser/custom_language_detection/fasttext.py b/dateparser/custom_language_detection/fasttext.py index dd1e1b7c2..8977a2c47 100644 --- a/dateparser/custom_language_detection/fasttext.py +++ b/dateparser/custom_language_detection/fasttext.py @@ -6,6 +6,7 @@ """ import warnings +from typing import NoReturn warnings.warn( "fastText support is deprecated and will be removed in a future version. " @@ -16,7 +17,7 @@ ) -def detect_languages(text, confidence_threshold): +def detect_languages(text: str, confidence_threshold: float) -> NoReturn: """ Deprecated function. FastText support has been removed. diff --git a/dateparser/custom_language_detection/langdetect.py b/dateparser/custom_language_detection/langdetect.py index e885a4936..895f35c55 100644 --- a/dateparser/custom_language_detection/langdetect.py +++ b/dateparser/custom_language_detection/langdetect.py @@ -1,3 +1,5 @@ +from typing import Any + import langdetect # The below _Factory is set to prevent setting global state of the library @@ -6,25 +8,25 @@ class _Factory: - data = None + data: Any = None -def _init_factory(): +def _init_factory() -> None: if _Factory.data is None: _Factory.data = langdetect.detector_factory.DetectorFactory() _Factory.data.load_profile(langdetect.detector_factory.PROFILES_DIRECTORY) _Factory.data.seed = 0 -def _get_language_probablities(text): +def _get_language_probablities(text: str) -> Any: _init_factory() detector = _Factory.data.create() detector.append(text) return detector.get_probabilities() -def detect_languages(text, confidence_threshold): - language_codes = [] +def detect_languages(text: str, confidence_threshold: float) -> list[str]: + language_codes: list[str] = [] try: parser_data = _get_language_probablities(text) language_codes.extend( diff --git a/dateparser/custom_language_detection/language_mapping.py b/dateparser/custom_language_detection/language_mapping.py index a76030828..5e797d7cc 100644 --- a/dateparser/custom_language_detection/language_mapping.py +++ b/dateparser/custom_language_detection/language_mapping.py @@ -1,7 +1,9 @@ +from collections.abc import Iterable + from dateparser.data.languages_info import language_map -def map_languages(language_codes): +def map_languages(language_codes: Iterable[str]) -> list[str]: """ Returns the candidates from the supported languages codes. :param language_codes: diff --git a/dateparser/date.py b/dateparser/date.py index a4cb01908..bbdd771c3 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -1,12 +1,14 @@ import collections import threading +from collections.abc import Callable, Iterable, Iterator from collections.abc import Set as AbstractSet -from datetime import datetime, timedelta, timezone +from datetime import date, datetime, timedelta, timezone, tzinfo +from typing import TYPE_CHECKING, Any, TypeVar import regex as re from dateutil.relativedelta import relativedelta -from dateparser.conf import apply_settings, check_settings +from dateparser.conf import Settings, apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages from dateparser.date_parser import date_parser from dateparser.freshness_date_parser import freshness_date_parser @@ -25,6 +27,11 @@ ) from dateparser.utils.strptime import strptime as patched_strptime +if TYPE_CHECKING: + from dateparser.languages.locale import Locale + +_D = TypeVar("_D", bound=date) + APOSTROPHE_LOOK_ALIKE_CHARS = [ "\N{RIGHT SINGLE QUOTATION MARK}", # '\u2019' "\N{MODIFIER LETTER APOSTROPHE}", # '\u02bc' @@ -96,13 +103,13 @@ RE_SEARCH_NEGATIVE_TIMESTAMP = re.compile(r"^([-]\d{10})(\d{3})?(\d{3})?(?![^.])") -def sanitize_spaces(date_string): +def sanitize_spaces(date_string: str) -> str: date_string = RE_NBSP.sub(" ", date_string) date_string = RE_SPACES.sub(" ", date_string) return RE_TRIM_SPACES.sub(r"\1", date_string) -def date_range(begin, end, **kwargs): +def date_range(begin: _D, end: _D, **kwargs: Any) -> Iterator[_D]: dateutil_error_prone_args = [ "year", "month", @@ -128,7 +135,7 @@ def date_range(begin, end, **kwargs): yield end -def get_intersecting_periods(low, high, period="day"): +def get_intersecting_periods(low: _D, high: _D, period: str = "day") -> Iterator[_D]: if period not in [ "year", "month", @@ -144,11 +151,12 @@ def get_intersecting_periods(low, high, period="day"): if high <= low: return - step = relativedelta(**{period + "s": 1}) + step_kwargs: dict[str, Any] = {period + "s": 1} + step = relativedelta(**step_kwargs) current_period_start = low if isinstance(current_period_start, datetime): - reset_arguments = {} + reset_arguments: dict[str, Any] = {} for test_period in ["microsecond", "second", "minute", "hour"]: if test_period == period: break @@ -170,7 +178,7 @@ def get_intersecting_periods(low, high, period="day"): current_period_start += step -def sanitize_date(date_string): +def sanitize_date(date_string: str) -> str: date_string = RE_SANITIZE_SKIP.sub(" ", date_string) date_string = RE_SANITIZE_RUSSIAN.sub( r"\1 ", date_string @@ -187,7 +195,9 @@ def sanitize_date(date_string): return date_string.strip() -def get_date_from_timestamp(date_string, settings, negative=False): +def get_date_from_timestamp( + date_string: str, settings: Settings | None, negative: bool = False +) -> datetime | None: if negative: match = RE_SEARCH_NEGATIVE_TIMESTAMP.search(date_string) else: @@ -201,7 +211,7 @@ def get_date_from_timestamp(date_string, settings, negative=False): ): # If the timezone in settings is unset, or it's 'local', use the # local timezone - timezone = _get_localzone() + timezone: tzinfo = _get_localzone() else: # Otherwise, use the timezone given in settings timezone = get_timezone_from_tz_string(settings.TIMEZONE) @@ -216,7 +226,9 @@ def get_date_from_timestamp(date_string, settings, negative=False): return None -def _apply_century_preference(date_obj, now, prefer_from): +def _apply_century_preference( + date_obj: datetime, now: datetime, prefer_from: str +) -> datetime: """Shift *date_obj* by ±100 years to satisfy PREFER_DATES_FROM. *now* is normalised to naive so a tz-aware RELATIVE_BASE does not raise @@ -247,7 +259,9 @@ def _apply_century_preference(date_obj, now, prefer_from): return date_obj.replace(year=target_year) -def parse_with_formats(date_string, date_formats, settings): +def parse_with_formats( + date_string: str, date_formats: Iterable[str], settings: Settings +) -> "DateData": """Parse with formats and return a dictionary with 'period' and 'obj_date'. :returns: :class:`datetime.datetime`, dict or None @@ -295,12 +309,13 @@ def parse_with_formats(date_string, date_formats, settings): class _DateLocaleParser: def __init__( self, - locale, - date_string, - date_formats, - settings=None, - ignore_surrounding_text=False, - ): + locale: "Locale", + date_string: str, + date_formats: Iterable[str] | None, + settings: Settings | None = None, + ignore_surrounding_text: bool = False, + ) -> None: + assert settings is not None self._settings = settings if not ( date_formats is None or isinstance(date_formats, (list, tuple, AbstractSet)) @@ -311,9 +326,9 @@ def __init__( self.date_string = date_string self.date_formats = date_formats self._ignore_surrounding_text = ignore_surrounding_text - self._translated_date = None - self._translated_date_with_formatting = None - self._parsers = { + self._translated_date: str | None = None + self._translated_date_with_formatting: str | None = None + self._parsers: dict[str, Callable[[], DateData | None]] = { "timestamp": self._try_timestamp, "negative-timestamp": self._try_negative_timestamp, "relative-time": self._try_freshness_parser, @@ -325,25 +340,25 @@ def __init__( @classmethod def parse( cls, - locale, - date_string, - date_formats=None, - settings=None, - ignore_surrounding_text=False, - ): + locale: "Locale", + date_string: str, + date_formats: Iterable[str] | None = None, + settings: Settings | None = None, + ignore_surrounding_text: bool = False, + ) -> "DateData | None": instance = cls( locale, date_string, date_formats, settings, ignore_surrounding_text ) return instance._parse() - def _parse(self): + def _parse(self) -> "DateData | None": for parser_name in self._settings.PARSERS: date_data = self._parsers[parser_name]() if self._is_valid_date_data(date_data): return date_data return None - def _try_timestamp_parser(self, negative=False): + def _try_timestamp_parser(self, negative: bool = False) -> "DateData": return DateData( date_obj=get_date_from_timestamp( self.date_string, self._settings, negative=negative @@ -351,13 +366,13 @@ def _try_timestamp_parser(self, negative=False): period="time" if self._settings.RETURN_TIME_AS_PERIOD else "day", ) - def _try_timestamp(self): + def _try_timestamp(self) -> "DateData": return self._try_timestamp_parser() - def _try_negative_timestamp(self): + def _try_negative_timestamp(self) -> "DateData": return self._try_timestamp_parser(negative=True) - def _try_freshness_parser(self): + def _try_freshness_parser(self) -> "DateData | None": try: return freshness_date_parser.get_date_data( self._get_translated_date(), self._settings @@ -365,13 +380,15 @@ def _try_freshness_parser(self): except (OverflowError, ValueError): return None - def _try_absolute_parser(self): + def _try_absolute_parser(self) -> "DateData | None": return self._try_parser(parse_method=_parse_absolute) - def _try_nospaces_parser(self): + def _try_nospaces_parser(self) -> "DateData | None": return self._try_parser(parse_method=_parse_nospaces) - def _try_parser(self, parse_method): + def _try_parser( + self, parse_method: Callable[..., tuple[datetime, str | None]] + ) -> "DateData | None": original_order = self._settings.DATE_ORDER # Use locale date order unless DATE_ORDER was explicitly set by the caller. @@ -412,7 +429,7 @@ def _try_parser(self, parse_method): continue return None - def _try_given_formats(self): + def _try_given_formats(self) -> "DateData | None": if not self.date_formats: return None @@ -422,7 +439,7 @@ def _try_given_formats(self): settings=self._settings, ) - def _get_translated_date(self): + def _get_translated_date(self) -> str: if self._translated_date is None: self._translated_date = self.locale.translate( self.date_string, @@ -432,7 +449,7 @@ def _get_translated_date(self): ) return self._translated_date - def _get_translated_date_with_formatting(self): + def _get_translated_date_with_formatting(self) -> str: if self._translated_date_with_formatting is None: self._translated_date_with_formatting = self.locale.translate( self.date_string, @@ -442,7 +459,7 @@ def _get_translated_date_with_formatting(self): ) return self._translated_date_with_formatting - def _is_valid_date_data(self, date_data): + def _is_valid_date_data(self, date_data: object) -> bool: if not isinstance(date_data, DateData): return False if not date_data["date_obj"] or not date_data["period"]: @@ -458,22 +475,28 @@ class DateData: It can be accessed with square brackets like a dict object. """ - def __init__(self, *, date_obj=None, period=None, locale=None): + def __init__( + self, + *, + date_obj: datetime | None = None, + period: str | None = None, + locale: str | None = None, + ) -> None: self.date_obj = date_obj self.period = period self.locale = locale - def __getitem__(self, k): + def __getitem__(self, k: str) -> Any: if not hasattr(self, k): raise KeyError(k) return getattr(self, k) - def __setitem__(self, k, v): + def __setitem__(self, k: str, v: Any) -> None: if not hasattr(self, k): raise KeyError(k) setattr(self, k, v) - def __repr__(self): + def __repr__(self) -> str: properties_text = ", ".join( f"{prop}={val!r}" for prop, val in self.__dict__.items() ) @@ -531,19 +554,20 @@ class DateDataParser: ``SettingValidationError``: A provided setting is not valid. """ - locale_loader = None + locale_loader: LocaleDataLoader | None = None @apply_settings def __init__( self, - languages=None, - locales=None, - region=None, - try_previous_locales=False, - use_given_order=False, - settings=None, - detect_languages_function=None, - ): + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + try_previous_locales: bool = False, + use_given_order: bool = False, + settings: Settings | dict[str, Any] | None = None, + detect_languages_function: Callable[..., list[str]] | None = None, + ) -> None: + assert isinstance(settings, Settings) if languages is not None and not isinstance( languages, (list, tuple, AbstractSet) ): @@ -583,12 +607,16 @@ def __init__( self.locales = locales self.region = region self.detect_languages_function = detect_languages_function - self.previous_locales = collections.OrderedDict() + self.previous_locales: collections.OrderedDict[Locale, None] = ( + collections.OrderedDict() + ) # Guards the per-instance state mutated when a parser is shared by # multiple threads (previous_locales and the lazily detected languages). self._lock = threading.RLock() - def get_date_data(self, date_string, date_formats=None): + def get_date_data( + self, date_string: str, date_formats: Iterable[str] | None = None + ) -> DateData: """ Parse string representing date and/or time in recognizable localized formats. Supports parsing multiple languages and timezones. @@ -653,8 +681,11 @@ def get_date_data(self, date_string, date_formats=None): return parsed_date or DateData(date_obj=None, period="day", locale=None) def _parse_using_applicable_locales( - self, date_string, date_formats, ignore_surrounding_text=False - ): + self, + date_string: str, + date_formats: Iterable[str] | None, + ignore_surrounding_text: bool = False, + ) -> DateData | None: for locale in self._get_applicable_locales( date_string, ignore_surrounding_text=ignore_surrounding_text ): @@ -673,13 +704,16 @@ def _parse_using_applicable_locales( return parsed_date return None - def get_date_tuple(self, *args, **kwargs): + def get_date_tuple(self, *args: Any, **kwargs: Any) -> tuple[Any, ...]: date_data = self.get_date_data(*args, **kwargs) fields = date_data.__dict__.keys() - date_tuple = collections.namedtuple("DateData", fields) # noqa: PYI024 - return date_tuple(**date_data.__dict__) + date_tuple = collections.namedtuple("DateData", fields) # type: ignore[misc] # noqa: PYI024 + result: tuple[Any, ...] = date_tuple(**date_data.__dict__) + return result - def _get_applicable_locales(self, date_string, ignore_surrounding_text=False): + def _get_applicable_locales( + self, date_string: str, ignore_surrounding_text: bool = False + ) -> Iterator["Locale"]: # The given order is preserved if requested either through the # ``use_given_order`` constructor argument or the # ``USE_GIVEN_LANGUAGE_ORDER`` setting (which also reaches the @@ -689,13 +723,14 @@ def _get_applicable_locales(self, date_string, ignore_surrounding_text=False): self.use_given_order or self._settings.USE_GIVEN_LANGUAGE_ORDER ) - pop_tz_cache = [] + pop_tz_cache: list[str | None] = [] - def date_strings(): + def date_strings() -> Iterator[str]: """A generator instead of a static list to avoid calling pop_tz_offset_from_string if the first locale matches on unmodified date_string. """ + stripped_date_string: str | None yield date_string if not pop_tz_cache: stripped_date_string, _ = pop_tz_offset_from_string( @@ -743,7 +778,12 @@ def date_strings(): ): yield locale - def _is_applicable_locale(self, locale, date_string, ignore_surrounding_text=False): + def _is_applicable_locale( + self, + locale: "Locale", + date_string: str, + ignore_surrounding_text: bool = False, + ) -> bool: return locale.is_applicable( date_string, strip_timezone=False, # it is stripped outside @@ -754,7 +794,7 @@ def _is_applicable_locale(self, locale, date_string, ignore_surrounding_text=Fal _locale_loader_lock = threading.Lock() @classmethod - def _get_locale_loader(cls): + def _get_locale_loader(cls) -> LocaleDataLoader: if not cls.locale_loader: with cls._locale_loader_lock: if not cls.locale_loader: diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py index c650db7e2..e89a160af 100644 --- a/dateparser/date_parser.py +++ b/dateparser/date_parser.py @@ -1,11 +1,22 @@ -from .conf import apply_settings +from collections.abc import Callable +from datetime import datetime +from typing import Any + +from .conf import Settings, apply_settings from .timezone_parser import pop_tz_offset_from_string from .utils import _get_localzone, apply_timezone, localize_timezone, strip_braces class DateParser: @apply_settings - def parse(self, date_string, parse_method, settings=None, date_order=None): + def parse( + self, + date_string: str, + parse_method: Callable[..., tuple[datetime, str | None]], + settings: Settings | dict[str, Any] | None = None, + date_order: str | None = None, + ) -> tuple[datetime, str | None]: + assert isinstance(settings, Settings) date_string = str(date_string) if not date_string.strip(): diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index e682c0b93..68aab17e2 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -1,5 +1,6 @@ import contextlib -from datetime import datetime, time, timezone +from datetime import datetime, time, timezone, tzinfo +from typing import TYPE_CHECKING, Any import regex as re from dateutil.relativedelta import relativedelta @@ -14,6 +15,10 @@ from .parser import time_parser from .timezone_parser import pop_tz_offset_from_string +if TYPE_CHECKING: + from .conf import Settings + from .date import DateData + _UNITS = r"decade|year|month|week|day|hour|minute|second" PATTERN = re.compile(rf"([+-]?\s*\d++[.,]?\d*+)\s*({_UNITS})\b", re.I | re.S | re.U) @@ -21,7 +26,7 @@ class FreshnessDateDataParser: """Parses date string like "1 year, 2 months ago" and "3 hours, 50 minutes ago".""" - def _are_all_words_units(self, date_string): + def _are_all_words_units(self, date_string: str) -> bool: skip = [_UNITS, r"ago|in|\d+", r":|[ap]m"] date_string = re.sub(r"\s+", " ", date_string.strip()) @@ -30,25 +35,28 @@ def _are_all_words_units(self, date_string): words = [x for x in words if not re.match("|".join(skip), x)] return not words - def _parse_time(self, date_string, settings): + def _parse_time(self, date_string: str, settings: "Settings") -> time | None: """Attempts to parse time part of date strings like '1 day ago, 2 PM'""" date_string = PATTERN.sub("", date_string) date_string = re.sub(r"\b(?:ago|in)\b", "", date_string) with contextlib.suppress(Exception): return time_parser(date_string) + return None - def get_local_tz(self): + def get_local_tz(self) -> tzinfo: return _get_localzone() - def parse(self, date_string, settings): # noqa: PLR0912 + def parse( # noqa: PLR0912 + self, date_string: str, settings: "Settings" + ) -> tuple[datetime | None, str | None]: date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) _time = self._parse_time(date_string, settings) _settings_tz = settings.TIMEZONE.lower() - def apply_time(dateobj, timeobj): - if not isinstance(_time, time): + def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: + if not isinstance(timeobj, time): return dateobj return dateobj.replace( @@ -104,7 +112,9 @@ def apply_time(dateobj, timeobj): return date, period - def _parse_date(self, date_string, now, prefer_dates_from): + def _parse_date( + self, date_string: str, now: datetime, prefer_dates_from: str + ) -> tuple[datetime, str] | tuple[None, None]: if not self._are_all_words_units(date_string): return None, None @@ -129,7 +139,7 @@ def _parse_date(self, date_string, now, prefer_dates_from): and not re.search(r"\bago\b", date_string) ) - adjusted_kwargs = {} + adjusted_kwargs: dict[str, Any] = {} for key, value in kwargs.items(): if explicit_signs.get(key, False) or going_forward: adjusted_kwargs[key] = value @@ -151,13 +161,15 @@ def _parse_date(self, date_string, now, prefer_dates_from): return date, period - def get_kwargs(self, date_string): + def get_kwargs( + self, date_string: str + ) -> tuple[dict[str, float], dict[str, bool]] | dict[str, float]: m = PATTERN.findall(date_string) if not m: return {} - kwargs = {} - explicit_signs = {} + kwargs: dict[str, float] = {} + explicit_signs: dict[str, bool] = {} for num, unit in m: has_explicit_sign = num.startswith(("+", "-")) @@ -166,7 +178,7 @@ def get_kwargs(self, date_string): return kwargs, explicit_signs - def get_date_data(self, date_string, settings=None): + def get_date_data(self, date_string: str, settings: "Settings") -> "DateData": from dateparser.date import DateData # noqa: PLC0415 date, period = self.parse(date_string, settings) diff --git a/dateparser/languages/__init__.py b/dateparser/languages/__init__.py index 7270a7b93..2f14a878d 100644 --- a/dateparser/languages/__init__.py +++ b/dateparser/languages/__init__.py @@ -1,2 +1,2 @@ -from .loader import default_loader -from .locale import Locale +from .loader import default_loader as default_loader +from .locale import Locale as Locale diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index 1b8993531..0572c2197 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -1,13 +1,19 @@ import threading +from collections.abc import Iterable, Iterator from itertools import chain, zip_longest from operator import methodcaller -from typing import ClassVar +from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, cast import regex as re from dateparser.timezone_parser import is_timezone_token from dateparser.utils import normalize_unicode +if TYPE_CHECKING: + from dateparser.conf import Settings + +_T = TypeVar("_T") + PARSER_HARDCODED_TOKENS = [":", ".", " ", "-", "/"] PARSER_KNOWN_TOKENS = ["am", "pm", "UTC", "GMT", "Z"] ALWAYS_KEEP_TOKENS = ["+", *PARSER_HARDCODED_TOKENS] @@ -57,7 +63,7 @@ class UnknownTokenError(Exception): pass -def _parse_bool(value): +def _parse_bool(value: object) -> bool: if isinstance(value, bool): return value if isinstance(value, str): @@ -91,17 +97,19 @@ class Dictionary: # concurrent eviction cannot drop an entry between its check and its read. _cache_lock = threading.RLock() - def __init__(self, locale_info, settings=None): - dictionary = {} - self._settings = settings + def __init__( + self, locale_info: dict[str, Any], settings: "Settings | None" = None + ) -> None: + dictionary: dict[str, str | None] = {} + self._settings = cast("Settings", settings) self.info = locale_info if "skip" in locale_info: skip = map(methodcaller("lower"), locale_info["skip"]) - dictionary.update(zip_longest(skip, [], fillvalue=None)) + dictionary.update(dict.fromkeys(skip)) if "pertain" in locale_info: pertain = map(methodcaller("lower"), locale_info["pertain"]) - dictionary.update(zip_longest(pertain, [], fillvalue=None)) + dictionary.update(dict.fromkeys(pertain)) for word in KNOWN_WORD_TOKENS: if word in locale_info: translations = map(methodcaller("lower"), locale_info[word]) @@ -120,7 +128,7 @@ def __init__(self, locale_info, settings=None): if word in locale_info: for token in map(methodcaller("lower"), locale_info[word]): weekday_translations[token] = word - self._month_translations = set() + self._month_translations: set[str] = set() for word in _MONTH_TOKENS: if word in locale_info: self._month_translations.update( @@ -152,7 +160,7 @@ def __init__(self, locale_info, settings=None): relative_type_regex = locale_info.get("relative-type-regex", {}) self._relative_strings = list(chain.from_iterable(relative_type_regex.values())) - def _is_unambiguous_month(self, token): + def _is_unambiguous_month(self, token: str) -> bool: """ Whether ``token`` (already lowercased) names a month and, unlike the tokens in :attr:`_weekday_month_conflicts`, cannot also mean a weekday. @@ -162,20 +170,20 @@ def _is_unambiguous_month(self, token): and token not in self._weekday_month_conflicts ) - def __contains__(self, key): + def __contains__(self, key: object) -> bool: if key in self._settings.SKIP_TOKENS: return True return self._dictionary.__contains__(key) - def __getitem__(self, key): + def __getitem__(self, key: str) -> str | None: if key in self._settings.SKIP_TOKENS: return None return self._dictionary.__getitem__(key) - def __iter__(self): + def __iter__(self) -> Iterator[str]: return chain(self._settings.SKIP_TOKENS, iter(self._dictionary)) - def are_tokens_valid(self, tokens): + def are_tokens_valid(self, tokens: Iterable[str]) -> bool: """ Check if tokens are valid tokens for the locale. @@ -193,7 +201,9 @@ def are_tokens_valid(self, tokens): self._is_known_token(token, match_relative_regex) for token in tokens ) - def _is_known_token(self, token, match_relative_regex): + def _is_known_token( + self, token: str, match_relative_regex: re.Pattern[str] + ) -> bool: """Whether ``token`` is recognised by this locale: a number, a relative expression, or a dictionary word (the same per-token check that :meth:`are_tokens_valid` applies).""" @@ -201,7 +211,7 @@ def _is_known_token(self, token, match_relative_regex): token.isdigit() or match_relative_regex.match(token) or token in self ) - def _strip_unknown_edge_tokens(self, tokens): + def _strip_unknown_edge_tokens(self, tokens: list[str]) -> list[str]: """Return ``tokens`` without the leading and trailing tokens that this locale does not recognise (neither digits, relative expressions, nor dictionary words), along with any whitespace those removals leave at @@ -223,7 +233,7 @@ def _strip_unknown_edge_tokens(self, tokens): keeps stripping unrecognized tokens unconditionally.""" match_relative_regex = self._get_match_relative_regex_cache() - def is_extra_text(token): + def is_extra_text(token: str) -> bool: return token.isspace() or not self._is_known_token( token, match_relative_regex ) @@ -243,7 +253,7 @@ def is_extra_text(token): end -= 1 return tokens[start:end] - def split(self, string, keep_formatting=False): + def split(self, string: str, keep_formatting: bool = False) -> list[str]: """ Split the date string using translations in locale info. @@ -259,12 +269,12 @@ def split(self, string, keep_formatting=False): :return: A list of string tokens formed after splitting the date string. """ if not string: - return string + return [] split_relative_regex = self._get_split_relative_regex_cache() match_relative_regex = self._get_match_relative_regex_cache() - tokens = split_relative_regex.split(string) + tokens: list[Any] = split_relative_regex.split(string) for i, token in enumerate(tokens): if match_relative_regex.match(token): @@ -274,7 +284,7 @@ def split(self, string, keep_formatting=False): return list(filter(bool, chain.from_iterable(tokens))) - def _add_to_cache(self, value, cache): + def _add_to_cache(self, value: _T, cache: dict[str, dict[str, _T]]) -> None: with self._cache_lock: key = self._settings.registry_key entry = cache.pop(key, {}) @@ -286,9 +296,9 @@ def _add_to_cache(self, value, cache): ): cache.pop(next(iter(cache))) - def _split_by_known_words(self, string: str, keep_formatting: bool): + def _split_by_known_words(self, string: str, keep_formatting: bool) -> list[str]: regex = self._get_split_regex_cache() - splitted = [] + splitted: list[str] = [] unknown = string while unknown: @@ -327,21 +337,23 @@ def _split_by_known_words(self, string: str, keep_formatting: bool): return splitted - def _split_by_numerals(self, string, keep_formatting): + def _split_by_numerals(self, string: str, keep_formatting: bool) -> list[str]: return [ token for token in NUMERAL_PATTERN.split(string) if self._should_capture(token, keep_formatting) ] - def _should_capture(self, token, keep_formatting): + def _should_capture( + self, token: str, keep_formatting: bool + ) -> bool | re.Match[str] | None: return ( keep_formatting or token in ALWAYS_KEEP_TOKENS or KEEP_TOKEN_PATTERN.match(token) ) - def _get_sorted_words_from_cache(self): + def _get_sorted_words_from_cache(self) -> list[str]: with self._cache_lock: if ( self._settings.registry_key not in self._sorted_words_cache @@ -356,7 +368,7 @@ def _get_sorted_words_from_cache(self): self.info["name"] ] - def _get_split_regex_cache(self): + def _get_split_regex_cache(self) -> re.Pattern[str]: with self._cache_lock: if ( self._settings.registry_key not in self._split_regex_cache @@ -368,7 +380,7 @@ def _get_split_regex_cache(self): self.info["name"] ] - def _construct_split_regex(self): + def _construct_split_regex(self) -> None: known_words_group = "|".join( map(re.escape, self._get_sorted_words_from_cache()) ) @@ -381,7 +393,7 @@ def _construct_split_regex(self): value=re.compile(regex, re.UNICODE | re.IGNORECASE), ) - def _get_sorted_relative_strings_from_cache(self): + def _get_sorted_relative_strings_from_cache(self) -> list[str]: with self._cache_lock: if ( self._settings.registry_key not in self._sorted_relative_strings_cache @@ -403,7 +415,7 @@ def _get_sorted_relative_strings_from_cache(self): self.info["name"] ] - def _get_split_relative_regex_cache(self): + def _get_split_relative_regex_cache(self) -> re.Pattern[str]: with self._cache_lock: if ( self._settings.registry_key not in self._split_relative_regex_cache @@ -415,7 +427,7 @@ def _get_split_relative_regex_cache(self): self.info["name"] ] - def _construct_split_relative_regex(self): + def _construct_split_relative_regex(self) -> None: known_relative_strings_group = "|".join( self._get_sorted_relative_strings_from_cache() ) @@ -430,7 +442,7 @@ def _construct_split_relative_regex(self): value=re.compile(regex, re.UNICODE | re.IGNORECASE), ) - def _get_match_relative_regex_cache(self): + def _get_match_relative_regex_cache(self) -> re.Pattern[str]: with self._cache_lock: if ( self._settings.registry_key not in self._match_relative_regex_cache @@ -442,7 +454,7 @@ def _get_match_relative_regex_cache(self): self.info["name"] ] - def _construct_match_relative_regex(self): + def _construct_match_relative_regex(self) -> None: known_relative_strings_group = "|".join( self._get_sorted_relative_strings_from_cache() ) @@ -454,12 +466,14 @@ def _construct_match_relative_regex(self): class NormalizedDictionary(Dictionary): - def __init__(self, locale_info, settings=None): + def __init__( + self, locale_info: dict[str, Any], settings: "Settings | None" = None + ) -> None: super().__init__(locale_info, settings) self._normalize() - def _normalize(self): - new_dict = {} + def _normalize(self) -> None: + new_dict: dict[str, str | None] = {} conflicting_keys = [] for key, value in self._dictionary.items(): normalized = normalize_unicode(key) diff --git a/dateparser/languages/loader.py b/dateparser/languages/loader.py index 56a4ee90e..b60e5640e 100644 --- a/dateparser/languages/loader.py +++ b/dateparser/languages/loader.py @@ -1,5 +1,6 @@ import threading from collections import OrderedDict +from collections.abc import Iterable, Iterator from copy import deepcopy from importlib import import_module from itertools import zip_longest @@ -7,14 +8,14 @@ import regex as re -from dateparser.data import language_locale_dict, language_order +from dateparser.data.languages_info import language_locale_dict, language_order from .locale import Locale LOCALE_SPLIT_PATTERN = re.compile(r"-(?=[A-Z0-9]+$)") -def _isvalidlocale(locale): +def _isvalidlocale(locale: str) -> bool: language = LOCALE_SPLIT_PATTERN.split(locale)[0] if language not in language_order: return False @@ -22,14 +23,14 @@ def _isvalidlocale(locale): return locale == language or locale in locales_list -def _filter_valid_locales(locales): +def _filter_valid_locales(locales: Iterable[str]) -> list[str]: return [locale for locale in locales if _isvalidlocale(locale)] -def _construct_locales(languages, region): +def _construct_locales(languages: Iterable[str], region: str) -> Iterable[str]: if region: possible_locales = [language + "-" + region for language in languages] - locales = _filter_valid_locales(possible_locales) + locales: Iterable[str] = _filter_valid_locales(possible_locales) else: locales = languages return locales @@ -44,12 +45,12 @@ class LocaleDataLoader: def get_locale_map( self, - languages=None, - locales=None, - region=None, - use_given_order=False, - allow_conflicting_locales=False, - ): + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + use_given_order: bool = False, + allow_conflicting_locales: bool = False, + ) -> OrderedDict[str, Locale]: """ Get an ordered mapping with locale codes as keys and corresponding locale instances as values. @@ -93,12 +94,12 @@ def get_locale_map( def get_locales( self, - languages=None, - locales=None, - region=None, - use_given_order=False, - allow_conflicting_locales=False, - ): + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + use_given_order: bool = False, + allow_conflicting_locales: bool = False, + ) -> Iterator[Locale]: """ Yield locale instances. @@ -138,7 +139,7 @@ def get_locales( ): yield locale - def get_locale(self, shortname): + def get_locale(self, shortname: str) -> Locale: """ Get a locale instance. @@ -152,20 +153,20 @@ def get_locale(self, shortname): def _load_data( # noqa: PLR0912 self, - languages=None, - locales=None, - region=None, - use_given_order=False, - allow_conflicting_locales=False, - ): - locale_dict = {} + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + use_given_order: bool = False, + allow_conflicting_locales: bool = False, + ) -> Iterator[tuple[str, Locale]]: + locale_dict: dict[str, tuple[str, ...]] = {} if locales: invalid_locales = [] for locale in locales: - lang_reg = LOCALE_SPLIT_PATTERN.split(locale) - if len(lang_reg) == 1: - lang_reg.append("") - locale_dict[locale] = tuple(lang_reg) + split_locale = LOCALE_SPLIT_PATTERN.split(locale) + if len(split_locale) == 1: + split_locale.append("") + locale_dict[locale] = tuple(split_locale) if not _isvalidlocale(locale): invalid_locales.append(locale) if invalid_locales: @@ -207,7 +208,7 @@ def _load_data( # noqa: PLR0912 if shortname not in self._loaded_locales: lang, _reg = lang_reg if lang in self._loaded_languages: - locale = Locale( + locale_obj = Locale( shortname, language_info=deepcopy(self._loaded_languages[lang]), ) @@ -217,15 +218,15 @@ def _load_data( # noqa: PLR0912 "dateparser.data.date_translation_data." + lang ) ).info - locale = Locale( + locale_obj = Locale( shortname, language_info=deepcopy(language_info) ) self._loaded_languages[lang] = language_info # Store only once fully built so concurrent readers never see # a half-initialised locale. - self._loaded_locales[shortname] = locale - locale = self._loaded_locales[shortname] - yield shortname, locale + self._loaded_locales[shortname] = locale_obj + locale_obj = self._loaded_locales[shortname] + yield shortname, locale_obj default_loader = LocaleDataLoader() diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 4c5316f12..2684a0fc5 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -1,19 +1,26 @@ import copy import threading +from collections.abc import Iterable, Iterator, Mapping, Sequence from itertools import chain +from typing import TYPE_CHECKING, Any, TypeVar import regex as re -from dateutil import parser from dateparser.timezone_parser import pop_tz_offset_from_string, word_is_tz from dateparser.utils import combine_dicts, normalize_unicode from .dictionary import ALWAYS_KEEP_TOKENS, Dictionary, NormalizedDictionary +if TYPE_CHECKING: + from dateparser.conf import Settings + +_D = TypeVar("_D", bound=Dictionary) +_T = TypeVar("_T") + NUMERAL_PATTERN = re.compile(r"(\d+)", re.U) -def _parse_bool(value): +def _parse_bool(value: object) -> bool: if isinstance(value, bool): return value if isinstance(value, str): @@ -42,19 +49,19 @@ class Locale: :return: A Locale instance """ - _dictionary = None - _normalized_dictionary = None - _simplifications = None - _normalized_simplifications = None - _splitters = None - _wordchars = None - _relative_translations = None - _normalized_relative_translations = None - _abbreviations = None - _split_dictionary = None - _wordchars_for_detection = None - - def __init__(self, shortname, language_info): + _dictionary: Dictionary | None = None + _normalized_dictionary: NormalizedDictionary | None = None + _simplifications: list[dict[re.Pattern[str], str]] | None = None + _normalized_simplifications: list[dict[re.Pattern[str], str]] | None = None + _splitters: dict[str, set[str]] | None = None + _wordchars: set[str] | None = None + _relative_translations: dict[re.Pattern[str], str] | None = None + _normalized_relative_translations: dict[re.Pattern[str], str] | None = None + _abbreviations: list[str] | None = None + _split_dictionary: dict[str, str | None] | None = None + _wordchars_for_detection: set[str] | None = None + + def __init__(self, shortname: str, language_info: Mapping[str, Any]) -> None: self.shortname = shortname locale_specific_info = language_info.get("locale_specific", {}).get( shortname, {} @@ -67,11 +74,11 @@ def __init__(self, shortname, language_info): def is_applicable( self, - date_string, - strip_timezone=False, - settings=None, - ignore_surrounding_text=False, - ): + date_string: str, + strip_timezone: bool = False, + settings: "Settings | None" = None, + ignore_surrounding_text: bool = False, + ) -> bool: """ Check if the locale is applicable to translate date string. @@ -94,6 +101,7 @@ def is_applicable( date_string, _ = pop_tz_offset_from_string(date_string, as_offset=False) date_string = self._translate_numerals(date_string) + assert settings is not None if settings.NORMALIZE: date_string = normalize_unicode(date_string) date_string = self._simplify(date_string, settings=settings) @@ -103,7 +111,12 @@ def is_applicable( date_tokens = dictionary._strip_unknown_edge_tokens(date_tokens) return dictionary.are_tokens_valid(date_tokens) - def count_applicability(self, text, strip_timezone=False, settings=None): + def count_applicability( + self, + text: str, + strip_timezone: bool = False, + settings: "Settings | None" = None, + ) -> list[int]: if strip_timezone: text, _ = pop_tz_offset_from_string(text, as_offset=False) @@ -114,7 +127,9 @@ def count_applicability(self, text, strip_timezone=False, settings=None): tokens.extend(self._split(sent, keep_formatting=False, settings=settings)) return self._count_words_present_in_the_dictionary(tokens, settings) - def _count_words_present_in_the_dictionary(self, words, settings=None): + def _count_words_present_in_the_dictionary( + self, words: Iterable[str], settings: "Settings | None" = None + ) -> list[int]: dictionary = self.clean_dictionary( self._get_split_dictionary(settings=settings) ) @@ -131,7 +146,9 @@ def _count_words_present_in_the_dictionary(self, words, settings=None): return [dict_cnt, skip_cnt] @staticmethod - def clean_dictionary(dictionary, threshold=2): + def clean_dictionary( + dictionary: dict[str, _T], threshold: int = 2 + ) -> dict[str, _T]: del_keys = [key for key in dictionary if len(key) < threshold] for del_key in del_keys: del dictionary[del_key] @@ -139,11 +156,11 @@ def clean_dictionary(dictionary, threshold=2): def translate( # noqa: PLR0912 self, - date_string, - keep_formatting=False, - settings=None, - ignore_surrounding_text=False, - ): + date_string: str, + keep_formatting: bool = False, + settings: "Settings | None" = None, + ignore_surrounding_text: bool = False, + ) -> str: """ Translate the date string to its English equivalent. @@ -164,6 +181,7 @@ def translate( # noqa: PLR0912 :return: translated date string. """ date_string = self._translate_numerals(date_string) + assert settings is not None if settings.NORMALIZE: date_string = normalize_unicode(date_string) date_string = self._simplify(date_string, settings=settings) @@ -205,7 +223,7 @@ def translate( # noqa: PLR0912 # Remove empty tokens (skip words) and handle adjacent whitespace # When a skip token is removed between spaces, keep the maximum number of spaces - filtered_tokens = [] + filtered_tokens: list[str] = [] i = 0 while i < len(date_string_tokens): token = date_string_tokens[i] @@ -252,14 +270,17 @@ def translate( # noqa: PLR0912 settings=settings, ) - def _translate_numerals(self, date_string): + def _translate_numerals(self, date_string: str) -> str: date_string_tokens = NUMERAL_PATTERN.split(date_string) for i, token in enumerate(date_string_tokens): if token.isdecimal(): date_string_tokens[i] = str(int(token)).zfill(len(token)) return "".join(date_string_tokens) - def _get_relative_translations(self, settings=None): + def _get_relative_translations( + self, settings: "Settings | None" = None + ) -> dict[re.Pattern[str], str]: + assert settings is not None with self._lock: if settings.NORMALIZE: if self._normalized_relative_translations is None: @@ -273,30 +294,36 @@ def _get_relative_translations(self, settings=None): ) return self._relative_translations - def _generate_relative_translations(self, normalize=False): + def _generate_relative_translations( + self, normalize: bool = False + ) -> dict[re.Pattern[str], str]: relative_translations = self.info.get("relative-type-regex", {}) relative_dictionary = {} for key, value in relative_translations.items(): translations = map(normalize_unicode, value) if normalize else value pattern = "|".join(sorted(translations, key=len, reverse=True)) pattern = pattern.replace(r"(\d+", r"(?P\d+") - pattern = re.compile(rf"^(?:{pattern})$", re.UNICODE | re.IGNORECASE) - relative_dictionary[pattern] = key + compiled_pattern = re.compile( + rf"^(?:{pattern})$", re.UNICODE | re.IGNORECASE + ) + relative_dictionary[compiled_pattern] = key return relative_dictionary - def translate_search(self, search_string, settings=None): # noqa: PLR0912 + def translate_search( # noqa: PLR0912 + self, search_string: str, settings: "Settings | None" = None + ) -> tuple[list[str], list[str]]: dashes = ["-", "——", "—", "~"] word_joint_unsupported_languages = ["zh", "ja"] sentences = self._sentence_split(search_string, settings=settings) dictionary = self._get_dictionary(settings=settings) - translated = [] - original = [] + translated: list[Any] = [] + original: list[Any] = [] for sentence in sentences: original_tokens, simplified_tokens = self._simplify_split_align( sentence, settings=settings ) - translated_chunk = [] - original_chunk = [] + translated_chunk: list[str | None] = [] + original_chunk: list[str] = [] last_token_index = len(simplified_tokens) - 1 skip_next_token = False for i, word in enumerate(simplified_tokens): @@ -330,10 +357,11 @@ def translate_search(self, search_string, settings=None): # noqa: PLR0912 elif word.strip(PUNCTUATION) in dictionary and word not in dashes: bare_word = word.strip(PUNCTUATION) punct = word[len(bare_word) :] - if punct and dictionary[bare_word]: - translated_chunk.append(dictionary[bare_word] + punct) + bare_translation = dictionary[bare_word] + if punct and bare_translation: + translated_chunk.append(bare_translation + punct) else: - translated_chunk.append(dictionary[bare_word]) + translated_chunk.append(bare_translation) original_chunk.append(original_tokens[i]) elif self._token_with_digits_is_ok(word) or ( translated_chunk and word_is_tz(original_tokens[i]) @@ -359,7 +387,7 @@ def translate_search(self, search_string, settings=None): # noqa: PLR0912 ) return translated, original - def _get_abbreviations(self, settings): + def _get_abbreviations(self, settings: "Settings | None") -> list[str]: dictionary = self._get_dictionary(settings=settings) with self._lock: if self._abbreviations is None: @@ -368,7 +396,9 @@ def _get_abbreviations(self, settings): ] return self._abbreviations - def _sentence_split(self, string, settings): + def _sentence_split( + self, string: str, settings: "Settings | None" + ) -> Iterator[str]: abbreviations = self._get_abbreviations(settings=settings) digit_abbreviations = ["[0-9]"] # numeric date with full stop abbreviation_string = "" @@ -404,7 +434,9 @@ def _sentence_split(self, string, settings): return filter(None, sentences) - def _simplify_split_align(self, original, settings): # noqa: PLR0912 + def _simplify_split_align( # noqa: PLR0912 + self, original: str, settings: "Settings | None" + ) -> tuple[list[str], list[str]]: # TODO: Switch to new split method. original_tokens = self._word_split(original, settings=settings) simplified_tokens = self._word_split( @@ -448,7 +480,10 @@ def _simplify_split_align(self, original, settings): # noqa: PLR0912 simplified_tokens.remove("") return original_tokens, simplified_tokens - def _get_split_dictionary(self, settings): + def _get_split_dictionary( + self, settings: "Settings | None" + ) -> dict[str, str | None]: + assert settings is not None with self._lock: if self._split_dictionary is None: # The split dictionary is always built from the normalized @@ -459,7 +494,7 @@ def _get_split_dictionary(self, settings): self._split_dictionary = self._split_dict(dictionary) return self._split_dictionary - def _split_dict(self, dictionary): + def _split_dict(self, dictionary: Dictionary) -> dict[str, str | None]: newdict = {} for item in dictionary: if " " in item: @@ -470,12 +505,17 @@ def _split_dict(self, dictionary): newdict[item] = dictionary[item] return newdict - def _word_split(self, string, settings): + def _word_split(self, string: str, settings: "Settings | None") -> list[str]: if "no_word_spacing" in self.info: return self._split(string, keep_formatting=True, settings=settings) return string.split() - def _split(self, date_string, keep_formatting, settings=None): + def _split( + self, + date_string: str, + keep_formatting: bool, + settings: "Settings | None" = None, + ) -> list[str]: tokens = [date_string] tokens = list(self._split_tokens_with_regex(tokens, r"(\d+)")) return list( @@ -484,30 +524,35 @@ def _split(self, date_string, keep_formatting, settings=None): ) ) - def _split_tokens_with_regex(self, tokens, regex): + def _split_tokens_with_regex(self, tokens: list[Any], regex: str) -> Iterator[str]: tokens = tokens[:] for i, token in enumerate(tokens): tokens[i] = re.split(regex, token) return filter(bool, chain.from_iterable(tokens)) - def _split_tokens_by_known_words(self, tokens, keep_formatting, settings=None): + def _split_tokens_by_known_words( + self, + tokens: list[Any], + keep_formatting: bool, + settings: "Settings | None" = None, + ) -> list[str]: dictionary = self._get_dictionary(settings) for i, token in enumerate(tokens): tokens[i] = dictionary.split(token, keep_formatting) return list(chain.from_iterable(tokens)) - def _join_chunk(self, chunk, settings): + def _join_chunk(self, chunk: Sequence[str], settings: "Settings | None") -> str: if "no_word_spacing" in self.info: return self._join(chunk, separator="", settings=settings) return re.sub(r"\s{2,}", " ", " ".join(chunk)) - def _token_with_digits_is_ok(self, token): + def _token_with_digits_is_ok(self, token: str) -> bool: if "no_word_spacing" in self.info: return re.search(r"[\d\.:\-/]+", token) is not None return re.search(r"\d+", token) is not None - def _simplify(self, date_string, settings=None): + def _simplify(self, date_string: str, settings: "Settings | None" = None) -> str: date_string = date_string.lower() simplifications = self._get_simplifications(settings=settings) @@ -520,17 +565,25 @@ def _simplify(self, date_string, settings=None): return date_string - def _apply_simplifications(self, date_string, simplifications): + def _apply_simplifications( + self, + date_string: str, + simplifications: Iterable[Mapping[re.Pattern[str], str]], + ) -> str: for simplification in simplifications: pattern, replacement = next(iter(simplification.items())) date_string = pattern.sub(replacement, date_string).lower() return date_string - def _process_russian_compound_ordinals(self, date_string, simplifications): + def _process_russian_compound_ordinals( + self, + date_string: str, + simplifications: Iterable[Mapping[re.Pattern[str], str]], + ) -> str: """Process Russian compound ordinals mathematically (двадцать + первое = 21).""" date_string = self._apply_simplifications(date_string, simplifications) - def replace_number_pairs(match): + def replace_number_pairs(match: re.Match[str]) -> str: first_num = int(match.group(1)) second_num = int(match.group(2)) result = first_num + second_num @@ -541,8 +594,11 @@ def replace_number_pairs(match): number_pair_pattern = r"\b(\d+)\s+(\d+)\b" return re.sub(number_pair_pattern, replace_number_pairs, date_string) - def _get_simplifications(self, settings=None): + def _get_simplifications( + self, settings: "Settings | None" = None + ) -> list[dict[re.Pattern[str], str]]: no_word_spacing = _parse_bool(self.info.get("no_word_spacing", False)) + assert settings is not None with self._lock: if settings.NORMALIZE: if self._normalized_simplifications is None: @@ -552,8 +608,10 @@ def _get_simplifications(self, settings=None): pattern, replacement = next(iter(simplification.items())) if not no_word_spacing: pattern = rf"(?<=\A|\W|_){pattern}(?=\Z|\W|_)" - pattern = re.compile(pattern, flags=re.I | re.U) - normalized_simplifications.append({pattern: replacement}) + compiled_pattern = re.compile(pattern, flags=re.I | re.U) + normalized_simplifications.append( + {compiled_pattern: replacement} + ) # Assign only once fully built so other threads never observe # a partially-populated list. self._normalized_simplifications = normalized_simplifications @@ -566,15 +624,17 @@ def _get_simplifications(self, settings=None): pattern, replacement = next(iter(simplification.items())) if not no_word_spacing: pattern = rf"(?<=\A|\W|_){pattern}(?=\Z|\W|_)" - pattern = re.compile(pattern, flags=re.I | re.U) - simplifications_built.append({pattern: replacement}) + compiled_pattern = re.compile(pattern, flags=re.I | re.U) + simplifications_built.append({compiled_pattern: replacement}) self._simplifications = simplifications_built return self._simplifications - def _generate_simplifications(self, normalize=False): + def _generate_simplifications( + self, normalize: bool = False + ) -> list[dict[str, str]]: simplifications = [] for simplification in self.info.get("simplifications", []): - c_simplification = {} + c_simplification: dict[str, str] = {} key, value = next(iter(simplification.items())) if normalize: key = normalize_unicode(key) @@ -587,7 +647,7 @@ def _generate_simplifications(self, normalize=False): simplifications.append(c_simplification) return simplifications - def _clear_future_words(self, words): + def _clear_future_words(self, words: list[str]) -> list[str]: freshness_words = {"day", "week", "month", "year", "hour", "minute", "second"} # A unit keeps the punctuation it was written next to, so "2 hours," # becomes "hour,". That is still the unit of a future expression, and @@ -597,7 +657,12 @@ def _clear_future_words(self, words): words[words.index("in")] = "" return words - def _join(self, tokens, separator=" ", settings=None): + def _join( + self, + tokens: Sequence[str], + separator: str = " ", + settings: "Settings | None" = None, + ) -> str: if not tokens: return "" @@ -611,25 +676,30 @@ def _join(self, tokens, separator=" ", settings=None): return joined - def _get_dictionary(self, settings=None): + def _get_dictionary(self, settings: "Settings | None" = None) -> Dictionary: + assert settings is not None if not settings.NORMALIZE: return self._bind_settings(self._get_base_dictionary(), settings) return self._bind_settings(self._get_normalized_dictionary(settings), settings) - def _get_base_dictionary(self): + def _get_base_dictionary(self) -> Dictionary: with self._lock: if self._dictionary is None: self._generate_dictionary() + assert self._dictionary is not None return self._dictionary - def _get_normalized_dictionary(self, settings=None): + def _get_normalized_dictionary( + self, settings: "Settings | None" = None + ) -> NormalizedDictionary: with self._lock: if self._normalized_dictionary is None: self._generate_normalized_dictionary() + assert self._normalized_dictionary is not None return self._normalized_dictionary @staticmethod - def _bind_settings(dictionary, settings): + def _bind_settings(dictionary: _D, settings: "Settings") -> _D: # A shallow copy shares the heavy state (translations, regex caches) by # reference but gets its own settings, so the shared, cached dictionary # instance is not mutated per call. @@ -637,20 +707,22 @@ def _bind_settings(dictionary, settings): bound._settings = settings return bound - def _get_wordchars(self, settings=None): + def _get_wordchars(self, settings: "Settings | None" = None) -> set[str]: with self._lock: if self._wordchars is None: self._set_wordchars(settings) + assert self._wordchars is not None return self._wordchars - def _get_splitters(self, settings=None): + def _get_splitters(self, settings: "Settings | None" = None) -> dict[str, set[str]]: with self._lock: if self._splitters is None: self._set_splitters(settings) + assert self._splitters is not None return self._splitters - def _set_splitters(self, settings=None): - splitters = { + def _set_splitters(self, settings: "Settings | None" = None) -> None: + splitters: dict[str, set[str]] = { # The ones that split string only if they are not surrounded by letters from both sides: "wordchars": set(), # The ones that are not filtered out from tokens after split: @@ -668,8 +740,8 @@ def _set_splitters(self, settings=None): self._splitters = splitters - def _set_wordchars(self, settings=None): - wordchars = set() + def _set_wordchars(self, settings: "Settings | None" = None) -> None: + wordchars: set[str] = set() for word in self._get_dictionary(settings): if re.match(r"^[\W\d_]+$", word, re.UNICODE): continue @@ -689,11 +761,11 @@ def _set_wordchars(self, settings=None): "9", } - def get_wordchars_for_detection(self, settings): + def get_wordchars_for_detection(self, settings: "Settings | None") -> set[str]: with self._lock: if self._wordchars_for_detection is not None: return self._wordchars_for_detection - wordchars = set() + wordchars: set[str] = set() for word in self._get_dictionary(settings): if re.match(r"^[\W\d_]+$", word, re.UNICODE): continue @@ -722,40 +794,10 @@ def get_wordchars_for_detection(self, settings): } return self._wordchars_for_detection - def _generate_dictionary(self, settings=None): + def _generate_dictionary(self, settings: "Settings | None" = None) -> None: self._dictionary = Dictionary(self.info, settings=settings) - def _generate_normalized_dictionary(self, settings=None): + def _generate_normalized_dictionary( + self, settings: "Settings | None" = None + ) -> None: self._normalized_dictionary = NormalizedDictionary(self.info, settings=settings) - - def to_parserinfo(self, base_cls=parser.parserinfo): - attributes = { - "JUMP": self.info.get("skip", []), - "PERTAIN": self.info.get("pertain", []), - "WEEKDAYS": [ - self.info["monday"], - self.info["tuesday"], - self.info["wednesday"], - self.info["thursday"], - self.info["friday"], - self.info["saturday"], - self.info["sunday"], - ], - "MONTHS": [ - self.info["january"], - self.info["february"], - self.info["march"], - self.info["april"], - self.info["may"], - self.info["june"], - self.info["july"], - self.info["august"], - self.info["september"], - self.info["october"], - self.info["november"], - self.info["december"], - ], - "HMS": [self.info["hour"], self.info["minute"], self.info["second"]], - } - name = "{language}ParserInfo".format(language=self.info["name"]) - return type(name, bases=[base_cls], dict=attributes) diff --git a/dateparser/languages/validation.py b/dateparser/languages/validation.py index 2c57f281d..be4f51833 100644 --- a/dateparser/languages/validation.py +++ b/dateparser/languages/validation.py @@ -1,4 +1,5 @@ -from typing import ClassVar +import logging +from typing import Any, ClassVar import regex as re @@ -6,7 +7,7 @@ class LanguageValidator: - logger = None + logger: logging.Logger | None = None VALID_KEYS: ClassVar[list[str]] = [ "name", @@ -46,13 +47,13 @@ class LanguageValidator: ] @classmethod - def get_logger(cls): + def get_logger(cls) -> logging.Logger: if cls.logger is None: cls.logger = get_logger() return cls.logger @classmethod - def validate_info(cls, language_id, info): + def validate_info(cls, language_id: str, info: Any) -> bool: result = True result &= cls._validate_type(language_id, info) @@ -72,7 +73,7 @@ def validate_info(cls, language_id, info): return result @classmethod - def _validate_type(cls, language_id, info): + def _validate_type(cls, language_id: str, info: Any) -> bool: result = True if not isinstance(info, dict): @@ -85,7 +86,7 @@ def _validate_type(cls, language_id, info): return result @classmethod - def _validate_name(cls, language_id, info): + def _validate_name(cls, language_id: str, info: Any) -> bool: result = True if "name" not in info or not isinstance(info["name"], str) or not info["name"]: @@ -97,7 +98,7 @@ def _validate_name(cls, language_id, info): return result @classmethod - def _validate_word_spacing(cls, language_id, info): + def _validate_word_spacing(cls, language_id: str, info: Any) -> bool: if "no_word_spacing" not in info: return True # Optional key @@ -115,7 +116,7 @@ def _validate_word_spacing(cls, language_id, info): return result @classmethod - def _validate_sentence_splitter_group(cls, language_id, info): + def _validate_sentence_splitter_group(cls, language_id: str, info: Any) -> bool: if "sentence_splitter_group" not in info: return True # Optional key @@ -141,7 +142,7 @@ def _validate_sentence_splitter_group(cls, language_id, info): return result @classmethod - def _validate_skip_list(cls, language_id, info): + def _validate_skip_list(cls, language_id: str, info: Any) -> bool: if "skip" not in info: return True # Optional key @@ -168,7 +169,7 @@ def _validate_skip_list(cls, language_id, info): return result @classmethod - def _validate_pertain_list(cls, language_id, info): + def _validate_pertain_list(cls, language_id: str, info: Any) -> bool: if "pertain" not in info: return True # Optional key @@ -195,7 +196,7 @@ def _validate_pertain_list(cls, language_id, info): return result @classmethod - def _validate_weekdays(cls, language_id, info): + def _validate_weekdays(cls, language_id: str, info: Any) -> bool: result = True for weekday in ( @@ -240,7 +241,7 @@ def _validate_weekdays(cls, language_id, info): return result @classmethod - def _validate_months(cls, language_id, info): + def _validate_months(cls, language_id: str, info: Any) -> bool: result = True for month in ( @@ -290,7 +291,7 @@ def _validate_months(cls, language_id, info): return result @classmethod - def _validate_units(cls, language_id, info): + def _validate_units(cls, language_id: str, info: Any) -> bool: result = True for unit in "year", "month", "week", "day", "hour", "minute", "second": @@ -327,7 +328,7 @@ def _validate_units(cls, language_id, info): return result @classmethod - def _validate_other_words(cls, language_id, info): + def _validate_other_words(cls, language_id: str, info: Any) -> bool: result = True for word in ("ago",): @@ -364,7 +365,7 @@ def _validate_other_words(cls, language_id, info): return result @classmethod - def _validate_simplifications(cls, language_id, info): + def _validate_simplifications(cls, language_id: str, info: Any) -> bool: if "simplifications" not in info: return True # Optional key @@ -397,7 +398,7 @@ def _validate_simplifications(cls, language_id, info): replacements = re.findall(r"\\(\d+)", value) replacements.extend(re.findall(r"\\g<(.+?)>", value)) - groups = [] + groups: list[int] = [] for group in replacements: if group.isdigit(): groups.append(int(group)) @@ -455,7 +456,7 @@ def _validate_simplifications(cls, language_id, info): return result @classmethod - def _validate_extra_keys(cls, language_id, info): + def _validate_extra_keys(cls, language_id: str, info: Any) -> bool: result = True extra_keys = set(info.keys()) - set(cls.VALID_KEYS) diff --git a/dateparser/parser.py b/dateparser/parser.py index 61fa7d4b7..fb75bef4f 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -1,8 +1,10 @@ import calendar import contextlib -from datetime import datetime, timedelta, timezone +from collections.abc import Callable, Iterable, Iterator +from datetime import datetime, time, timedelta, timezone, tzinfo +from functools import partial from io import StringIO -from typing import ClassVar +from typing import TYPE_CHECKING, Any, ClassVar, Literal, overload import pytz import regex as re @@ -18,6 +20,9 @@ ) from dateparser.utils.strptime import strptime +if TYPE_CHECKING: + from dateparser.conf import Settings + NSP_COMPATIBLE = re.compile(r"\D+") MERIDIAN = re.compile(r"am|pm") MICROSECOND = re.compile(r"\d{1,6}") @@ -25,12 +30,12 @@ HOUR_MINUTE_REGEX = re.compile(r"^([0-9]|0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$") -def no_space_parser_eligibile(datestring): +def no_space_parser_eligibile(datestring: str) -> bool: src = NSP_COMPATIBLE.search(datestring) return not src or src.group() == ":" -def get_unresolved_attrs(parser_object): +def get_unresolved_attrs(parser_object: object) -> tuple[list[str], list[str]]: attrs = ["year", "month", "day"] seen = [] unseen = [] @@ -52,7 +57,15 @@ def get_unresolved_attrs(parser_object): } -def resolve_date_order(order, lst=None): +@overload +def resolve_date_order(order: str, lst: Literal[False] | None = None) -> str: ... + + +@overload +def resolve_date_order(order: str, lst: Literal[True]) -> list[str]: ... + + +def resolve_date_order(order: str, lst: bool | None = None) -> str | list[str]: chart_list = { "DMY": ["day", "month", "year"], "DYM": ["day", "year", "month"], @@ -65,11 +78,21 @@ def resolve_date_order(order, lst=None): return chart_list[order] if lst else date_order_chart[order] -def _parse_absolute(datestring, settings, tz=None, date_order=None): +def _parse_absolute( + datestring: str, + settings: "Settings", + tz: tzinfo | None = None, + date_order: str | None = None, +) -> tuple[datetime, str | None]: return _parser.parse(datestring, settings, tz, date_order=date_order) -def _parse_nospaces(datestring, settings, tz=None, date_order=None): +def _parse_nospaces( + datestring: str, + settings: "Settings", + tz: tzinfo | None = None, + date_order: str | None = None, +) -> tuple[datetime, str]: return _no_spaces_parser.parse(datestring, settings, date_order=date_order) @@ -85,7 +108,7 @@ class _time_parser: "%H:%M %p", ] - def __call__(self, timestring): + def __call__(self, timestring: str) -> time: _timestring = timestring for directive in self.time_directives: try: @@ -138,7 +161,7 @@ class _no_spaces_parser: _default_order = resolve_date_order("MDY") - def __init__(self, *args, **kwargs): + def __init__(self, *args: Any, **kwargs: Any) -> None: self._all = ( self._dateformats + [x + y for x in self._dateformats for y in self._timeformats] @@ -172,7 +195,7 @@ def __init__(self, *args, **kwargs): } @classmethod - def _get_period(cls, format_string): + def _get_period(cls, format_string: str) -> str: for pname, pdrv in sorted(cls.period.items(), key=lambda x: x[0]): for drv in pdrv: if drv in format_string: @@ -180,7 +203,7 @@ def _get_period(cls, format_string): return "year" @classmethod - def _find_best_matching_date(cls, datestring): + def _find_best_matching_date(cls, datestring: str) -> tuple[datetime, str] | None: for fmt in cls._preferred_formats_ordered_8_digit: with contextlib.suppress(Exception): dt = strptime(datestring, fmt), cls._get_period(fmt) @@ -189,7 +212,9 @@ def _find_best_matching_date(cls, datestring): return None @classmethod - def parse(cls, datestring, settings, date_order=None): + def parse( + cls, datestring: str, settings: "Settings", date_order: str | None = None + ) -> tuple[datetime, str]: if not no_space_parser_eligibile(datestring): raise ValueError(f"Unable to parse date from: {datestring}") @@ -207,7 +232,7 @@ def parse(cls, datestring, settings, date_order=None): if dt is not None: return dt nsp = cls() - ambiguous_date = None + ambiguous_date: tuple[datetime, str] | None = None for token, _ in tokens.tokenize(): for fmt in nsp.date_formats[order]: with contextlib.suppress(Exception): @@ -224,11 +249,11 @@ def parse(cls, datestring, settings, date_order=None): raise ValueError(f"Unable to parse date from: {datestring}") -def _get_missing_error(missing): +def _get_missing_error(missing: Iterable[str]) -> str: return "Fields missing from the date string: {}".format(", ".join(missing)) -def _check_strict_parsing(missing, settings): +def _check_strict_parsing(missing: list[str], settings: "Settings") -> None: if settings.STRICT_PARSING and missing: raise ValueError(_get_missing_error(missing)) if settings.REQUIRE_PARTS and missing: @@ -249,7 +274,22 @@ class _parser: "year": ["%y", "%Y"], } - def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 + day: int | None + month: int | None + year: int | None + time: Callable[[], time] | None + now: datetime + _token_day: tuple[str, int] | str | int | None + _token_month: tuple[str, int] | str | int | None + _token_year: tuple[str, int] | str | None + _token_time: str | None + + def __init__( # noqa: PLR0912, PLR0915 + self, + tokens: Iterable[tuple[str, int]], + settings: "Settings", + date_order: str | None = None, + ) -> None: self.settings = settings self._date_order = date_order or settings.DATE_ORDER self.tokens = [(t[0].strip(), t[1]) for t in list(tokens)] @@ -257,14 +297,14 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 (t[0], t[1], i) for i, t in enumerate(self.tokens) if t[1] <= 1 ] - self.unset_tokens = [] + self.unset_tokens: list[tuple[str, int, str]] = [] self.day = None self.month = None self.year = None self.time = None - self.auto_order = [] + self.auto_order: list[str] = [] self._token_day = None self._token_month = None @@ -276,8 +316,8 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 for k in resolve_date_order(self._date_order, lst=True) } - skip_index = [] - skip_component = None + skip_index: list[int] = [] + skip_component: str | None = None skip_tokens = ["t", "year", "hour", "minute"] for index, token_type_original_index in enumerate(self.filtered_tokens): @@ -321,7 +361,7 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 meridian_index += 1 try: - microsecond = MICROSECOND.search( + microsecond = MICROSECOND.search( # type: ignore[union-attr] self.filtered_tokens[index + 1][0] ).group() # Is after time token? raise ValueError if ':' can't be found: @@ -335,7 +375,7 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 meridian_index += 1 try: - meridian = MERIDIAN.search( + meridian = MERIDIAN.search( # type: ignore[union-attr] self.filtered_tokens[meridian_index][0] ).group() except Exception: @@ -354,7 +394,7 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 skip_index.append(meridian_index) else: self._token_time = token - self.time = lambda: time_parser(self._token_time) + self.time = partial(time_parser, self._token_time) continue results = self._parse(token_type, token, skip_component=skip_component) @@ -364,7 +404,7 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 setattr(self, *res) known, unknown = get_unresolved_attrs(self) - params = {} + params: dict[str, int] = {} for attr in known: params.update({attr: getattr(self, attr)}) for attr in unknown: @@ -375,7 +415,7 @@ def __init__(self, tokens, settings, date_order=None): # noqa: PLR0912, PLR0915 setattr(self, attr, int(token)) @classmethod - def _has_month_name(cls, tokens): + def _has_month_name(cls, tokens: Iterable[tuple[str, int]]) -> bool: for token, token_type in tokens: if token_type != 1: continue @@ -387,7 +427,7 @@ def _has_month_name(cls, tokens): pass return False - def _get_period(self): + def _get_period(self) -> str: if self.settings.RETURN_TIME_AS_PERIOD and getattr(self, "time", None): return "time" @@ -401,7 +441,7 @@ def _get_period(self): return "day" - def _get_datetime_obj(self, **params): + def _get_datetime_obj(self, **params: Any) -> datetime: try: return datetime(**params) except ValueError as e: @@ -427,7 +467,7 @@ def _get_datetime_obj(self, **params): return datetime(**params) raise - def _get_correct_leap_year(self, prefer_dates_from, current_year): + def _get_correct_leap_year(self, prefer_dates_from: str, current_year: int) -> int: if prefer_dates_from == "future": return get_next_leap_year(current_year) if prefer_dates_from == "past": @@ -441,12 +481,12 @@ def _get_correct_leap_year(self, prefer_dates_from, current_year): ) return next_leap_year if next_leap_year_is_closer else previous_leap_year - def _set_relative_base(self): - self.now = self.settings.RELATIVE_BASE - if not self.now: - self.now = datetime.now(tz=timezone.utc).replace(tzinfo=None) + def _set_relative_base(self) -> None: + self.now = self.settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( + tzinfo=None + ) - def _get_datetime_obj_params(self): + def _get_datetime_obj_params(self) -> dict[str, int]: if not self.now: self._set_relative_base() @@ -460,10 +500,10 @@ def _get_datetime_obj_params(self): "microsecond": 0, } - def _get_date_obj(self, token, directive): + def _get_date_obj(self, token: str, directive: str) -> datetime: return strptime(token, directive) - def _results(self): + def _results(self) -> datetime: missing = [ field for field in ("day", "month", "year") if not getattr(self, field) ] @@ -485,7 +525,9 @@ def _results(self): return self._get_datetime_obj(**params) - def _correct_for_time_frame(self, dateobj, tz): # noqa: PLR0912, PLR0915 + def _correct_for_time_frame( # noqa: PLR0912, PLR0915 + self, dateobj: datetime, tz: tzinfo | None + ) -> datetime: days = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"] token_weekday, _ = getattr(self, "_token_weekday", (None, None)) @@ -569,6 +611,7 @@ def _correct_for_time_frame(self, dateobj, tz): # noqa: PLR0912, PLR0915 try: tz = tz or get_timezone_from_tz_string(self.settings.TIMEZONE) tz_offset = tz.utcoffset(dateobj) + assert tz_offset is not None except (pytz.UnknownTimeZoneError, pytz.NonExistentTimeError): tz_offset = timedelta(hours=0) @@ -587,7 +630,7 @@ def _correct_for_time_frame(self, dateobj, tz): # noqa: PLR0912, PLR0915 # have been set earlier. return dateobj.replace(tzinfo=original_dateobj.tzinfo) - def _correct_for_day(self, dateobj): + def _correct_for_day(self, dateobj: datetime) -> datetime: if ( getattr(self, "_token_day", None) or getattr(self, "_token_weekday", None) @@ -599,7 +642,7 @@ def _correct_for_day(self, dateobj): dateobj, self.settings, current_day=self.now.day ) - def _correct_for_month(self, dateobj): + def _correct_for_month(self, dateobj: datetime) -> datetime: if getattr(self, "_token_month", None): return dateobj @@ -608,7 +651,13 @@ def _correct_for_month(self, dateobj): ) @classmethod - def parse(cls, datestring, settings, tz=None, date_order=None): + def parse( + cls, + datestring: str, + settings: "Settings", + tz: tzinfo | None = None, + date_order: str | None = None, + ) -> tuple[datetime, str | None]: tokens = list(tokenizer(datestring).tokenize()) date_order = date_order or settings.DATE_ORDER try: @@ -641,16 +690,24 @@ def parse(cls, datestring, settings, tz=None, date_order=None): return dateobj, period - def _parse(self, token_type, token, skip_component=None): + def _parse( + self, token_type: int, token: str, skip_component: str | None = None + ) -> list[tuple[str, int]]: def set_and_return( - token, token_type, component, dateobj, skip_date_order=False - ): + token: str, + token_type: int, + component: str, + dateobj: Any, + skip_date_order: bool = False, + ) -> list[tuple[str, int]]: if not skip_date_order: self.auto_order.append(component) setattr(self, f"_token_{component}", (token, token_type)) return [(component, getattr(dateobj, component))] - def parse_number(token, skip_component=None): + def parse_number( + token: str, skip_component: str | None = None + ) -> list[tuple[str, int]]: token_type = 0 num_directives = self.ordered_num_directives @@ -668,7 +725,9 @@ def parse_number(token, skip_component=None): k: self.num_directives[k] for k in ("month", "day", "year") } - def try_directives(skip_directive=None): + def try_directives( + skip_directive: str | None = None, + ) -> list[tuple[str, int]]: for component, directives in num_directives.items(): if skip_component == component: continue @@ -714,7 +773,9 @@ def try_directives(skip_directive=None): pass return try_directives() - def parse_alpha(token, skip_component=None): + def parse_alpha( + token: str, skip_component: str | None = None + ) -> list[tuple[str, int]]: token_type = 1 for component, directives in self.alpha_directives.items(): @@ -739,7 +800,10 @@ def parse_alpha(token, skip_component=None): ] raise ValueError(f"Unable to parse: {token}") - handlers = {0: parse_number, 1: parse_alpha} + handlers: dict[int, Callable[[str, str | None], list[tuple[str, int]]]] = { + 0: parse_number, + 1: parse_alpha, + } return handlers[token_type](token, skip_component) @@ -747,16 +811,16 @@ class tokenizer: digits = "0123456789:" letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" - def _isletter(self, tkn): + def _isletter(self, tkn: str) -> bool: return tkn in self.letters - def _isdigit(self, tkn): + def _isdigit(self, tkn: str) -> bool: return tkn in self.digits - def __init__(self, ds): + def __init__(self, ds: str) -> None: self.instream = StringIO(ds) - def _switch(self, chara, charb): + def _switch(self, chara: str, charb: str) -> tuple[int, bool]: if self._isdigit(chara): return 0, not self._isdigit(charb) @@ -765,7 +829,7 @@ def _switch(self, chara, charb): return 2, self._isdigit(charb) or self._isletter(charb) - def tokenize(self): + def tokenize(self) -> Iterator[tuple[str, int]]: token = "" EOF = False diff --git a/dateparser/search/__init__.py b/dateparser/search/__init__.py index 03bffd711..6a9a2f6c7 100644 --- a/dateparser/search/__init__.py +++ b/dateparser/search/__init__.py @@ -1,16 +1,21 @@ +from collections.abc import Callable, Iterable +from datetime import datetime +from typing import Any + +from dateparser.conf import Settings from dateparser.search.search import DateSearchWithDetection _search_with_detection = DateSearchWithDetection() def search_dates( - text, - languages=None, - settings=None, - add_detected_language=False, - detect_languages_function=None, - strategy="split", -): + text: str, + languages: Iterable[str] | None = None, + settings: Settings | dict[str, Any] | None = None, + add_detected_language: bool = False, + detect_languages_function: Callable[..., list[str]] | None = None, + strategy: str = "split", +) -> list[tuple[str, datetime]] | list[tuple[str, datetime, str | None]] | None: """Find all substrings of the given string which represent date and/or time and parse them. :param text: @@ -78,6 +83,6 @@ def search_dates( if dates: if add_detected_language: language = result.get("Language") - dates = [(*date, language) for date in dates] + return [(*date, language) for date in dates] return dates return None diff --git a/dateparser/search/detection.py b/dateparser/search/detection.py index a49f06beb..74f1db530 100644 --- a/dateparser/search/detection.py +++ b/dateparser/search/detection.py @@ -1,9 +1,20 @@ +from collections.abc import Callable, Iterator from functools import wraps +from typing import TYPE_CHECKING, Concatenate, ParamSpec, TypeVar +if TYPE_CHECKING: + from dateparser.conf import Settings + from dateparser.languages.locale import Locale -def _restore_languages_on_generator_exit(method): +_S = TypeVar("_S", bound="BaseLanguageDetector") +_P = ParamSpec("_P") + + +def _restore_languages_on_generator_exit( + method: Callable[Concatenate[_S, _P], Iterator["Locale"]], +) -> Callable[Concatenate[_S, _P], Iterator["Locale"]]: @wraps(method) - def wrapped(self, *args, **kwargs): + def wrapped(self: _S, /, *args: _P.args, **kwargs: _P.kwargs) -> Iterator["Locale"]: stored_languages = self.languages[:] yield from method(self, *args, **kwargs) self.languages[:] = stored_languages @@ -12,16 +23,23 @@ def wrapped(self, *args, **kwargs): class BaseLanguageDetector: - def __init__(self, languages): + def __init__(self, languages: list["Locale"]) -> None: self.languages = languages[:] @_restore_languages_on_generator_exit - def iterate_applicable_languages(self, date_string, settings=None, modify=False): + def iterate_applicable_languages( + self, + date_string: str, + settings: "Settings | None" = None, + modify: bool = False, + ) -> Iterator["Locale"]: languages = self.languages if modify else self.languages[:] yield from self._filter_languages(date_string, languages, settings) @staticmethod - def _filter_languages(date_string, languages, settings=None): + def _filter_languages( + date_string: str, languages: list["Locale"], settings: "Settings | None" = None + ) -> Iterator["Locale"]: while languages: language = languages[0] if language.is_applicable( @@ -35,13 +53,20 @@ def _filter_languages(date_string, languages, settings=None): class AutoDetectLanguage(BaseLanguageDetector): - def __init__(self, languages, allow_redetection=False): + def __init__( + self, languages: list["Locale"], allow_redetection: bool = False + ) -> None: super().__init__(languages=languages[:]) self.language_pool = languages[:] self.allow_redetection = allow_redetection @_restore_languages_on_generator_exit - def iterate_applicable_languages(self, date_string, modify=False, settings=None): + def iterate_applicable_languages( # type: ignore[override] + self, + date_string: str, + modify: bool = False, + settings: "Settings | None" = None, + ) -> Iterator["Locale"]: languages = self.languages if modify else self.languages[:] initial_languages = languages[:] yield from self._filter_languages(date_string, languages, settings=settings) @@ -62,13 +87,18 @@ def iterate_applicable_languages(self, date_string, modify=False, settings=None) class ExactLanguages(BaseLanguageDetector): - def __init__(self, languages): + def __init__(self, languages: list["Locale"] | None) -> None: if languages is None: raise ValueError("language cannot be None for ExactLanguages") super().__init__(languages=languages) @_restore_languages_on_generator_exit - def iterate_applicable_languages(self, date_string, modify=False, settings=None): + def iterate_applicable_languages( # type: ignore[override] + self, + date_string: str, + modify: bool = False, + settings: "Settings | None" = None, + ) -> Iterator["Locale"]: yield from super().iterate_applicable_languages( date_string, modify=False, settings=settings ) diff --git a/dateparser/search/ngram_search.py b/dateparser/search/ngram_search.py index f3e483147..4c3376df5 100644 --- a/dateparser/search/ngram_search.py +++ b/dateparser/search/ngram_search.py @@ -8,9 +8,12 @@ """ import logging +from collections.abc import Sequence +from datetime import datetime import regex as re +from dateparser.conf import Settings from dateparser.date import DateDataParser logger = logging.getLogger(__name__) @@ -58,10 +61,12 @@ class _NgramDateSearch: so the reported dates never overlap. """ - def __init__(self, max_tokens=7): + def __init__(self, max_tokens: int = 7) -> None: self.max_tokens = max_tokens - def search_parse(self, languages, text, settings): + def search_parse( + self, languages: list[str], text: str, settings: Settings + ) -> list[tuple[str, datetime]]: """Find all dates in ``text`` and return ``(substring, date)`` pairs. ``languages`` are tried in the given order for every candidate @@ -75,7 +80,7 @@ def search_parse(self, languages, text, settings): for token in _TOKEN_RE.finditer(text) if token.group() not in _NOISE_TOKENS ] - results = [] + results: list[tuple[str, datetime]] = [] index = 0 while index < len(tokens): for size in range(min(self.max_tokens, len(tokens) - index), 0, -1): @@ -94,7 +99,9 @@ def search_parse(self, languages, text, settings): return results @staticmethod - def _parse_candidate(parser, candidate, languages): + def _parse_candidate( + parser: DateDataParser, candidate: str, languages: Sequence[str] + ) -> datetime | None: try: return parser.get_date_data(candidate).date_obj except Exception: diff --git a/dateparser/search/search.py b/dateparser/search/search.py index fcc9d6fc1..708b09e77 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -1,13 +1,16 @@ +from collections.abc import Callable, Iterable, Sequence from collections.abc import Set as AbstractSet from datetime import datetime +from typing import Any, TypedDict import regex as re -from dateparser.conf import apply_settings, check_settings +from dateparser.conf import Settings, apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages -from dateparser.date import DateDataParser +from dateparser.date import DateData, DateDataParser from dateparser.freshness_date_parser import _UNITS from dateparser.languages.loader import LocaleDataLoader +from dateparser.languages.locale import Locale from dateparser.search.ngram_search import _NgramDateSearch from dateparser.search.text_detection import FullTextLanguageDetector from dateparser.utils.time_spans import detect_time_span, generate_time_span @@ -22,11 +25,18 @@ ) -def date_is_relative(translation): +class _SearchResult(TypedDict): + Language: str | None + Dates: list[tuple[str, datetime]] | None + + +def date_is_relative(translation: str) -> bool: return re.search(RELATIVE_REG, translation) is not None -def _add_time_span_results(results, text, settings): +def _add_time_span_results( + results: list[tuple[str, datetime]], text: str, settings: Settings +) -> list[tuple[str, datetime]]: """Append time span start/end dates if RETURN_TIME_SPAN is enabled.""" if getattr(settings, "RETURN_TIME_SPAN", False): span_info = detect_time_span(text) @@ -40,18 +50,22 @@ def _add_time_span_results(results, text, settings): class _ExactLanguageSearch: - def __init__(self, loader): + def __init__(self, loader: LocaleDataLoader) -> None: self.loader = loader - def get_current_language(self, shortname): + def get_current_language(self, shortname: str) -> Locale: return self.loader.get_locale(shortname) - def search(self, shortname, text, settings): + def search( + self, shortname: str, text: str, settings: Settings + ) -> tuple[list[str], list[str]]: language = self.get_current_language(shortname) return language.translate_search(text, settings=settings) @staticmethod - def set_relative_base(substring, already_parsed): + def set_relative_base( + substring: str, already_parsed: Sequence[tuple[DateData, bool]] + ) -> tuple[str, datetime | None]: if len(already_parsed) == 0: return substring, None @@ -63,8 +77,12 @@ def set_relative_base(substring, already_parsed): relative_base = already_parsed[i][0]["date_obj"] return substring, relative_base - def choose_best_split(self, possible_parsed_splits, possible_substrings_splits): - rating = [] + def choose_best_split( + self, + possible_parsed_splits: Sequence[list[tuple[DateData, bool]]], + possible_substrings_splits: Sequence[list[str]], + ) -> tuple[list[tuple[DateData, bool]], list[str]]: + rating: list[list[float]] = [] for i in range(len(possible_parsed_splits)): num_substrings = len(possible_substrings_splits[i]) num_substrings_without_digits = 0 @@ -93,7 +111,9 @@ def choose_best_split(self, possible_parsed_splits, possible_substrings_splits): possible_substrings_splits[best_index], ) - def split_by(self, item, original, splitter): + def split_by( + self, item: str, original: str, splitter: str + ) -> list[list[list[str]]]: if item.count(splitter) <= 2: return [[item.split(splitter), original.split(splitter)]] @@ -111,7 +131,14 @@ def split_by(self, item, original, splitter): all_possible_splits.append([item_partially_split, original_partially_split]) return all_possible_splits - def split_by_relative_expression(self, parser, item, original, language, settings): + def split_by_relative_expression( + self, + parser: DateDataParser, + item: str, + original: str, + language: Locale, + settings: Settings, + ) -> list[list[list[str]]]: """Split a chunk into a relative expression and the date next to it. A word translated into a multi-word relative expression gives the @@ -122,7 +149,7 @@ def split_by_relative_expression(self, parser, item, original, language, setting chunk turns out to be the date it was written next to. """ words = original.split() - possible_splits = [] + possible_splits: list[list[list[str]]] = [] for match in TRANSLATED_RELATIVE_REG.finditer(item): before = item[: match.start()].strip() after = item[match.end() :].strip() @@ -154,9 +181,16 @@ def split_by_relative_expression(self, parser, item, original, language, setting ) return possible_splits - def split_if_not_parsed(self, parser, item, original, language, settings): + def split_if_not_parsed( + self, + parser: DateDataParser, + item: str, + original: str, + language: Locale, + settings: Settings, + ) -> list[list[list[str]]]: splitters = [",", "،", "——", "—", "–", ".", " "] - possible_splits = [] + possible_splits: list[list[list[str]]] = [] for splitter in splitters: if splitter in item and item.count(splitter) == original.count(splitter): possible_splits.extend(self.split_by(item, original, splitter)) @@ -168,7 +202,14 @@ def split_if_not_parsed(self, parser, item, original, language, settings): ) return possible_splits - def parse_item(self, parser, item, translated_item, parsed, need_relative_base): + def parse_item( + self, + parser: DateDataParser, + item: str, + translated_item: str, + parsed: Sequence[tuple[DateData, bool]], + need_relative_base: bool, + ) -> tuple[DateData, bool]: relative_base = None item = item.replace("ngày", "") item = item.replace("am", "") @@ -184,9 +225,15 @@ def parse_item(self, parser, item, translated_item, parsed, need_relative_base): return parsed_item, is_relative def parse_found_objects( - self, parser, to_parse, original, translated, settings, language - ): - parsed = [] + self, + parser: DateDataParser, + to_parse: Sequence[str], + original: Sequence[str], + translated: Sequence[str], + settings: Settings, + language: Locale, + ) -> tuple[list[tuple[DateData, bool]], list[str]]: + parsed: list[tuple[DateData, bool]] = [] substrings = [] need_relative_base = True if settings.RELATIVE_BASE: @@ -209,11 +256,11 @@ def parse_found_objects( if not possible_splits: continue - possible_parsed = [] - possible_substrings = [] + possible_parsed: list[list[tuple[DateData, bool]]] = [] + possible_substrings: list[list[str]] = [] for split_translated, split_original in possible_splits: - current_parsed = [] - current_substrings = [] + current_parsed: list[tuple[DateData, bool]] = [] + current_substrings: list[str] = [] if split_translated: for j, jtem in enumerate(split_translated): if len(jtem) <= 2: @@ -238,7 +285,9 @@ def parse_found_objects( substrings.append(substrings_best[k]) return parsed, substrings - def search_parse(self, shortname, text, settings): + def search_parse( + self, shortname: str, text: str, settings: Settings + ) -> list[tuple[str, datetime]]: language = self.get_current_language(shortname) translated, original = self.search(shortname, text, settings) bad_translate_with_search = [ @@ -276,13 +325,15 @@ class DateSearchWithDetection: """ - def __init__(self): + def __init__(self) -> None: self.loader = LocaleDataLoader() self.available_language_map = self.loader.get_locale_map() self.search = _ExactLanguageSearch(self.loader) self.ngram_search = _NgramDateSearch() - def _get_candidate_languages(self, detected_language, languages): + def _get_candidate_languages( + self, detected_language: str | None, languages: Iterable[str] | None + ) -> list[str]: candidates = [] if detected_language: candidates.append(detected_language) @@ -290,17 +341,17 @@ def _get_candidate_languages(self, detected_language, languages): if isinstance(languages, (list, tuple, AbstractSet)) and len(languages) > 1: candidates.extend(languages) - seen = set() - return [ - language - for language in candidates - if not (language in seen or seen.add(language)) - ] + return list(dict.fromkeys(candidates)) @apply_settings def detect_language( - self, text, languages, settings=None, detect_languages_function=None - ): + self, + text: str, + languages: Iterable[str] | None, + settings: Settings | dict[str, Any] | None = None, + detect_languages_function: Callable[..., list[str]] | None = None, + ) -> str | None: + assert isinstance(settings, Settings) if detect_languages_function and not languages: detected_languages = detect_languages_function( text, @@ -311,9 +362,10 @@ def detect_language( ) return detected_languages[0] if detected_languages else None + locales = None if isinstance(languages, (list, tuple, AbstractSet)): if all(language in self.available_language_map for language in languages): - languages = [ + locales = [ self.available_language_map[language] for language in languages ] else: @@ -328,8 +380,8 @@ def detect_language( f"languages argument must be a list ({type(languages)!r} given)" ) - if languages: - language_detector = FullTextLanguageDetector(languages=languages) + if locales: + language_detector = FullTextLanguageDetector(languages=locales) else: language_detector = FullTextLanguageDetector( list(self.available_language_map.values()) @@ -342,12 +394,12 @@ def detect_language( @apply_settings def search_dates( self, - text, - languages=None, - settings=None, - detect_languages_function=None, - strategy="split", - ): + text: str, + languages: Iterable[str] | None = None, + settings: Settings | dict[str, Any] | None = None, + detect_languages_function: Callable[..., list[str]] | None = None, + strategy: str = "split", + ) -> _SearchResult: """ Find all substrings of the given string which represent date and/or time and parse them. @@ -389,6 +441,7 @@ def search_dates( f'strategy must be "split" or "ngram" ({strategy!r} given)' ) + assert isinstance(settings, Settings) check_settings(settings) language_shortname = self.detect_language( @@ -423,7 +476,7 @@ def search_dates( "Dates": [], } - def preprocess_text(self, text, languages): + def preprocess_text(self, text: str, languages: Iterable[str] | None) -> str: """Preprocess text to handle language-specific quirks.""" if languages and "ru" in languages: # Replace "с" (from) before numbers with a placeholder diff --git a/dateparser/search/text_detection.py b/dateparser/search/text_detection.py index d84d2087b..127b19b69 100644 --- a/dateparser/search/text_detection.py +++ b/dateparser/search/text_detection.py @@ -1,16 +1,19 @@ -from dateparser.conf import apply_settings +from typing import Any + +from dateparser.conf import Settings, apply_settings +from dateparser.languages.locale import Locale from dateparser.search.detection import BaseLanguageDetector from dateparser.utils import normalize_unicode class FullTextLanguageDetector(BaseLanguageDetector): - def __init__(self, languages): + def __init__(self, languages: list[Locale]) -> None: super(BaseLanguageDetector, self).__init__() self.languages = languages[:] - self.language_unique_chars = [] - self.language_chars = [] + self.language_unique_chars: list[set[str]] = [] + self.language_chars: list[set[str]] = [] - def get_unique_characters(self, settings): + def get_unique_characters(self, settings: Settings) -> None: settings = settings.replace(NORMALIZE=False) for language in self.languages: @@ -24,7 +27,7 @@ def get_unique_characters(self, settings): unique_chars = unique_chars - other_char_set self.language_unique_chars.append(unique_chars) - def character_check(self, date_string, settings): + def character_check(self, date_string: str, settings: Settings) -> None: date_string_set = set(date_string.lower()) symbol_set = { "0", @@ -67,7 +70,10 @@ def character_check(self, date_string, settings): ] @apply_settings - def _best_language(self, date_string, settings=None): + def _best_language( + self, date_string: str, settings: Settings | dict[str, Any] | None = None + ) -> str | None: + assert isinstance(settings, Settings) self.character_check(date_string, settings) date_string = normalize_unicode(date_string.lower()) if len(self.languages) == 1: diff --git a/dateparser/timezone_parser.py b/dateparser/timezone_parser.py index 53124970c..0598ac62d 100644 --- a/dateparser/timezone_parser.py +++ b/dateparser/timezone_parser.py @@ -1,37 +1,44 @@ +from collections.abc import Iterator from datetime import datetime, timedelta, timezone, tzinfo +from typing import Literal, TypedDict, overload import regex as re from .timezones import timezone_info_list +class _TzOffsetInfo(TypedDict): + regex: re.Pattern[str] + offset: timedelta + + class StaticTzInfo(tzinfo): - def __init__(self, name, offset): + def __init__(self, name: str, offset: timedelta) -> None: self.__offset = offset self.__name = name - def tzname(self, dt): + def tzname(self, dt: datetime | None) -> str: return self.__name - def utcoffset(self, dt): + def utcoffset(self, dt: datetime | None) -> timedelta: return self.__offset - def dst(self, dt): + def dst(self, dt: datetime | None) -> timedelta: return timedelta(0) - def __repr__(self): + def __repr__(self) -> str: return f"<{self.__class__.__name__} '{self.__name}'>" - def localize(self, dt, is_dst=False): + def localize(self, dt: datetime, is_dst: bool = False) -> datetime: if dt.tzinfo is not None: raise ValueError("Not naive datetime (tzinfo is already set)") return dt.replace(tzinfo=self) - def __getinitargs__(self): + def __getinitargs__(self) -> tuple[str, timedelta]: return self.__name, self.__offset -def _search_and_pop_tz(date_string): +def _search_and_pop_tz(date_string: str) -> tuple[str, str, _TzOffsetInfo] | None: """Find and remove the first timezone token from ``date_string``. Returns a ``(new_string, name, info)`` tuple, or ``None`` if no timezone @@ -56,7 +63,21 @@ def _search_and_pop_tz(date_string): return None -def pop_tz_offset_from_string(date_string, as_offset=True): +@overload +def pop_tz_offset_from_string( + date_string: str, as_offset: Literal[True] = True +) -> tuple[str, StaticTzInfo | None]: ... + + +@overload +def pop_tz_offset_from_string( + date_string: str, as_offset: Literal[False] +) -> tuple[str, str | None]: ... + + +def pop_tz_offset_from_string( + date_string: str, as_offset: bool = True +) -> tuple[str, StaticTzInfo | str | None]: match = _search_and_pop_tz(date_string) if match is None: return date_string, None @@ -80,11 +101,11 @@ def pop_tz_offset_from_string(date_string, as_offset=True): return date_string, result -def word_is_tz(word): +def word_is_tz(word: str) -> bool: return bool(_search_regex.match(word)) -def is_timezone_token(token): +def is_timezone_token(token: str) -> bool: """Whether ``token`` is, on its own, a recognized timezone abbreviation. Unlike :func:`word_is_tz` (a case-sensitive prefix match used while @@ -100,12 +121,18 @@ def is_timezone_token(token): return bool(_search_regex_ignorecase.fullmatch(token.strip())) -def convert_to_local_tz(datetime_obj, datetime_tz_offset): +def convert_to_local_tz( + datetime_obj: datetime, datetime_tz_offset: timedelta +) -> datetime: return datetime_obj - datetime_tz_offset + local_tz_offset -def build_tz_offsets(search_regex_parts): - def get_offset(tz_obj, regex, repl="", replw=""): +def build_tz_offsets( + search_regex_parts: list[str], +) -> Iterator[tuple[str, _TzOffsetInfo]]: + def get_offset( + tz_obj: tuple[str, int], regex: str, repl: str = "", replw: str = "" + ) -> tuple[str, _TzOffsetInfo]: return ( tz_obj[0], { @@ -128,12 +155,12 @@ def get_offset(tz_obj, regex, repl="", replw=""): yield get_offset(tz_obj, regex, repl=replace, replw=replacewith) -def get_local_tz_offset(): +def get_local_tz_offset() -> timedelta: offset = datetime.now() - datetime.now(tz=timezone.utc).replace(tzinfo=None) return timedelta(days=offset.days, seconds=round(offset.seconds, -1)) -_search_regex_parts = [] +_search_regex_parts: list[str] = [] _tz_offsets = list(build_tz_offsets(_search_regex_parts)) _search_regex = re.compile("|".join(_search_regex_parts)) _search_regex_ignorecase = re.compile("|".join(_search_regex_parts), re.IGNORECASE) diff --git a/dateparser/timezones.py b/dateparser/timezones.py index 458bc5d6e..248ecc907 100644 --- a/dateparser/timezones.py +++ b/dateparser/timezones.py @@ -10,7 +10,9 @@ # has to agree with it: "BST" and "HDT" did not, and were corrected in #1322. # Run dateparser_scripts/tz_abbreviation_conflicts.py to re-check the table. -timezone_info_list = [ +from typing import Any + +timezone_info_list: list[dict[str, Any]] = [ { "regex_patterns": [r"(.)%s$"], "replace": [ diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 8ab149986..8c6ef20af 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -1,11 +1,14 @@ import calendar import logging +import logging.config import os import threading import types import unicodedata from collections import OrderedDict -from datetime import datetime +from collections.abc import Callable, Mapping +from datetime import datetime, tzinfo +from typing import TYPE_CHECKING, Any, Literal, TypeVar import regex as re from pytz import UTC, UnknownTimeZoneError, timezone @@ -13,8 +16,13 @@ from dateparser.timezone_parser import StaticTzInfo, _tz_offsets +if TYPE_CHECKING: + from dateparser.conf import Settings -def _get_localzone(): +_T = TypeVar("_T") + + +def _get_localzone() -> tzinfo: try: return get_localzone() except ValueError as error: @@ -24,11 +32,13 @@ def _get_localzone(): ) from error -def strip_braces(date_string): +def strip_braces(date_string: str) -> str: return re.sub(r"[{}()<>\[\]]+", "", date_string) -def normalize_unicode(string, form="NFKD"): +def normalize_unicode( + string: str, form: Literal["NFC", "NFD", "NFKC", "NFKD"] = "NFKD" +) -> str: return "".join( c for c in unicodedata.normalize(form, string) @@ -36,8 +46,10 @@ def normalize_unicode(string, form="NFKD"): ) -def combine_dicts(primary_dict, supplementary_dict): - combined_dict = OrderedDict() +def combine_dicts( + primary_dict: Mapping[str, Any], supplementary_dict: Mapping[str, Any] +) -> "OrderedDict[str, Any]": + combined_dict: OrderedDict[str, Any] = OrderedDict() for key, value in primary_dict.items(): if key in supplementary_dict: if isinstance(value, list): @@ -54,14 +66,14 @@ def combine_dicts(primary_dict, supplementary_dict): return combined_dict -def find_date_separator(format): # noqa: A002 +def find_date_separator(format: str) -> str | None: # noqa: A002 m = re.search(r"(?:(?:%[dbBmaA])(\W))+", format) if m: return m.group(1) return None -def _get_missing_parts(fmt): +def _get_missing_parts(fmt: str) -> list[str]: """ Return a list containing missing parts (day, month, year) from a date format checking its directives @@ -92,7 +104,7 @@ def _get_missing_parts(fmt): ] -def get_timezone_from_tz_string(tz_string): +def get_timezone_from_tz_string(tz_string: str) -> tzinfo: try: return timezone(tz_string) except UnknownTimeZoneError: @@ -102,7 +114,7 @@ def get_timezone_from_tz_string(tz_string): raise -def localize_timezone(date_time, tz_string): +def localize_timezone(date_time: datetime, tz_string: str) -> datetime: if date_time.tzinfo: return date_time @@ -116,7 +128,7 @@ def localize_timezone(date_time, tz_string): return date_time -def apply_tzdatabase_timezone(date_time, pytz_string): +def apply_tzdatabase_timezone(date_time: datetime, pytz_string: str) -> datetime: usr_timezone = timezone(pytz_string) if date_time.tzinfo != usr_timezone: @@ -125,7 +137,9 @@ def apply_tzdatabase_timezone(date_time, pytz_string): return date_time -def apply_dateparser_timezone(utc_datetime, offset_or_timezone_abb): +def apply_dateparser_timezone( + utc_datetime: datetime, offset_or_timezone_abb: str +) -> datetime | None: for name, info in _tz_offsets: if info["regex"].search(f" {offset_or_timezone_abb}"): tz = StaticTzInfo(name, info["offset"]) @@ -133,7 +147,7 @@ def apply_dateparser_timezone(utc_datetime, offset_or_timezone_abb): return None -def apply_timezone(date_time, tz_string): +def apply_timezone(date_time: datetime, tz_string: str) -> datetime: if not date_time.tzinfo: if hasattr(UTC, "localize"): date_time = UTC.localize(date_time) @@ -148,7 +162,9 @@ def apply_timezone(date_time, tz_string): return new_datetime -def apply_timezone_from_settings(date_obj, settings): +def apply_timezone_from_settings( + date_obj: datetime, settings: "Settings | None" +) -> datetime: tz = _get_localzone() if settings is None: return date_obj @@ -170,19 +186,19 @@ def apply_timezone_from_settings(date_obj, settings): return date_obj -def get_last_day_of_month(year, month): +def get_last_day_of_month(year: int, month: int) -> int: return calendar.monthrange(year, month)[1] -def get_previous_leap_year(year): +def get_previous_leap_year(year: int) -> int: return _get_leap_year(year, future=False) -def get_next_leap_year(year): +def get_next_leap_year(year: int) -> int: return _get_leap_year(year, future=True) -def _get_leap_year(year, future): +def _get_leap_year(year: int, future: bool) -> int: """ Iterate through previous or next years until it gets a valid leap year This is performed to avoid missing or including centurial leap years @@ -194,7 +210,9 @@ def _get_leap_year(year, future): return leap_year -def set_correct_day_from_settings(date_obj, settings, current_day=None): +def set_correct_day_from_settings( + date_obj: datetime, settings: "Settings", current_day: int | None = None +) -> datetime: """Set correct day attending the `PREFER_DAY_OF_MONTH` setting.""" options = { "first": 1, @@ -208,7 +226,9 @@ def set_correct_day_from_settings(date_obj, settings, current_day=None): return date_obj.replace(day=options["last"]) -def set_correct_month_from_settings(date_obj, settings, current_month=None): +def set_correct_month_from_settings( + date_obj: datetime, settings: "Settings", current_month: int | None = None +) -> datetime: """Set correct month attending the `PREFER_MONTH_OF_YEAR` setting.""" options = {"first": 1, "last": 12, "current": current_month or datetime.now().month} @@ -221,9 +241,9 @@ def set_correct_month_from_settings(date_obj, settings, current_month=None): _registry_lock = threading.Lock() -def registry(cls): - def choose(creator): - def constructor(cls, *args, **kwargs): +def registry(cls: type[_T]) -> type[_T]: + def choose(creator: Callable[..., Any]) -> "staticmethod[..., Any]": + def constructor(cls: Any, *args: Any, **kwargs: Any) -> Any: key = cls.get_key(*args, **kwargs) with _registry_lock: @@ -241,25 +261,22 @@ def constructor(cls, *args, **kwargs): return staticmethod(constructor) - if not ( - hasattr(cls, "get_key") - and isinstance(cls.get_key, types.MethodType) - and cls.get_key.__self__ is cls - ): + get_key = getattr(cls, "get_key", None) + if not (isinstance(get_key, types.MethodType) and get_key.__self__ is cls): raise NotImplementedError( "Registry classes require to implement class method get_key" ) - cls.__new__ = choose(cls.__new__) + cls.__new__ = choose(cls.__new__) # type: ignore[method-assign] return cls -def get_logger(): +def get_logger() -> logging.Logger: setup_logging() return logging.getLogger("dateparser") -def setup_logging(): +def setup_logging() -> None: if len(logging.root.handlers): return diff --git a/dateparser/utils/strptime.py b/dateparser/utils/strptime.py index 968c40f7d..642144951 100644 --- a/dateparser/utils/strptime.py +++ b/dateparser/utils/strptime.py @@ -1,8 +1,11 @@ import calendar import importlib.util import sys +from collections.abc import Callable from datetime import datetime +from time import struct_time from types import ModuleType +from typing import Any import regex as re @@ -17,7 +20,7 @@ MS_SEARCHER = re.compile(r"\.(?P[0-9]{1,6})") -def patch_strptime(): +def patch_strptime() -> Callable[[str, str], struct_time]: """Monkey patching _strptime to avoid problems related with non-english locale changes on the system. @@ -25,7 +28,9 @@ def patch_strptime(): any date since all languages are translated to english dates. """ _strptime_spec = importlib.util.find_spec("_strptime") - _strptime = importlib.util.module_from_spec(_strptime_spec) + assert _strptime_spec is not None + assert _strptime_spec.loader is not None + _strptime: Any = importlib.util.module_from_spec(_strptime_spec) _strptime_spec.loader.exec_module(_strptime) sys.modules["strptime_patched"] = _strptime @@ -78,7 +83,8 @@ def patch_strptime(): "december", ] - return _strptime._strptime_time + strptime_time: Callable[[str, str], struct_time] = _strptime._strptime_time + return strptime_time __strptime = patch_strptime() @@ -136,12 +142,12 @@ def strptime(date_string: str, format: str) -> datetime: # noqa: A002 if "%f" in prepared_format: try: - match_groups = TIME_MATCHER.match(date_string).groupdict() + match_groups = TIME_MATCHER.match(date_string).groupdict() # type: ignore[union-attr] ms = match_groups["microsecond"] ms = ms + ((6 - len(ms)) * "0") obj = obj.replace(microsecond=int(ms)) except AttributeError: - match_groups = MS_SEARCHER.search(date_string).groupdict() + match_groups = MS_SEARCHER.search(date_string).groupdict() # type: ignore[union-attr] ms = match_groups["microsecond"] ms = ms + ((6 - len(ms)) * "0") obj = obj.replace(microsecond=int(ms)) diff --git a/dateparser/utils/time_spans.py b/dateparser/utils/time_spans.py index 0099933e5..6e110b830 100644 --- a/dateparser/utils/time_spans.py +++ b/dateparser/utils/time_spans.py @@ -1,10 +1,15 @@ import re -from datetime import timedelta +from collections.abc import Mapping +from datetime import datetime, timedelta +from typing import TYPE_CHECKING, Any from dateutil.relativedelta import relativedelta +if TYPE_CHECKING: + from dateparser.conf import Settings -def detect_time_span(text): + +def detect_time_span(text: str) -> dict[str, Any] | None: """Detect time span expressions in text and return span information.""" span_patterns = [ { @@ -62,7 +67,7 @@ def detect_time_span(text): for pattern_info in span_patterns: match = re.search(pattern_info["pattern"], text, re.IGNORECASE) if match: - result = { + result: dict[str, Any] = { "type": pattern_info["type"], "direction": pattern_info["direction"], "matched_text": match.group(0), @@ -78,7 +83,9 @@ def detect_time_span(text): return None -def generate_time_span(span_info, base_date, settings): +def generate_time_span( + span_info: Mapping[str, Any], base_date: datetime, settings: "Settings" +) -> tuple[datetime, datetime]: """Return the start and end dates of the span described by *span_info*.""" span_type = span_info["type"] number = span_info.get("number", 1) @@ -94,6 +101,7 @@ def generate_time_span(span_info, base_date, settings): start_date = week_start + timedelta(days=7) return start_date, start_date + timedelta(days=6) + span: timedelta | relativedelta if span_type == "month": span = timedelta(days=settings.DEFAULT_DAYS_IN_MONTH) elif span_type == "days": diff --git a/dateparser_cli/cli.py b/dateparser_cli/cli.py index b557d3bc5..979ff241c 100644 --- a/dateparser_cli/cli.py +++ b/dateparser_cli/cli.py @@ -7,7 +7,7 @@ logger = logging.getLogger(__name__) -def entrance(): +def entrance() -> None: dateparser_argparse = argparse.ArgumentParser( description="dateparser download manager." ) diff --git a/dateparser_cli/utils.py b/dateparser_cli/utils.py index 5a6d1006b..78897c7b7 100644 --- a/dateparser_cli/utils.py +++ b/dateparser_cli/utils.py @@ -17,6 +17,6 @@ dateparser_model_home = (Path(_cache_dir) / DEFAULT_DIR_NAME).expanduser() -def clear_cache(*args): +def clear_cache(*args: object) -> None: for path in dateparser_model_home.rglob("*.*"): path.unlink() diff --git a/dateparser_scripts/get_cldr_data.py b/dateparser_scripts/get_cldr_data.py index d2a6e762d..8fe764c8c 100644 --- a/dateparser_scripts/get_cldr_data.py +++ b/dateparser_scripts/get_cldr_data.py @@ -1,6 +1,7 @@ import json import shutil from pathlib import Path +from typing import Any import regex as re @@ -30,7 +31,7 @@ PARENTHESIS_PATTERN = re.compile(r"[\(\)]") -def _filter_relative_string(relative_string): +def _filter_relative_string(relative_string: object) -> bool | re.Match[str] | None: return ( isinstance(relative_string, str) and RELATIVE_PATTERN.search(relative_string) @@ -38,12 +39,12 @@ def _filter_relative_string(relative_string): ) -def _filter_month_name(month_name): +def _filter_month_name(month_name: str) -> bool: return not DEFAULT_MONTH_PATTERN.match(month_name) -def _retrieve_locale_data(locale): # noqa: PLR0915 - def load(scope, file_id): +def _retrieve_locale_data(locale: str) -> dict[str, Any]: # noqa: PLR0915 + def load(scope: str, file_id: str) -> Any: file_path = ( CLDR_JSON_DIR / "cldr-json" @@ -65,7 +66,7 @@ def load(scope, file_id): date_fields_dict = cldr_datefields_data["main"][locale]["dates"]["fields"] units = _units["main"][locale]["units"]["long"] - json_dict = {} + json_dict: dict[str, Any] = {} field_keys_1 = ["stand-alone", "format"] field_keys_2 = [ @@ -88,8 +89,10 @@ def load(scope, file_id): except AttributeError: date_format_string = gregorian_dict["dateFormats"]["short"]["_value"].upper() + date_order_match = DATE_ORDER_PATTERN.search(date_format_string) + assert date_order_match is not None json_dict["date_order"] = DATE_ORDER_PATTERN.sub( - r"\1\2\3", DATE_ORDER_PATTERN.search(date_format_string).group() + r"\1\2\3", date_order_match.group() ) json_dict["january"] = list( @@ -522,14 +525,14 @@ def load(scope, file_id): return json_dict -def _clean_string(given_string): +def _clean_string(given_string: str) -> str: given_string = RE_SANITIZE_APOSTROPHE.sub("'", given_string) given_string = given_string.replace(".", "") given_string = given_string.lower() return " ".join(given_string.split()) -def _clean_dict(json_dict): +def _clean_dict(json_dict: dict[str, Any]) -> dict[str, Any]: """Remove duplicates and sort""" for key, value in json_dict.items(): if isinstance(value, list): @@ -540,7 +543,7 @@ def _clean_dict(json_dict): return dict(filter(lambda x: x[1], json_dict.items())) -def main(): +def main() -> None: get_raw_data() language_locale_dict = _get_language_locale_dict() parent_directory = Path("../dateparser_data/cldr_language_data") @@ -552,7 +555,7 @@ def main(): for language in language_locale_dict: json_language_dict = _clean_dict(_retrieve_locale_data(language)) - locale_specific_dict = {} + locale_specific_dict: dict[str, dict[str, Any]] = {} locales_list = language_locale_dict[language] for locale in locales_list: json_locale_dict = _clean_dict(_retrieve_locale_data(locale)) diff --git a/dateparser_scripts/order_languages.py b/dateparser_scripts/order_languages.py index 82970df54..f23ecf3c9 100644 --- a/dateparser_scripts/order_languages.py +++ b/dateparser_scripts/order_languages.py @@ -1,6 +1,7 @@ import contextlib import json import os +from collections.abc import Iterable, Mapping from pathlib import Path import regex as re @@ -167,7 +168,7 @@ avoid_languages |= cldr_44_new_languages -def _get_language_locale_dict(): +def _get_language_locale_dict() -> dict[str, list[str]]: cldr_dates_full_dir = CLDR_JSON_DIR / "cldr-json/cldr-dates-full/main/" available_locale_names = [path.name for path in cldr_dates_full_dir.iterdir()] available_language_names = [ @@ -175,7 +176,7 @@ def _get_language_locale_dict(): for shortname in available_locale_names if not re.search(r"-[A-Z0-9]+$", shortname) ] - language_locale_dict = {} + language_locale_dict: dict[str, list[str]] = {} for language_name in available_language_names: language_locale_dict[language_name] = [] for locale_name in available_locale_names: @@ -187,8 +188,8 @@ def _get_language_locale_dict(): return language_locale_dict -def _get_language_order(language_locale_dict): - def get_most_common_locales(): +def _get_language_order(language_locale_dict: Mapping[str, list[str]]) -> list[str]: + def get_most_common_locales() -> list[str]: # Order from https://w3techs.com/technologies/overview/content_language # Last updated on 03.10.2022 old_common_locales = [ @@ -264,7 +265,7 @@ def get_most_common_locales(): territory_content = json.load(f) territory_info_data = territory_content["supplemental"]["territoryInfo"] - language_population_dict = {} + language_population_dict: dict[str, float] = {} for territory in territory_info_data: population = int(territory_info_data[territory]["_population"]) with contextlib.suppress(Exception): @@ -315,7 +316,7 @@ def get_most_common_locales(): return list(map(str, language_order)) -def generate_language_map(language_order): +def generate_language_map(language_order: Iterable[str]) -> dict[str, list[str]]: data = {} for lang in sorted(language_order): if "-" not in lang: @@ -325,7 +326,7 @@ def generate_language_map(language_order): return data -def main(): +def main() -> None: get_raw_data() language_locale_dict = _get_language_locale_dict() language_order = _get_language_order(language_locale_dict) diff --git a/dateparser_scripts/tz_abbreviation_conflicts.py b/dateparser_scripts/tz_abbreviation_conflicts.py index af7048e9a..0711ced38 100644 --- a/dateparser_scripts/tz_abbreviation_conflicts.py +++ b/dateparser_scripts/tz_abbreviation_conflicts.py @@ -53,6 +53,7 @@ python -m dateparser_scripts.tz_abbreviation_conflicts """ +from collections.abc import Collection, Mapping from datetime import datetime from typing import NamedTuple @@ -95,7 +96,7 @@ class Conflict(NamedTuple): tz_database_offsets: list[int] -def static_tz_abbreviations(): +def static_tz_abbreviations() -> dict[str, int]: """Return ``{abbreviation: offset_in_seconds}`` as dateparser resolves it. A few abbreviations are listed more than once in ``timezone_info_list`` @@ -110,14 +111,14 @@ def static_tz_abbreviations(): case-insensitively, so a differently-cased entry such as ``ChST`` is the same abbreviation and has to be compared as one. """ - effective = {} + effective: dict[str, int] = {} for group in timezone_info_list: for name, offset in group["timezones"]: effective.setdefault(name.upper(), offset) return effective -def tz_database_abbreviations(): +def tz_database_abbreviations() -> dict[str, set[int]]: """Return ``{abbreviation: {offset_in_seconds, ...}}`` from the tz database. Every zone is sampled, including the deprecated aliases (``US/Pacific``, @@ -132,7 +133,7 @@ def tz_database_abbreviations(): for year in REFERENCE_YEARS for month in REFERENCE_MONTHS ] - abbreviations = {} + abbreviations: dict[str, set[int]] = {} for zone_name in pytz.all_timezones: zone = pytz.timezone(zone_name) for naive in samples: @@ -140,12 +141,17 @@ def tz_database_abbreviations(): abbreviation = localized.tzname() if not abbreviation or _NUMERIC_ZONE_NAME.fullmatch(abbreviation): continue - offset = int(localized.utcoffset().total_seconds()) + utcoffset = localized.utcoffset() + assert utcoffset is not None + offset = int(utcoffset.total_seconds()) abbreviations.setdefault(abbreviation.upper(), set()).add(offset) return abbreviations -def find_conflicts(static=None, tz_database=None): +def find_conflicts( + static: Mapping[str, int] | None = None, + tz_database: Mapping[str, Collection[int]] | None = None, +) -> list[Conflict]: """Return the sorted list of :class:`Conflict` between both tables. ``static`` and ``tz_database`` default to the real tables and are only @@ -173,7 +179,7 @@ def find_conflicts(static=None, tz_database=None): return sorted(conflicts) -def main(): +def main() -> int: found = find_conflicts() if not found: print( diff --git a/dateparser_scripts/update_supported_languages_and_locales.py b/dateparser_scripts/update_supported_languages_and_locales.py index 8d3252652..358105e2d 100755 --- a/dateparser_scripts/update_supported_languages_and_locales.py +++ b/dateparser_scripts/update_supported_languages_and_locales.py @@ -1,12 +1,13 @@ #!/usr/bin/env python3 +from collections.abc import Mapping, Sequence from pathlib import Path from tempfile import TemporaryFile from dateparser.data.languages_info import language_locale_dict -def to_string(data): +def to_string(data: Mapping[str, Sequence[str]]) -> str: result = "" language_column_width = 18 for language in sorted(data): @@ -19,7 +20,7 @@ def to_string(data): return result -def main(): +def main() -> None: readme_path = Path(__file__).parent.parent / "docs" / "supported_locales.rst" new_data = to_string(language_locale_dict) temporary_file = TemporaryFile("w+") diff --git a/dateparser_scripts/utils.py b/dateparser_scripts/utils.py index 9f6c4f27b..9b6e1a9ac 100644 --- a/dateparser_scripts/utils.py +++ b/dateparser_scripts/utils.py @@ -1,12 +1,13 @@ import shutil from pathlib import Path +from typing import Any from git import Repo CLDR_JSON_DIR = (Path(__file__).parent / "../cldr-json").resolve() -def get_raw_data(): +def get_raw_data() -> None: cldr_version = "44.1.0" url = "https://github.com/unicode-org/cldr-json.git" if CLDR_JSON_DIR.is_dir(): @@ -16,7 +17,9 @@ def get_raw_data(): Repo.clone_from(url, CLDR_JSON_DIR, branch=cldr_version, depth=1) -def get_dict_difference(parent_dict, child_dict): +def get_dict_difference( + parent_dict: dict[str, Any], child_dict: dict[str, Any] +) -> dict[str, Any]: difference_dict = {} for key, child_value in child_dict.items(): parent_value = parent_dict.get(key) @@ -34,7 +37,9 @@ def get_dict_difference(parent_dict, child_dict): return difference_dict -def combine_dicts(primary_dict, supplementary_dict): +def combine_dicts( + primary_dict: dict[str, Any], supplementary_dict: dict[str, Any] +) -> dict[str, Any]: combined_dict = {} for key, value in primary_dict.items(): if key in supplementary_dict: diff --git a/dateparser_scripts/write_complete_data.py b/dateparser_scripts/write_complete_data.py index f2cc79239..fb954569a 100644 --- a/dateparser_scripts/write_complete_data.py +++ b/dateparser_scripts/write_complete_data.py @@ -1,6 +1,7 @@ import json import shutil from pathlib import Path +from typing import Any import regex as re from ruamel.yaml import YAML @@ -28,11 +29,11 @@ POSSESSIVE_DIGIT_PATTERN = re.compile(r"\\d\+\[\.,\]\?\\d\*") -def _make_possessive(s): +def _make_possessive(s: str) -> str: return POSSESSIVE_DIGIT_PATTERN.sub(r"\\d++[.,]?\\d*+", s) -def _to_plain_types(obj): +def _to_plain_types(obj: Any) -> Any: """Recursively convert ruamel.yaml CommentedMap/CommentedSeq to plain dict/list so that json.dumps produces stable output across all Python versions. @@ -51,7 +52,9 @@ def _to_plain_types(obj): return obj -def _modify_relative_data(relative_data): +def _modify_relative_data( + relative_data: dict[str, list[str]], +) -> dict[str, list[str]]: modified_relative_data = {} for key, value in relative_data.items(): for i, string in enumerate(value): @@ -62,7 +65,7 @@ def _modify_relative_data(relative_data): return modified_relative_data -def _modify_simplifications(simplifications): +def _modify_simplifications(simplifications: list[dict[str, Any]]) -> None: for simplification in simplifications: for pattern in list(simplification.keys()): new_pattern = _make_possessive(pattern) @@ -70,7 +73,7 @@ def _modify_simplifications(simplifications): simplification[new_pattern] = simplification.pop(pattern) -def _modify_data(language_data): +def _modify_data(language_data: dict[str, Any]) -> None: relative_data = language_data.get("relative-type-regex", {}) relative_data = _modify_relative_data(relative_data) simplifications = language_data.get("simplifications", []) @@ -81,9 +84,9 @@ def _modify_data(language_data): locale_relative_data = _modify_relative_data(locale_relative_data) -def _get_complete_date_translation_data(language): - cldr_data = {} - supplementary_data = {} +def _get_complete_date_translation_data(language: str) -> dict[str, Any]: + cldr_data: dict[str, Any] = {} + supplementary_data: dict[str, Any] = {} if language in cldr_languages: with (cldr_date_directory / f"{language}.json").open() as f: cldr_data = json.load(f) @@ -97,7 +100,13 @@ def _get_complete_date_translation_data(language): return complete_data -def _write_file(filename, text, mode, in_memory, in_memory_result): +def _write_file( + filename: Path, + text: str | bytes, + mode: str, + in_memory: bool, + in_memory_result: dict[Path, str | bytes], +) -> None: if in_memory: in_memory_result[filename] = text else: @@ -105,7 +114,7 @@ def _write_file(filename, text, mode, in_memory, in_memory_result): out.write(text) -def write_complete_data(in_memory=False): +def write_complete_data(in_memory: bool = False) -> dict[Path, str | bytes]: """ This function is responsible of generating the needed py files from the CLDR files (JSON format) and supplementary language data (YAML format). @@ -113,7 +122,7 @@ def write_complete_data(in_memory=False): Use it with in_memory=True to avoid writing real files and getting a dictionary containing the file names and their content (used when testing). """ - in_memory_result = {} + in_memory_result: dict[Path, str | bytes] = {} if not in_memory: translation_data_directory.mkdir(exist_ok=True) diff --git a/fuzzing/dateparser_fuzzer.py b/fuzzing/dateparser_fuzzer.py index 8bd21c999..13d342bd4 100644 --- a/fuzzing/dateparser_fuzzer.py +++ b/fuzzing/dateparser_fuzzer.py @@ -66,7 +66,7 @@ def _get_format_strings(fdp: EnhancedFuzzedDataProvider) -> list[str]: ] -def TestOneInput(data): +def TestOneInput(data: bytes) -> int | None: fdp = EnhancedFuzzedDataProvider(data) settings = { @@ -102,9 +102,10 @@ def TestOneInput(data): ) except re.error: return -1 + return None -def main(): +def main() -> None: atheris.Setup(sys.argv, TestOneInput) atheris.Fuzz() diff --git a/fuzzing/fuzz_helpers.py b/fuzzing/fuzz_helpers.py index 54d576af3..0d928e042 100644 --- a/fuzzing/fuzz_helpers.py +++ b/fuzzing/fuzz_helpers.py @@ -2,6 +2,7 @@ import datetime import io import tempfile +from collections.abc import Iterator from typing import TypeVar import atheris @@ -9,20 +10,26 @@ T = TypeVar("T") -class EnhancedFuzzedDataProvider(atheris.FuzzedDataProvider): +class EnhancedFuzzedDataProvider(atheris.FuzzedDataProvider): # type: ignore[misc] def ConsumeRandomBytes(self) -> bytes: - return self.ConsumeBytes(self.ConsumeIntInRange(0, self.remaining_bytes())) + result: bytes = self.ConsumeBytes( + self.ConsumeIntInRange(0, self.remaining_bytes()) + ) + return result def ConsumeRandomString(self) -> str: - return self.ConsumeUnicodeNoSurrogates( + result: str = self.ConsumeUnicodeNoSurrogates( self.ConsumeIntInRange(0, self.remaining_bytes()) ) + return result def ConsumeRemainingString(self) -> str: - return self.ConsumeUnicodeNoSurrogates(self.remaining_bytes()) + result: str = self.ConsumeUnicodeNoSurrogates(self.remaining_bytes()) + return result def ConsumeRemainingBytes(self) -> bytes: - return self.ConsumeBytes(self.remaining_bytes()) + result: bytes = self.ConsumeBytes(self.remaining_bytes()) + return result def ConsumeSublist(self, source: list[T]) -> list[T]: """ @@ -46,26 +53,26 @@ def ConsumeDate(self) -> datetime.datetime: @contextlib.contextmanager def ConsumeMemoryFile( self, all_data: bool = False, as_bytes: bool = True - ) -> io.BytesIO: - if all_data: - file_data = ( - self.ConsumeRemainingBytes() - if as_bytes - else self.ConsumeRemainingString() + ) -> Iterator[io.BytesIO | io.StringIO]: + file: io.BytesIO | io.StringIO + if as_bytes: + file = io.BytesIO( + self.ConsumeRemainingBytes() if all_data else self.ConsumeRandomBytes() ) else: - file_data = ( - self.ConsumeRandomBytes() if as_bytes else self.ConsumeRandomString() + file = io.StringIO( + self.ConsumeRemainingString() + if all_data + else self.ConsumeRandomString() ) - - file = io.BytesIO(file_data) if as_bytes else io.StringIO(file_data) yield file file.close() @contextlib.contextmanager def ConsumeTemporaryFile( self, suffix: str, all_data: bool = False, as_bytes: bool = True - ) -> str: + ) -> Iterator[str]: + file_data: bytes | str if all_data: file_data = ( self.ConsumeRemainingBytes() diff --git a/pyproject.toml b/pyproject.toml index 7241a6328..4b90d315f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -77,6 +77,18 @@ filename = "SECURITY.md" parse = """(?P0|[1-9]\\d*)\\.(?P0|[1-9]\\d*)""" serialize = ["{major}.{minor}"] +[tool.mypy] +strict = true +mypy_path = "stubs" + +[[tool.mypy.overrides]] +module = [ + "atheris", + "convertdate.*", + "langdetect.*", +] +ignore_missing_imports = true + [tool.ruff] exclude = ["date_translation_data"] diff --git a/stubs/parameterized/__init__.pyi b/stubs/parameterized/__init__.pyi new file mode 100644 index 000000000..cfd1164bc --- /dev/null +++ b/stubs/parameterized/__init__.pyi @@ -0,0 +1,19 @@ +from collections.abc import Callable, Iterable +from typing import Any, TypeVar + +_F = TypeVar("_F", bound=Callable[..., Any]) + +class param: + def __init__(self, *args: Any, **kwargs: Any) -> None: ... + +class parameterized: + @classmethod + def expand( + cls, + input: Iterable[Any], # noqa: A002 + name_func: Callable[..., str] | None = None, + doc_func: Callable[..., str | None] | None = None, + skip_on_empty: bool = False, + namespace: dict[str, Any] | None = None, + **legacy: Any, + ) -> Callable[[_F], _F]: ... diff --git a/tests/__init__.py b/tests/__init__.py index 4f91b2349..a19c9d353 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,23 +1,34 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING, Any from unittest import TestCase +if TYPE_CHECKING: + from collections.abc import Iterable + from unittest.mock import _patch + class BaseTestCase(TestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.__patches = [] + self.__patches: list[_patch[Any]] = [] - self.error = NotImplemented + self.error: object = NotImplemented - def add_patch(self, patch): + def add_patch(self, patch: _patch[Any]) -> None: patch.start() self.__patches.append(patch) - def tearDown(self): + def tearDown(self) -> None: super().tearDown() for patch in reversed(self.__patches): patch.stop() - def then_error_was_raised(self, error_cls, allowed_substrings=()): + def then_error_was_raised( + self, + error_cls: type[BaseException], + allowed_substrings: Iterable[str] = (), + ) -> None: self.assertIsInstance(self.error, error_cls) self.assertTrue( any(mesg in str(self.error) for mesg in allowed_substrings), diff --git a/tests/benchmarks/test_benchmark_freshness_date_parser.py b/tests/benchmarks/test_benchmark_freshness_date_parser.py index cf22bbbf4..fc35bff87 100644 --- a/tests/benchmarks/test_benchmark_freshness_date_parser.py +++ b/tests/benchmarks/test_benchmark_freshness_date_parser.py @@ -20,7 +20,7 @@ def test_freshness_pattern_findall(benchmark: BenchmarkFixture) -> None: - def run(): + def run() -> None: for date_string in TRANSLATED_RELATIVE_STRINGS: PATTERN.findall(date_string) @@ -50,7 +50,7 @@ def test_freshness_pattern_sub_long_digit_run(benchmark: BenchmarkFixture) -> No def test_freshness_get_kwargs(benchmark: BenchmarkFixture) -> None: - def run(): + def run() -> None: for date_string in TRANSLATED_RELATIVE_STRINGS: freshness_date_parser.get_kwargs(date_string) diff --git a/tests/benchmarks/test_benchmark_parse.py b/tests/benchmarks/test_benchmark_parse.py index 94262cad4..2dd41a35b 100644 --- a/tests/benchmarks/test_benchmark_parse.py +++ b/tests/benchmarks/test_benchmark_parse.py @@ -32,7 +32,7 @@ def _benchmark_parse(benchmark: BenchmarkFixture, date_strings: list[str]) -> None: - def run(): + def run() -> None: for date_string in date_strings: dateparser.parse(date_string) diff --git a/tests/test_clean_api.py b/tests/test_clean_api.py index 324141f6b..146e63fd1 100644 --- a/tests/test_clean_api.py +++ b/tests/test_clean_api.py @@ -1,4 +1,5 @@ from datetime import date, datetime, timedelta +from typing import Any from parameterized import param, parameterized from pytz import utc @@ -9,9 +10,9 @@ class TestParseFunction(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented + self.result: datetime | None = NotImplemented @parameterized.expand( [ @@ -20,7 +21,9 @@ def setUp(self): param(date_string="January 25, 2014", expected_date=date(2014, 1, 25)), ] ) - def test_parse_dates_in_different_languages(self, date_string, expected_date): + def test_parse_dates_in_different_languages( + self, date_string: str, expected_date: date + ) -> None: self.when_date_is_parsed_with_defaults(date_string) self.then_parsed_date_is(expected_date) @@ -40,7 +43,9 @@ def test_parse_dates_in_different_languages(self, date_string, expected_date): ), ] ) - def test_parse_dates_with_specific_time(self, date_string, expected_date): + def test_parse_dates_with_specific_time( + self, date_string: str, expected_date: datetime + ) -> None: self.when_date_is_parsed_with_defaults(date_string) self.then_parsed_date_and_time_is(expected_date) @@ -64,8 +69,8 @@ def test_parse_dates_with_specific_time(self, date_string, expected_date): ] ) def test_parse_dates_with_specific_time_and_settings( - self, date_string, expected_date, relative - ): + self, date_string: str, expected_date: datetime, relative: datetime + ) -> None: self.when_date_is_parsed_with_settings( date_string, settings={"RELATIVE_BASE": relative} ) @@ -81,8 +86,8 @@ def test_parse_dates_with_specific_time_and_settings( ] ) def test_dates_which_match_languages_are_parsed( - self, date_string, languages, expected_date - ): + self, date_string: str, languages: list[str] | None, expected_date: date + ) -> None: self.when_date_is_parsed(date_string, languages=languages) self.then_parsed_date_is(expected_date) @@ -92,8 +97,8 @@ def test_dates_which_match_languages_are_parsed( ] ) def test_dates_which_do_not_match_languages_are_not_parsed( - self, date_string, languages - ): + self, date_string: str, languages: list[str] | None + ) -> None: self.when_date_is_parsed(date_string, languages=languages) self.then_date_was_not_parsed() @@ -107,8 +112,8 @@ def test_dates_which_do_not_match_languages_are_not_parsed( ] ) def test_dates_which_match_locales_are_parsed( - self, date_string, locales, expected_date - ): + self, date_string: str, locales: list[str], expected_date: date + ) -> None: self.when_date_is_parsed(date_string, locales=locales) self.then_parsed_date_is(expected_date) @@ -119,7 +124,9 @@ def test_dates_which_match_locales_are_parsed( param(date_string="6 yar 2019", locales=["ff-MR"]), ] ) - def test_locales_dropped_in_cldr_44_remain_supported(self, date_string, locales): + def test_locales_dropped_in_cldr_44_remain_supported( + self, date_string: str, locales: list[str] + ) -> None: # ff-CM/ff-GN/ff-MR were standalone locales up to CLDR 31 but were dropped in # CLDR 44 (regional data moved under ff-Latn). They remain valid locale codes # and resolve to the base `ff` data, so existing callers keep working. @@ -139,8 +146,14 @@ def test_locales_dropped_in_cldr_44_remain_supported(self, date_string, locales) ] ) def test_dates_parse_utc_offset_does_not_throw( - self, date_string, locales, languages, region, date_formats, expected_date - ): + self, + date_string: str, + locales: list[str], + languages: list[str] | None, + region: str, + date_formats: list[str], + expected_date: datetime, + ) -> None: """ Bug discovered by OSSFuzz that caused an exception in pytz to halt parsing Regression test to ensure that this is not reintroduced @@ -195,8 +208,8 @@ def test_dates_parse_utc_offset_does_not_throw( ] ) def test_dates_which_do_not_match_locales_are_not_parsed( - self, date_string, locales - ): + self, date_string: str, locales: list[str] + ) -> None: self.when_date_is_parsed(date_string, locales=locales) self.then_date_was_not_parsed() @@ -207,8 +220,8 @@ def test_dates_which_do_not_match_locales_are_not_parsed( ] ) def test_require_parts_month_year_parses_month_year( - self, date_string, expected_date - ): + self, date_string: str, expected_date: datetime + ) -> None: # Regression: when year is required, Mon-YY should be interpreted as month-year. base = datetime(2050, 1, 1, 0, 0) self.when_date_is_parsed_with_settings( @@ -222,7 +235,7 @@ def test_require_parts_month_year_parses_month_year( ) self.then_parsed_date_and_time_is(expected_date) - def test_require_parts_does_not_override_explicit_date_order(self): + def test_require_parts_does_not_override_explicit_date_order(self) -> None: # Explicit DATE_ORDER must be respected. base = datetime(2050, 1, 1, 0, 0) self.when_date_is_parsed_with_settings( @@ -235,7 +248,7 @@ def test_require_parts_does_not_override_explicit_date_order(self): ) self.then_date_was_not_parsed() - def test_require_parts_month_day_parses_month_day(self): + def test_require_parts_month_day_parses_month_day(self) -> None: # If day is required, Mon-XX should remain month-day. base = datetime(2000, 1, 1, 0, 0) self.when_date_is_parsed_with_settings( @@ -247,26 +260,33 @@ def test_require_parts_month_day_parses_month_day(self): ) self.then_parsed_date_and_time_is(datetime(2000, 10, 23, 0, 0)) - def when_date_is_parsed_with_defaults(self, date_string): + def when_date_is_parsed_with_defaults(self, date_string: str) -> None: self.result = dateparser.parse(date_string) - def when_date_is_parsed(self, date_string, languages=None, locales=None): + def when_date_is_parsed( + self, + date_string: str, + languages: list[str] | None = None, + locales: list[str] | None = None, + ) -> None: self.result = dateparser.parse( date_string, languages=languages, locales=locales ) - def when_date_is_parsed_with_settings(self, date_string, settings=None): + def when_date_is_parsed_with_settings( + self, date_string: str, settings: dict[str, Any] | None = None + ) -> None: self.result = dateparser.parse(date_string, settings=settings) def when_date_is_parsed_with_args_and_settings( self, - date_string, - languages=None, - locales=None, - region=None, - date_formats=None, - settings=None, - ): + date_string: str, + languages: list[str] | None = None, + locales: list[str] | None = None, + region: str | None = None, + date_formats: list[str] | None = None, + settings: dict[str, Any] | None = None, + ) -> None: self.result = dateparser.parse( date_string, languages=languages, @@ -276,24 +296,24 @@ def when_date_is_parsed_with_args_and_settings( settings=settings, ) - def then_parsed_date_is(self, expected_date): + def then_parsed_date_is(self, expected_date: date) -> None: self.assertEqual( self.result, datetime.combine(expected_date, datetime.min.time()) ) - def then_parsed_date_and_time_is(self, expected_date): + def then_parsed_date_and_time_is(self, expected_date: datetime) -> None: self.assertEqual(self.result, expected_date) - def then_date_was_not_parsed(self): + def then_date_was_not_parsed(self) -> None: self.assertIsNone(self.result) class TestIgnoreSurroundingTextSetting(BaseTestCase): """Tests for the opt-in ``IGNORE_SURROUNDING_TEXT`` setting (issue #518).""" - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented + self.result: object = NotImplemented @parameterized.expand( [ @@ -345,8 +365,8 @@ def setUp(self): ] ) def test_dates_with_surrounding_text_are_parsed( - self, date_string, languages, expected_datetime - ): + self, date_string: str, languages: list[str] | None, expected_datetime: datetime + ) -> None: self.when_date_is_parsed( date_string, languages=languages, @@ -362,8 +382,8 @@ def test_dates_with_surrounding_text_are_parsed( ] ) def test_dates_with_surrounding_text_are_not_parsed_by_default( - self, date_string, languages - ): + self, date_string: str, languages: list[str] | None + ) -> None: self.when_date_is_parsed(date_string, languages=languages) self.then_date_was_not_parsed() @@ -375,7 +395,9 @@ def test_dates_with_surrounding_text_are_not_parsed_by_default( param(date_string="hello world", languages=["en"]), ] ) - def test_non_dates_are_not_parsed_even_when_enabled(self, date_string, languages): + def test_non_dates_are_not_parsed_even_when_enabled( + self, date_string: str, languages: list[str] | None + ) -> None: self.when_date_is_parsed( date_string, languages=languages, @@ -383,7 +405,7 @@ def test_non_dates_are_not_parsed_even_when_enabled(self, date_string, languages ) self.then_date_was_not_parsed() - def test_surrounding_text_ignored_with_locales_argument(self): + def test_surrounding_text_ignored_with_locales_argument(self) -> None: self.when_date_is_parsed( "Actualisé le 17 avril 2019", locales=["fr-CA"], @@ -391,7 +413,7 @@ def test_surrounding_text_ignored_with_locales_argument(self): ) self.then_parsed_datetime_is(datetime(2019, 4, 17)) - def test_surrounding_text_ignored_with_region_argument(self): + def test_surrounding_text_ignored_with_region_argument(self) -> None: self.when_date_is_parsed( "Actualisé le 17 avril 2019", languages=["fr"], @@ -400,14 +422,14 @@ def test_surrounding_text_ignored_with_region_argument(self): ) self.then_parsed_datetime_is(datetime(2019, 4, 17)) - def test_surrounding_text_ignored_with_default_languages_setting(self): + def test_surrounding_text_ignored_with_default_languages_setting(self) -> None: self.when_date_is_parsed( "Actualisé le 17 avril 2019", settings={"IGNORE_SURROUNDING_TEXT": True, "DEFAULT_LANGUAGES": ["fr"]}, ) self.then_parsed_datetime_is(datetime(2019, 4, 17)) - def test_surrounding_text_ignored_with_detected_language(self): + def test_surrounding_text_ignored_with_detected_language(self) -> None: self.when_date_is_parsed( "Actualisé le 17 avril 2019", detect_languages_function=lambda text, confidence_threshold: ["fr"], @@ -415,7 +437,7 @@ def test_surrounding_text_ignored_with_detected_language(self): ) self.then_parsed_datetime_is(datetime(2019, 4, 17)) - def test_surrounding_text_ignored_with_date_formats(self): + def test_surrounding_text_ignored_with_date_formats(self) -> None: self.when_date_is_parsed( "Published on 16/04/2019", date_formats=["%d/%m/%Y"], @@ -424,7 +446,7 @@ def test_surrounding_text_ignored_with_date_formats(self): ) self.then_parsed_datetime_is(datetime(2019, 4, 16)) - def test_relative_date_with_surrounding_text(self): + def test_relative_date_with_surrounding_text(self) -> None: self.when_date_is_parsed( "asdf 3 hours ago asdf", languages=["en"], @@ -435,7 +457,7 @@ def test_relative_date_with_surrounding_text(self): ) self.then_parsed_datetime_is(datetime(2019, 4, 17, 9, 0)) - def test_strict_parsing_rejects_incomplete_remainder(self): + def test_strict_parsing_rejects_incomplete_remainder(self) -> None: # The remainder is parsed as if it were the whole input, so settings # such as STRICT_PARSING apply to it as usual. self.when_date_is_parsed( @@ -445,7 +467,7 @@ def test_strict_parsing_rejects_incomplete_remainder(self): ) self.then_date_was_not_parsed() - def test_surrounding_text_can_turn_non_dates_into_dates(self): + def test_surrounding_text_can_turn_non_dates_into_dates(self) -> None: # Documented caveat: with the setting enabled, a string that merely # contains date-like words produces a date. self.when_date_is_parsed( @@ -458,12 +480,12 @@ def test_surrounding_text_can_turn_non_dates_into_dates(self): ) self.then_parsed_datetime_is(datetime(2026, 3, 12)) - def test_search_dates_is_not_affected_by_default(self): + def test_search_dates_is_not_affected_by_default(self) -> None: # search_dates keeps relying on the strict behavior of get_date_data. self.result = search_dates("Actualisé le 17 avril 2019", languages=["fr"]) self.assertEqual([("le 17 avril 2019", datetime(2019, 4, 17))], self.result) - def test_trailing_timezone_is_preserved(self): + def test_trailing_timezone_is_preserved(self) -> None: # A recognized timezone at the trailing edge must not be discarded with # the surrounding text: wrapping a date in extra text yields the same # instant as parsing the bare date, timezone included. @@ -476,6 +498,7 @@ def test_trailing_timezone_is_preserved(self): languages=["en"], settings={"RETURN_AS_TIMEZONE_AWARE": True}, ) + assert wrapped is not None self.assertEqual(timedelta(hours=-5), wrapped.utcoffset()) self.assertEqual(unwrapped, wrapped) @@ -502,8 +525,8 @@ def test_trailing_timezone_is_preserved(self): ] ) def test_more_trailing_timezones_are_preserved( - self, wrapped, bare, tzname, utcoffset - ): + self, wrapped: str, bare: str, tzname: str, utcoffset: timedelta + ) -> None: # Like test_trailing_timezone_is_preserved, for further abbreviations: # wrapping the date in extra text yields the same tz-aware instant as # parsing the bare date. The timezone *name* is asserted (not only the @@ -514,11 +537,12 @@ def test_more_trailing_timezones_are_preserved( bare_result = dateparser.parse( bare, languages=["en"], settings={"RETURN_AS_TIMEZONE_AWARE": True} ) + assert wrapped_result is not None self.assertEqual(tzname, wrapped_result.tzname()) self.assertEqual(utcoffset, wrapped_result.utcoffset()) self.assertEqual(bare_result, wrapped_result) - def test_parenthesized_trailing_timezone_is_applied(self): + def test_parenthesized_trailing_timezone_is_applied(self) -> None: # A parenthesized trailing timezone is applied end to end. GMT is a # dictionary token, so the parentheses are split off and it is kept via # the ordinary known-word branch, not via is_timezone_token (which the @@ -536,11 +560,12 @@ def test_parenthesized_trailing_timezone_is_applied(self): languages=["en"], settings={"RETURN_AS_TIMEZONE_AWARE": True}, ) + assert wrapped is not None self.assertEqual("GMT", wrapped.tzname()) self.assertEqual(timedelta(0), wrapped.utcoffset()) self.assertEqual(bare, wrapped) - def test_only_trailing_timezone_is_preserved(self): + def test_only_trailing_timezone_is_preserved(self) -> None: # tz-recognition when stripping edge tokens is deliberately applied to # the trailing edge only: a timezone that follows the date is kept and # applied, while the same abbreviation before the date is treated as @@ -558,13 +583,14 @@ def test_only_trailing_timezone_is_preserved(self): settings={"RETURN_AS_TIMEZONE_AWARE": True}, ) # Trailing EST is applied... + assert trailing is not None self.assertEqual(timedelta(hours=-5), trailing.utcoffset()) # ...leading EST is not: the result matches the same string with no # timezone at all, and does not carry the EST offset. self.assertEqual(without_tz, leading) self.assertNotEqual(trailing, leading) - def test_trailing_timezone_followed_by_more_text_is_dropped(self): + def test_trailing_timezone_followed_by_more_text_is_dropped(self) -> None: # Known limitation: a trailing timezone is kept only when it is the # final token. If unrecognized text follows it, the tokenizer merges # the two, so the timezone is stripped together with that text and its @@ -576,10 +602,11 @@ def test_trailing_timezone_followed_by_more_text_is_dropped(self): languages=["en"], settings=settings, ) + assert result is not None self.assertEqual(datetime(2000, 3, 23, 13, 21), result.replace(tzinfo=None)) self.assertNotEqual(timedelta(hours=-5), result.utcoffset()) - def test_leading_numeric_noise_is_not_ignored(self): + def test_leading_numeric_noise_is_not_ignored(self) -> None: # Documented limitation: stripping stops at the first recognized token, # and a number counts as recognized, so leading text that contains a # number of its own blocks parsing. search_dates covers this shape. @@ -590,11 +617,11 @@ def test_leading_numeric_noise_is_not_ignored(self): ) self.then_date_was_not_parsed() - def when_date_is_parsed(self, date_string, **kwargs): + def when_date_is_parsed(self, date_string: str, **kwargs: Any) -> None: self.result = dateparser.parse(date_string, **kwargs) - def then_parsed_datetime_is(self, expected_datetime): + def then_parsed_datetime_is(self, expected_datetime: datetime) -> None: self.assertEqual(expected_datetime, self.result) - def then_date_was_not_parsed(self): + def then_date_was_not_parsed(self) -> None: self.assertIsNone(self.result) diff --git a/tests/test_data.py b/tests/test_data.py index 06430dc9a..4863b0dea 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -1,10 +1,13 @@ +from collections.abc import Iterable, Mapping from itertools import chain +from typing import Any import regex as re from parameterized import parameterized -from dateparser.data import language_locale_dict +from dateparser.data.languages_info import language_locale_dict from dateparser.languages import default_loader +from dateparser.languages.locale import Locale from tests import BaseTestCase DEFAULT_MONTH_PATTERN = re.compile(r"^M?\d+$", re.U) @@ -109,11 +112,11 @@ ] -def is_invalid_translation(translation): +def is_invalid_translation(translation: object) -> bool: return (not (translation and isinstance(translation, str))) or "." in translation -def is_invalid_month_translation(translation): +def is_invalid_month_translation(translation: object) -> bool | re.Match[str] | None: return ( (not (translation and isinstance(translation, str))) or "." in translation @@ -121,7 +124,7 @@ def is_invalid_month_translation(translation): ) -def is_invalid_am_pm_translation(translation): +def is_invalid_am_pm_translation(translation: object) -> bool | re.Match[str] | None: return ( (not (translation and isinstance(translation, str))) or "." in translation @@ -129,21 +132,23 @@ def is_invalid_am_pm_translation(translation): ) -def is_invalid_simplification(simplification): +def is_invalid_simplification(simplification: object) -> bool: if not isinstance(simplification, dict) or len(simplification) != 1: return True key, value = next(iter(simplification.items())) return not isinstance(key, str) or not isinstance(value, str) -def is_invalid_relative_mapping(relative_mapping): +def is_invalid_relative_mapping(relative_mapping: tuple[object, object]) -> bool: key, value = relative_mapping if not (key and value and isinstance(key, str) and isinstance(value, list)): return True return not all(isinstance(x, str) for x in value) -def is_invalid_relative_regex_mapping(relative_regex_mapping): +def is_invalid_relative_regex_mapping( + relative_regex_mapping: tuple[object, object], +) -> bool: key, value = relative_regex_mapping if not (key and value and isinstance(key, str) and isinstance(value, list)): return True @@ -151,13 +156,13 @@ def is_invalid_relative_regex_mapping(relative_regex_mapping): class TestLocaleInfo(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.info = NotImplemented - self.shortname = NotImplemented + self.info: Mapping[str, Any] = NotImplemented + self.shortname: str = NotImplemented @parameterized.expand(all_locale_params) - def test_extra_keys(self, locale): + def test_extra_keys(self, locale: Locale) -> None: self.given_locale_info(locale) extra_keys = list(set(self.info.keys()) - set(VALID_KEYS)) self.assertFalse( @@ -165,213 +170,213 @@ def test_extra_keys(self, locale): ) @parameterized.expand(all_locale_params) - def test_necessary_keys(self, locale): + def test_necessary_keys(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_keys_present_in_info(NECESSARY_KEYS) self.then_translations_present_in_info(NECESSARY_KEYS) @parameterized.expand(all_locale_params) - def test_name(self, locale): + def test_name(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_name_is_valid() @parameterized.expand(all_locale_params) - def test_date_order(self, locale): + def test_date_order(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_date_order_is_valid() @parameterized.expand(all_locale_params) - def test_january_translation(self, locale): + def test_january_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("january") @parameterized.expand(all_locale_params) - def test_february_translation(self, locale): + def test_february_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("february") @parameterized.expand(all_locale_params) - def test_march_translation(self, locale): + def test_march_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("march") @parameterized.expand(all_locale_params) - def test_april_translation(self, locale): + def test_april_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("april") @parameterized.expand(all_locale_params) - def test_may_translation(self, locale): + def test_may_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("may") @parameterized.expand(all_locale_params) - def test_june_translation(self, locale): + def test_june_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("june") @parameterized.expand(all_locale_params) - def test_july_translation(self, locale): + def test_july_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("july") @parameterized.expand(all_locale_params) - def test_august_translation(self, locale): + def test_august_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("august") @parameterized.expand(all_locale_params) - def test_september_translation(self, locale): + def test_september_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("september") @parameterized.expand(all_locale_params) - def test_october_translation(self, locale): + def test_october_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("october") @parameterized.expand(all_locale_params) - def test_november_translation(self, locale): + def test_november_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("november") @parameterized.expand(all_locale_params) - def test_december_translation(self, locale): + def test_december_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_month_translations_are_valid("december") @parameterized.expand(all_locale_params) - def test_am_translation(self, locale): + def test_am_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_am_pm_translations_are_valid("am") @parameterized.expand(all_locale_params) - def test_pm_translation(self, locale): + def test_pm_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_am_pm_translations_are_valid("pm") @parameterized.expand(all_locale_params) - def test_sunday_translation(self, locale): + def test_sunday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("sunday") @parameterized.expand(all_locale_params) - def test_monday_translation(self, locale): + def test_monday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("monday") @parameterized.expand(all_locale_params) - def test_tuesday_translation(self, locale): + def test_tuesday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("tuesday") @parameterized.expand(all_locale_params) - def test_wednesday_translation(self, locale): + def test_wednesday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("wednesday") @parameterized.expand(all_locale_params) - def test_thursday_translation(self, locale): + def test_thursday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("thursday") @parameterized.expand(all_locale_params) - def test_friday_translation(self, locale): + def test_friday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("friday") @parameterized.expand(all_locale_params) - def test_saturday_translation(self, locale): + def test_saturday_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("saturday") @parameterized.expand(all_locale_params) - def test_year_translation(self, locale): + def test_year_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("year") @parameterized.expand(all_locale_params) - def test_month_translation(self, locale): + def test_month_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("month") @parameterized.expand(all_locale_params) - def test_week_translation(self, locale): + def test_week_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("week") @parameterized.expand(all_locale_params) - def test_day_translation(self, locale): + def test_day_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("day") @parameterized.expand(all_locale_params) - def test_hour_translation(self, locale): + def test_hour_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("hour") @parameterized.expand(all_locale_params) - def test_minute_translation(self, locale): + def test_minute_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("minute") @parameterized.expand(all_locale_params) - def test_second_translation(self, locale): + def test_second_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("second") @parameterized.expand(all_locale_params) - def test_ago_translation(self, locale): + def test_ago_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("ago") @parameterized.expand(all_locale_params) - def test_in_translation(self, locale): + def test_in_translation(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_translations_are_valid("in") @parameterized.expand(all_locale_params) - def test_skip_tokens(self, locale): + def test_skip_tokens(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_skip_pertain_tokens_are_valid("skip") @parameterized.expand(all_locale_params) - def test_pertain_tokens(self, locale): + def test_pertain_tokens(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_skip_pertain_tokens_are_valid("pertain") @parameterized.expand(all_locale_params) - def test_simplifications(self, locale): + def test_simplifications(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_simplifications_are_valid() @parameterized.expand(all_locale_params) - def test_relative_type(self, locale): + def test_relative_type(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_relative_type_is_valid() @parameterized.expand(all_locale_params) - def test_relative_type_regex(self, locale): + def test_relative_type_regex(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_relative_type_regex_is_valid() @parameterized.expand(all_locale_params) - def test_no_word_spacing(self, locale): + def test_no_word_spacing(self, locale: Locale) -> None: self.given_locale_info(locale) self.then_no_word_spacing_is_valid() - def given_locale_info(self, locale): + def given_locale_info(self, locale: Locale) -> None: self.info = locale.info self.shortname = locale.shortname - def then_keys_present_in_info(self, keys_list): + def then_keys_present_in_info(self, keys_list: Iterable[str]) -> None: absent_keys = list(set(keys_list) - set(self.info.keys())) self.assertFalse( absent_keys, "{} not found in locale {}".format(", ".join(absent_keys), self.shortname), ) - def then_translations_present_in_info(self, keys_list): + def then_translations_present_in_info(self, keys_list: Iterable[str]) -> None: no_translation_keys = [key for key in keys_list if not self.info.get(key)] self.assertFalse( no_translation_keys, @@ -380,7 +385,7 @@ def then_translations_present_in_info(self, keys_list): ), ) - def then_name_is_valid(self): + def then_name_is_valid(self) -> None: name = self.info["name"] self.assertIsInstance( name, @@ -393,7 +398,7 @@ def then_name_is_valid(self): f"Invalid name: {name} for locale {self.shortname}", ) - def then_date_order_is_valid(self): + def then_date_order_is_valid(self) -> None: if "date_order" in self.info: date_order = self.info["date_order"] self.assertIsInstance( @@ -407,7 +412,7 @@ def then_date_order_is_valid(self): f"Invalid date_order {date_order} for {self.shortname}", ) - def then_month_translations_are_valid(self, month): + def then_month_translations_are_valid(self, month: str) -> None: if month in self.info: month_translations = self.info[month] self.assertIsInstance( @@ -425,7 +430,7 @@ def then_month_translations_are_valid(self, month): ), ) - def then_am_pm_translations_are_valid(self, key): + def then_am_pm_translations_are_valid(self, key: str) -> None: if key in self.info: translations_list = self.info[key] self.assertIsInstance( @@ -443,7 +448,7 @@ def then_am_pm_translations_are_valid(self, key): ), ) - def then_translations_are_valid(self, key): + def then_translations_are_valid(self, key: str) -> None: if key in self.info: translations_list = self.info[key] self.assertIsInstance( @@ -461,7 +466,7 @@ def then_translations_are_valid(self, key): ), ) - def then_skip_pertain_tokens_are_valid(self, key): + def then_skip_pertain_tokens_are_valid(self, key: str) -> None: if key in self.info: tokens_list = self.info[key] self.assertIsInstance( @@ -481,7 +486,7 @@ def then_skip_pertain_tokens_are_valid(self, key): ), ) - def then_simplifications_are_valid(self): + def then_simplifications_are_valid(self) -> None: if "simplifications" in self.info: simplifications_list = self.info["simplifications"] self.assertIsInstance( @@ -500,7 +505,7 @@ def then_simplifications_are_valid(self): + ", each simplification must be a single string to string mapping", ) - def then_relative_type_is_valid(self): + def then_relative_type_is_valid(self) -> None: if "relative-type" in self.info: relative_type_dict = self.info["relative-type"] self.assertIsInstance( @@ -519,7 +524,7 @@ def then_relative_type_is_valid(self): + ", each mapping must be a string to list (of strings) mapping", ) - def then_relative_type_regex_is_valid(self): + def then_relative_type_regex_is_valid(self) -> None: if "relative-type-regex" in self.info: relative_type_dict = self.info["relative-type-regex"] self.assertIsInstance( @@ -538,7 +543,7 @@ def then_relative_type_regex_is_valid(self): + ", each mapping must be a string to list (of strings) mapping", ) - def then_no_word_spacing_is_valid(self): + def then_no_word_spacing_is_valid(self) -> None: if "no_word_spacing" in self.info: no_word_spacing = self.info["no_word_spacing"] self.assertIsInstance( diff --git a/tests/test_date.py b/tests/test_date.py index 70e647abe..e7394170f 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1,10 +1,12 @@ import datetime as real_datetime import os import unittest +from collections.abc import Iterable from datetime import datetime, timedelta from datetime import timezone as dttz from itertools import product from time import tzset +from typing import Any from unittest.mock import Mock, patch import pytest @@ -14,13 +16,14 @@ from dateparser import date from dateparser.conf import Settings from dateparser.date import DateData +from dateparser.languages.locale import Locale from tests import BaseTestCase class TestDateRangeFunction(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented + self.result: list[datetime] = NotImplemented @parameterized.expand( [ @@ -31,7 +34,9 @@ def setUp(self): ) ] ) - def test_date_range(self, begin, end, expected_length): + def test_date_range( + self, begin: datetime, end: datetime, expected_length: int + ) -> None: self.when_date_range_generated(begin, end) self.then_range_length_is(expected_length) self.then_all_dates_in_range_are_present(begin, end) @@ -61,7 +66,9 @@ def test_date_range(self, begin, end, expected_length): ), ] ) - def test_one_date_for_each_month(self, begin, end, expected_months): + def test_one_date_for_each_month( + self, begin: datetime, end: datetime, expected_months: list[tuple[int, int]] + ) -> None: self.when_date_range_generated(begin, end, months=1) self.then_expected_months_are(expected_months) @@ -76,7 +83,9 @@ def test_one_date_for_each_month(self, begin, end, expected_months): "second", ] ) - def test_should_reject_easily_mistaken_dateutil_arguments(self, invalid_period): + def test_should_reject_easily_mistaken_dateutil_arguments( + self, invalid_period: str + ) -> None: self.when_date_range_generated( begin=datetime(2014, 6, 15), end=datetime(2014, 6, 25), @@ -84,43 +93,47 @@ def test_should_reject_easily_mistaken_dateutil_arguments(self, invalid_period): ) self.then_period_was_rejected(invalid_period) - def when_date_range_generated(self, begin, end, **size): + def when_date_range_generated( + self, begin: datetime, end: datetime, **size: int + ) -> None: try: self.result = list(date.date_range(begin, end, **size)) except Exception as error: self.error = error - def then_expected_months_are(self, expected): + def then_expected_months_are(self, expected: list[tuple[int, int]]) -> None: self.assertEqual(expected, [(d.year, d.month) for d in self.result]) - def then_range_length_is(self, expected_length): + def then_range_length_is(self, expected_length: int) -> None: self.assertEqual(expected_length, len(self.result)) - def then_all_dates_in_range_are_present(self, begin, end): + def then_all_dates_in_range_are_present( + self, begin: datetime, end: datetime + ) -> None: date_under_test = begin while date_under_test < end: self.assertIn(date_under_test, self.result) date_under_test += timedelta(days=1) - def then_range_is_in_ascending_order(self): + def then_range_is_in_ascending_order(self) -> None: for i in range(len(self.result) - 1): self.assertLess(self.result[i], self.result[i + 1]) - def then_period_was_rejected(self, period): + def then_period_was_rejected(self, period: str) -> None: self.then_error_was_raised(ValueError, [f"Invalid argument: {period}"]) class TestGetIntersectingPeriodsFunction(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented + self.result: list[datetime] = NotImplemented @parameterized.expand( [param(low=datetime(2014, 6, 15), high=datetime(2014, 6, 16), length=1)] ) def test_date_arguments_and_date_range_with_default_post_days( - self, low, high, length - ): + self, low: datetime, high: datetime, length: int + ) -> None: self.when_intersecting_period_calculated(low, high, period_size="day") self.then_all_dates_in_range_are_present(begin=low, end=high) self.then_date_range_length_is(length) @@ -168,8 +181,8 @@ def test_date_arguments_and_date_range_with_default_post_days( ] ) def test_dates_in_intersecting_period_should_use_first_day_when_period_is_month( - self, low, high, expected_results - ): + self, low: datetime, high: datetime, expected_results: list[datetime] + ) -> None: self.when_intersecting_period_calculated(low, high, period_size="month") self.then_results_are(expected_results) @@ -220,8 +233,8 @@ def test_dates_in_intersecting_period_should_use_first_day_when_period_is_month( ] ) def test_dates_in_intersecting_period_should_use_first_month_and_first_day_when_period_is_year( - self, low, high, expected_results - ): + self, low: datetime, high: datetime, expected_results: list[datetime] + ) -> None: self.when_intersecting_period_calculated(low, high, period_size="year") self.then_results_are(expected_results) @@ -275,7 +288,13 @@ def test_dates_in_intersecting_period_should_use_first_month_and_first_day_when_ ), ] ) - def test_periods(self, low, high, period_size, expected_results): + def test_periods( + self, + low: datetime, + high: datetime, + period_size: str, + expected_results: list[datetime], + ) -> None: self.when_intersecting_period_calculated(low, high, period_size=period_size) self.then_results_are(expected_results) @@ -291,7 +310,9 @@ def test_periods(self, low, high, period_size, expected_results): param("some_period"), ] ) - def test_should_reject_easily_mistaken_dateutil_arguments(self, period_size): + def test_should_reject_easily_mistaken_dateutil_arguments( + self, period_size: str + ) -> None: self.when_intersecting_period_calculated( low=datetime(2014, 6, 15), high=datetime(2014, 6, 25), @@ -313,11 +334,15 @@ def test_should_reject_easily_mistaken_dateutil_arguments(self, period_size): ), ] ) - def test_empty_period(self, low, high, period_size): + def test_empty_period( + self, low: datetime, high: datetime, period_size: str + ) -> None: self.when_intersecting_period_calculated(low, high, period_size) self.then_period_is_empty() - def when_intersecting_period_calculated(self, low, high, period_size): + def when_intersecting_period_calculated( + self, low: datetime, high: datetime, period_size: str + ) -> None: try: self.result = list( date.get_intersecting_periods(low, high, period=period_size) @@ -325,26 +350,28 @@ def when_intersecting_period_calculated(self, low, high, period_size): except Exception as error: self.error = error - def then_results_are(self, expected_results): + def then_results_are(self, expected_results: list[datetime]) -> None: self.assertEqual(expected_results, self.result) - def then_date_range_length_is(self, size): + def then_date_range_length_is(self, size: int) -> None: self.assertEqual(size, len(self.result)) - def then_all_dates_in_range_are_present(self, begin, end): + def then_all_dates_in_range_are_present( + self, begin: datetime, end: datetime + ) -> None: date_under_test = begin while date_under_test < end: self.assertIn(date_under_test, self.result) date_under_test += timedelta(days=1) - def then_period_is_empty(self): + def then_period_is_empty(self) -> None: self.assertEqual([], self.result) class TestParseWithFormatsFunction(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented + self.result: DateData = NotImplemented @parameterized.expand( [ @@ -352,8 +379,8 @@ def setUp(self): ] ) def test_date_with_not_matching_format_is_not_parsed( - self, date_string, date_formats - ): + self, date_string: str, date_formats: list[str] + ) -> None: self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_not_parsed() @@ -366,7 +393,9 @@ def test_date_with_not_matching_format_is_not_parsed( ), ] ) - def test_should_parse_date(self, date_string, date_formats, expected_result): + def test_should_parse_date( + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_parsed() self.then_parsed_period_is("day") @@ -388,7 +417,9 @@ def test_should_parse_date(self, date_string, date_formats, expected_result): ("2020-W53-5", "%G-W%V-%w", datetime(2021, 1, 1)), ] ) - def test_should_preserve_complete_week_date(self, text, fmt, expected): + def test_should_preserve_complete_week_date( + self, text: str, fmt: str, expected: datetime + ) -> None: self.given_now(2026, 9, 15) for preference in ("first", "last", "current"): with self.subTest(preference=preference): @@ -417,7 +448,9 @@ def test_should_preserve_complete_week_date(self, text, fmt, expected): ("09-1", "%W-%w", 2026), ] ) - def test_incomplete_week_date_keeps_date_preferences(self, text, fmt, year): + def test_incomplete_week_date_keeps_date_preferences( + self, text: str, fmt: str, year: int + ) -> None: self.given_now(2026, 9, 15) settings = Settings().replace( RELATIVE_BASE=datetime(2026, 9, 15), @@ -436,7 +469,7 @@ def test_incomplete_week_date_keeps_date_preferences(self, text, fmt, year): ("2024-W01-8", "%G-W%V-%u"), ] ) - def test_invalid_iso_week_date_is_not_parsed(self, text, fmt): + def test_invalid_iso_week_date_is_not_parsed(self, text: str, fmt: str) -> None: self.when_date_is_parsed_with_formats(text, [fmt]) self.then_date_was_not_parsed() @@ -460,8 +493,8 @@ def test_invalid_iso_week_date_is_not_parsed(self, text, fmt): ] ) def test_should_parse_day_of_year_format( - self, date_string, date_formats, expected_result - ): + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: """Format %%j (day of year) should correctly set both month and day.""" self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_parsed() @@ -513,8 +546,8 @@ def test_should_parse_day_of_year_format( ] ) def test_should_parse_day_of_year_boundaries( - self, date_string, date_formats, expected_result - ): + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: """Format %%j (day of year) should handle month and leap year edges.""" self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_parsed() @@ -535,7 +568,9 @@ def test_should_parse_day_of_year_boundaries( param(date_string="1999777", date_formats=["%Y%j"]), ] ) - def test_should_not_parse_out_of_range_day_of_year(self, date_string, date_formats): + def test_should_not_parse_out_of_range_day_of_year( + self, date_string: str, date_formats: list[str] + ) -> None: """Format %%j (day of year) should reject days the year does not have.""" self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_not_parsed() @@ -551,8 +586,12 @@ def test_should_not_parse_out_of_range_day_of_year(self, date_string, date_forma ] ) def test_should_use_current_year_for_dates_without_year( - self, date_string, date_formats, expected_month, expected_day - ): + self, + date_string: str, + date_formats: list[str], + expected_month: int, + expected_day: int, + ) -> None: self.given_now(2015, 2, 4) self.when_date_is_parsed_with_formats(date_string, date_formats) self.then_date_was_parsed() @@ -592,14 +631,14 @@ def test_should_use_current_year_for_dates_without_year( ) def test_should_use_correct_day_from_settings_for_dates_without_day( self, - date_string, - date_formats, - expected_year, - expected_month, - today_day, - prefer_day_of_month, - expected_day, - ): + date_string: str, + date_formats: list[str], + expected_year: int, + expected_month: int, + today_day: int, + prefer_day_of_month: str, + expected_day: int, + ) -> None: self.given_now(2014, 8, today_day) settings_mod = Settings() settings_mod.PREFER_DAY_OF_MONTH = prefer_day_of_month @@ -643,14 +682,14 @@ def test_should_use_correct_day_from_settings_for_dates_without_day( ) def test_should_use_correct_month_from_settings_for_dates_without_month( self, - date_string, - date_formats, - expected_year, - prefer_month_of_year, - current_month, - expected_month, - expected_day, - ): + date_string: str, + date_formats: list[str], + expected_year: int, + prefer_month_of_year: str, + current_month: int, + expected_month: int, + expected_day: int, + ) -> None: self.given_now(2014, current_month, 1) settings_mod = Settings() settings_mod.PREFER_MONTH_OF_YEAR = prefer_month_of_year @@ -678,16 +717,16 @@ def test_should_use_correct_month_from_settings_for_dates_without_month( ) def test_should_use_correct_day_n_month_from_settings_for_dates_without_day_n_month( self, - date_string, - date_formats, - current_day, - current_month, - prefer_day_of_month, - prefer_month_of_year, - expected_year, - expected_month, - expected_day, - ): + date_string: str, + date_formats: list[str], + current_day: int, + current_month: int, + prefer_day_of_month: str, + prefer_month_of_year: str, + expected_year: int, + expected_month: int, + expected_day: int, + ) -> None: self.given_now(2014, current_month, current_day) settings_mod = Settings() settings_mod.PREFER_DAY_OF_MONTH = prefer_day_of_month @@ -699,7 +738,7 @@ def test_should_use_correct_day_n_month_from_settings_for_dates_without_day_n_mo datetime(year=expected_year, month=expected_month, day=expected_day) ) - def given_now(self, year, month, day, **time): + def given_now(self, year: int, month: int, day: int, **time: Any) -> None: now = datetime(year, month, day, **time) datetime_mock = Mock(wraps=datetime) datetime_mock.utcnow = Mock(return_value=now) @@ -709,40 +748,43 @@ def given_now(self, year, month, day, **time): self.add_patch(patch("dateparser.utils.datetime", new=datetime_mock)) def when_date_is_parsed_with_formats( - self, date_string, date_formats, custom_settings=None - ): + self, + date_string: str, + date_formats: Iterable[str], + custom_settings: Settings | None = None, + ) -> None: self.result = date.parse_with_formats( date_string, date_formats, custom_settings or Settings() ) - def then_date_was_not_parsed(self): + def then_date_was_not_parsed(self) -> None: self.assertIsNotNone(self.result) self.assertIsNone(self.result["date_obj"]) - def then_date_was_parsed(self): + def then_date_was_parsed(self) -> None: self.assertIsNotNone(self.result) self.assertIsNotNone(self.result["date_obj"]) - def then_parsed_date_is(self, date_obj): + def then_parsed_date_is(self, date_obj: datetime) -> None: self.assertEqual(date_obj.date(), self.result["date_obj"].date()) - def then_parsed_period_is(self, period): + def then_parsed_period_is(self, period: str) -> None: self.assertEqual(period, self.result["period"]) class TestDateDataParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.parser = NotImplemented - self.result = NotImplemented - self.multiple_results = NotImplemented + self.parser: date.DateDataParser = NotImplemented + self.result: DateData = NotImplemented + self.multiple_results: list[DateData | Exception] = NotImplemented @parameterized.expand( [ param("10:04am EDT"), ] ) - def test_time_without_date_should_use_today(self, date_string): + def test_time_without_date_should_use_today(self, date_string: str) -> None: self.given_parser(settings={"RELATIVE_BASE": datetime(2020, 7, 19)}) self.when_date_string_is_parsed(date_string) self.then_date_was_parsed() @@ -773,13 +815,13 @@ def test_time_without_date_should_use_today(self, date_string): param("снощи", days_ago=1), ] ) - def test_temporal_nouns_are_parsed(self, date_string, days_ago): + def test_temporal_nouns_are_parsed(self, date_string: str, days_ago: int) -> None: self.given_parser() self.when_date_string_is_parsed(date_string) self.then_date_was_parsed() self.then_date_is_n_days_ago(days=days_ago) - def test_should_not_assume_language_too_early(self): + def test_should_not_assume_language_too_early(self) -> None: dates_to_parse = { "07/07/2014": datetime(2014, 7, 7).date(), # any language "07.jul.2014 | 12:52": datetime(2014, 7, 7).date(), # en, es, pt, nl @@ -812,26 +854,28 @@ def test_should_not_assume_language_too_early(self): param(date_string="24 януари 2015г.", locale="bg"), ] ) - def test_returned_detected_locale_should_be(self, date_string, locale): + def test_returned_detected_locale_should_be( + self, date_string: str, locale: str + ) -> None: self.given_parser() self.when_date_string_is_parsed(date_string) self.then_detected_locale(locale) - def test_try_previous_locales_false(self): + def test_try_previous_locales_false(self) -> None: self.given_parser(try_previous_locales=False) self.when_date_string_is_parsed("Mañana") # es self.then_detected_locale("es") self.when_date_string_is_parsed("2020-05-01") self.then_detected_locale("en") - def test_try_previous_locales_true(self): + def test_try_previous_locales_true(self) -> None: self.given_parser(try_previous_locales=True) self.when_date_string_is_parsed("Mañana") # es self.then_detected_locale("es") self.when_date_string_is_parsed("2020-05-01") self.then_detected_locale("es") - def test_try_previous_locales_order_deterministic(self): + def test_try_previous_locales_order_deterministic(self) -> None: self.given_parser(try_previous_locales=True) self.when_date_string_is_parsed("Mañana") # es self.then_detected_locale("es") @@ -844,13 +888,15 @@ def test_try_previous_locales_order_deterministic(self): param("2014-10-09T17:57:39+00:00"), ] ) - def test_get_date_data_should_not_strip_timezone_info(self, date_string): + def test_get_date_data_should_not_strip_timezone_info( + self, date_string: str + ) -> None: self.given_parser() self.when_date_string_is_parsed(date_string) self.then_date_was_parsed() self.then_parsed_date_has_timezone() - def test_ignore_surrounding_text_setting_parses_wrapped_date(self): + def test_ignore_surrounding_text_setting_parses_wrapped_date(self) -> None: # Issue #518: a date wrapped in harmless extra text is parsed when the # ``IGNORE_SURROUNDING_TEXT`` setting is enabled. self.given_parser( @@ -862,7 +908,7 @@ def test_ignore_surrounding_text_setting_parses_wrapped_date(self): self.then_detected_locale("fr") self.then_period_is("day") - def test_get_date_data_ignores_surrounding_text_only_when_enabled(self): + def test_get_date_data_ignores_surrounding_text_only_when_enabled(self) -> None: # The safety property of the ``IGNORE_SURROUNDING_TEXT`` setting: by # default, ``get_date_data`` keeps requiring the whole string to be a # date, so language detection and ``search_dates`` are unaffected. @@ -870,7 +916,7 @@ def test_get_date_data_ignores_surrounding_text_only_when_enabled(self): self.when_date_string_is_parsed("Actualisé le 17 avril 2019") self.then_date_was_not_parsed() - def test_ignore_surrounding_text_with_try_previous_locales(self): + def test_ignore_surrounding_text_with_try_previous_locales(self) -> None: self.given_parser( restrict_to_languages=["fr", "en"], try_previous_locales=True, @@ -907,7 +953,9 @@ def test_ignore_surrounding_text_with_try_previous_locales(self): ), ] ) - def test_parse_date_using_format(self, date_string, date_formats, expected_result): + def test_parse_date_using_format( + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser() self.when_date_string_is_parsed(date_string, date_formats) @@ -925,11 +973,11 @@ def test_parse_date_using_format(self, date_string, date_formats, expected_resul ] ) def test_parsing_date_using_invalid_type_date_format_must_raise_error( - self, date_string, date_formats - ): + self, date_string: str, date_formats: object + ) -> None: self.given_local_tz_offset(0) self.given_parser() - self.when_date_string_is_parsed(date_string, date_formats) + self.when_date_string_is_parsed(date_string, date_formats) # type: ignore[arg-type] self.then_error_was_raised( TypeError, [ @@ -948,10 +996,10 @@ def test_parsing_date_using_invalid_type_date_format_must_raise_error( ] ) def test_parsing_date_using_invalid_type_date_string_must_raise_error( - self, date_string - ): + self, date_string: object + ) -> None: self.given_parser() - self.when_date_string_is_parsed(date_string) + self.when_date_string_is_parsed(date_string) # type: ignore[arg-type] self.then_error_was_raised(TypeError, ["Input type must be str"]) @parameterized.expand( @@ -963,8 +1011,8 @@ def test_parsing_date_using_invalid_type_date_string_must_raise_error( ] ) def test_parse_date_with_timezones_not_using_formats( - self, date_string, expected_result - ): + self, date_string: str, expected_result: datetime + ) -> None: self.given_parser(settings={"TO_TIMEZONE": "UTC"}) self.when_date_string_is_parsed(date_string) self.then_date_was_parsed() @@ -982,8 +1030,8 @@ def test_parse_date_with_timezones_not_using_formats( ] ) def test_parse_date_with_timezones_using_formats_ignore_timezone( - self, date_string, date_formats, expected_result - ): + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser() self.when_date_string_is_parsed(date_string, date_formats) @@ -1000,8 +1048,8 @@ def test_parse_date_with_timezones_using_formats_ignore_timezone( ] ) def test_should_parse_with_no_break_space_in_dates( - self, date_string, expected_result - ): + self, date_string: str, expected_result: datetime + ) -> None: self.given_parser() self.when_date_string_is_parsed(date_string) self.then_date_was_parsed() @@ -1024,7 +1072,9 @@ def test_should_parse_with_no_break_space_in_dates( ), ] ) - def test_get_date_tuple(self, date_string, expected_result): + def test_get_date_tuple( + self, date_string: str, expected_result: tuple[datetime, str, str] + ) -> None: self.given_parser() self.when_get_date_tuple_is_called(date_string) self.then_returned_tuple_is(expected_result) @@ -1061,7 +1111,7 @@ def test_get_date_tuple(self, date_string, expected_result): ), ] ) - def test_short_weekday_names(self, date_string, expected): + def test_short_weekday_names(self, date_string: str, expected: datetime) -> None: if "Mo" in date_string: pytest.xfail( "Known bug: 'Mo' is being interpreted as a month instead of a weekday and needs to be fixed." @@ -1072,30 +1122,34 @@ def test_short_weekday_names(self, date_string, expected): self.when_date_string_is_parsed(date_string) self.then_parsed_datetime_is(expected) - def given_now(self, year, month, day, **time): + def given_now(self, year: int, month: int, day: int, **time: Any) -> None: now = real_datetime.datetime(year, month, day, **time) # Patch the datetime *class* in each target module class DateParserDateTime(real_datetime.datetime): @classmethod - def now(cls, tz=None): + def now( # type: ignore[override] + cls, tz: real_datetime.tzinfo | None = None + ) -> real_datetime.datetime: return now.replace(tzinfo=tz) if tz else now @classmethod - def utcnow(cls): + def utcnow(cls) -> real_datetime.datetime: # type: ignore[override] return now @classmethod - def today(cls): + def today(cls) -> real_datetime.datetime: # type: ignore[override] return now self.add_patch(patch("dateparser.date.datetime", DateParserDateTime)) self.add_patch(patch("dateparser.parser.datetime", DateParserDateTime)) - def given_parser(self, restrict_to_languages=None, **params): + def given_parser( + self, restrict_to_languages: list[str] | None = None, **params: Any + ) -> None: self.parser = date.DateDataParser(languages=restrict_to_languages, **params) - def given_local_tz_offset(self, offset): + def given_local_tz_offset(self, offset: int) -> None: self.add_patch( patch.object( dateparser.timezone_parser, @@ -1104,15 +1158,18 @@ def given_local_tz_offset(self, offset): ) ) - def when_date_string_is_parsed(self, date_string, date_formats=None): + def when_date_string_is_parsed( + self, date_string: str, date_formats: Iterable[str] | None = None + ) -> None: try: self.result = self.parser.get_date_data(date_string, date_formats) except Exception as error: self.error = error - def when_multiple_dates_are_parsed(self, date_strings): + def when_multiple_dates_are_parsed(self, date_strings: Iterable[str]) -> None: self.multiple_results = [] for date_string in date_strings: + result: DateData | Exception try: result = self.parser.get_date_data(date_string) except Exception as error: @@ -1120,60 +1177,64 @@ def when_multiple_dates_are_parsed(self, date_strings): finally: self.multiple_results.append(result) - def when_get_date_tuple_is_called(self, date_string): - self.result = self.parser.get_date_tuple(date_string) + def when_get_date_tuple_is_called(self, date_string: str) -> None: + self.date_tuple = self.parser.get_date_tuple(date_string) - def then_date_was_parsed(self): + def then_date_was_parsed(self) -> None: self.assertIsNotNone(self.result["date_obj"]) - def then_date_was_not_parsed(self): + def then_date_was_not_parsed(self) -> None: self.assertIsNone(self.result["date_obj"]) - def then_date_locale(self): + def then_date_locale(self) -> None: self.assertIsNotNone(self.result["locale"]) - def then_date_is_n_days_ago(self, days): + def then_date_is_n_days_ago(self, days: int) -> None: today = datetime.now().date() expected_date = today - timedelta(days=days) self.assertEqual(expected_date, self.result["date_obj"].date()) - def then_all_results_were_parsed(self): + def then_all_results_were_parsed(self) -> None: self.assertNotIn(None, self.multiple_results) - def then_parsed_dates_are(self, expected_dates): + def then_parsed_dates_are(self, expected_dates: list[real_datetime.date]) -> None: self.assertEqual( expected_dates, - [result["date_obj"].date() for result in self.multiple_results], + [ + result["date_obj"].date() + for result in self.multiple_results + if isinstance(result, DateData) + ], ) - def then_detected_locale(self, locale): + def then_detected_locale(self, locale: str) -> None: self.assertEqual(locale, self.result["locale"]) - def then_period_is(self, day): + def then_period_is(self, day: str) -> None: self.assertEqual(day, self.result["period"]) - def then_parsed_datetime_is(self, expected_datetime): + def then_parsed_datetime_is(self, expected_datetime: datetime) -> None: self.assertEqual(expected_datetime, self.result["date_obj"]) - def then_parsed_date_is(self, expected_date): + def then_parsed_date_is(self, expected_date: real_datetime.date) -> None: self.assertEqual(expected_date, self.result["date_obj"].date()) - def then_parsed_date_has_timezone(self): + def then_parsed_date_has_timezone(self) -> None: self.assertTrue(hasattr(self.result["date_obj"], "tzinfo")) - def then_returned_tuple_is(self, expected_tuple): - self.assertEqual(expected_tuple, self.result) + def then_returned_tuple_is(self, expected_tuple: tuple[datetime, str, str]) -> None: + self.assertEqual(expected_tuple, self.date_tuple) - def then_previous_locales_is(self, expected_list): + def then_previous_locales_is(self, expected_list: list[str]) -> None: self.assertEqual( expected_list, [locale.shortname for locale in self.parser.previous_locales] ) class TestParserInitialization(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.parser = NotImplemented + self.parser: date.DateDataParser = NotImplemented @parameterized.expand( [ @@ -1181,8 +1242,10 @@ def setUp(self): param(languages={"languages": ["en", "he", "it"]}), ] ) - def test_error_raised_for_invalid_languages_argument(self, languages): - self.when_parser_is_initialized(languages=languages) + def test_error_raised_for_invalid_languages_argument( + self, languages: object + ) -> None: + self.when_parser_is_initialized(languages=languages) # type: ignore[arg-type] self.then_error_was_raised( TypeError, [f"languages argument must be a list ({type(languages)!r} given)"], @@ -1194,8 +1257,8 @@ def test_error_raised_for_invalid_languages_argument(self, languages): param(locales={"locales": ["zh-Hant-HK", "ha-NE", "se-SE"]}), ] ) - def test_error_raised_for_invalid_locales_argument(self, locales): - self.when_parser_is_initialized(locales=locales) + def test_error_raised_for_invalid_locales_argument(self, locales: object) -> None: + self.when_parser_is_initialized(locales=locales) # type: ignore[arg-type] self.then_error_was_raised( TypeError, [f"locales argument must be a list ({type(locales)!r} given)"] ) @@ -1206,8 +1269,8 @@ def test_error_raised_for_invalid_locales_argument(self, locales): param(region=150), ] ) - def test_error_raised_for_invalid_region_argument(self, region): - self.when_parser_is_initialized(region=region) + def test_error_raised_for_invalid_region_argument(self, region: object) -> None: + self.when_parser_is_initialized(region=region) # type: ignore[arg-type] self.then_error_was_raised( TypeError, [f"region argument must be str ({type(region)!r} given)"] ) @@ -1221,9 +1284,9 @@ def test_error_raised_for_invalid_region_argument(self, region): ] ) def test_error_raised_for_invalid_try_previous_locales_argument( - self, try_previous_locales - ): - self.when_parser_is_initialized(try_previous_locales=try_previous_locales) + self, try_previous_locales: object + ) -> None: + self.when_parser_is_initialized(try_previous_locales=try_previous_locales) # type: ignore[arg-type] self.then_error_was_raised( TypeError, [ @@ -1239,9 +1302,12 @@ def test_error_raised_for_invalid_try_previous_locales_argument( param(use_given_order=1), ] ) - def test_error_raised_for_invalid_use_given_order_argument(self, use_given_order): + def test_error_raised_for_invalid_use_given_order_argument( + self, use_given_order: object + ) -> None: self.when_parser_is_initialized( - locales=["en", "es"], use_given_order=use_given_order + locales=["en", "es"], + use_given_order=use_given_order, # type: ignore[arg-type] ) self.then_error_was_raised( TypeError, @@ -1252,24 +1318,24 @@ def test_error_raised_for_invalid_use_given_order_argument(self, use_given_order def test_error_is_raised_when_use_given_order_is_True_and_locales_and_languages_is_None( self, - ): + ) -> None: self.when_parser_is_initialized(use_given_order=True) self.then_error_was_raised( ValueError, ["locales or languages must be given if use_given_order is True"], ) - def test_no_error_for_order_with_languages_without_locales(self): + def test_no_error_for_order_with_languages_without_locales(self) -> None: self.when_parser_is_initialized(languages=["en", "fr"], use_given_order=True) def when_parser_is_initialized( self, - languages=None, - locales=None, - region=None, - try_previous_locales=True, - use_given_order=False, - ): + languages: Iterable[str] | None = None, + locales: Iterable[str] | None = None, + region: str | None = None, + try_previous_locales: bool = True, + use_given_order: bool = False, + ) -> None: try: self.parser = date.DateDataParser( languages=languages, @@ -1283,18 +1349,18 @@ def when_parser_is_initialized( class TestSanitizeDate(BaseTestCase): - def test_remove_year_in_russian(self): + def test_remove_year_in_russian(self) -> None: self.assertEqual(date.sanitize_date("2005г."), "2005") self.assertEqual(date.sanitize_date("2005г. 20:37"), "2005 20:37") self.assertEqual(date.sanitize_date("2005 г."), "2005") self.assertEqual(date.sanitize_date("2005 г. 15:24"), "2005 15:24") self.assertEqual(date.sanitize_date("Авг."), "Авг") - def test_sanitize_date_colons(self): + def test_sanitize_date_colons(self) -> None: self.assertEqual(date.sanitize_date("2019:"), "2019") self.assertEqual(date.sanitize_date("31/07/2019:"), "31/07/2019") - def test_sanitize_date_dash_look_alikes(self): + def test_sanitize_date_dash_look_alikes(self) -> None: for dash in date.DASH_LOOK_ALIKE_CHARS: self.assertEqual( date.sanitize_date(f"UTC{dash}06:00"), @@ -1303,7 +1369,7 @@ def test_sanitize_date_dash_look_alikes(self): class TestDateLocaleParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() @parameterized.expand( @@ -1323,13 +1389,13 @@ def setUp(self): ), # wrong format (list) param(date_data=DateData(date_obj=None, period="day")), # date_obj is None param( - date_data=DateData(date_obj="29/05/1994", period="day") + date_data=DateData(date_obj="29/05/1994", period="day") # type: ignore[arg-type] ), # wrong date_obj format ] ) - def test_is_valid_date_data(self, date_data): + def test_is_valid_date_data(self, date_data: object) -> None: self.given_parser( - language=["en"], + language=["en"], # type: ignore[arg-type] date_string="10 jan 2000", date_formats=None, settings=Settings(), @@ -1337,25 +1403,31 @@ def test_is_valid_date_data(self, date_data): self.when_date_object_is_validated(date_data) self.then_date_object_is_invalid() - def given_parser(self, language, date_string, date_formats, settings): + def given_parser( + self, + language: Locale, + date_string: str, + date_formats: Iterable[str] | None, + settings: Settings, + ) -> None: self.parser = date._DateLocaleParser( language, date_string, date_formats, settings ) - def when_date_object_is_validated(self, date_data): + def when_date_object_is_validated(self, date_data: object) -> None: self.is_valid_date_obj = self.parser._is_valid_date_data(date_data) - def then_date_object_is_invalid(self): + def then_date_object_is_invalid(self) -> None: self.assertFalse(self.is_valid_date_obj) class TestTimestampParser(BaseTestCase): - def given_parser(self, **params): + def given_parser(self, **params: Any) -> None: self.parser = date.DateDataParser(**params) - def given_tzstr(self, tzstr): + def given_tzstr(self, tzstr: str | None) -> None: # Save the existing value - self.old_tzstr = os.environ.get("TZ", None) + self.old_tzstr: str | None = os.environ.get("TZ", None) # Overwrite the value, or remove it if tzstr is not None: @@ -1366,7 +1438,7 @@ def given_tzstr(self, tzstr): # Call tzset tzset() - def reset_tzstr(self): + def reset_tzstr(self) -> None: # If we never set it with given_tzstr, don't bother resetting it if not hasattr(self, "old_tzstr"): return @@ -1383,7 +1455,7 @@ def reset_tzstr(self): # Restore the old timezone behavior tzset() - def test_timestamp_in_milliseconds(self): + def test_timestamp_in_milliseconds(self) -> None: self.assertEqual( date.get_date_from_timestamp("1570308760263", None), datetime.fromtimestamp(1570308760).replace(microsecond=263000), @@ -1398,9 +1470,9 @@ def test_timestamp_in_milliseconds(self): ) ) def test_timestamp_with_different_timestr( - self, timestamp, timezone, to_timezone, tzstr - ): - settings = { + self, timestamp: str, timezone: str, to_timezone: str | None, tzstr: str | None + ) -> None: + settings: dict[str, object] = { "RETURN_AS_TIMEZONE_AWARE": True, "TIMEZONE": timezone, } @@ -1420,7 +1492,7 @@ def test_timestamp_with_different_timestr( self.reset_tzstr() - def test_timestamp_in_microseconds(self): + def test_timestamp_in_microseconds(self) -> None: self.assertEqual( date.get_date_from_timestamp("1570308760263111", None), datetime.fromtimestamp(1570308760).replace(microsecond=263111), @@ -1442,7 +1514,9 @@ def test_timestamp_in_microseconds(self): ), ] ) - def test_timestamp_with_negative(self, input_timestamp, negative, result): + def test_timestamp_with_negative( + self, input_timestamp: str, negative: bool, result: datetime | None + ) -> None: self.assertEqual( date.get_date_from_timestamp(input_timestamp, None, negative=negative), result, @@ -1462,7 +1536,7 @@ def test_timestamp_with_negative(self, input_timestamp, negative, result): param(date_string="1570308760263111222"), ] ) - def test_timestamp_with_wrong_length(self, date_string): + def test_timestamp_with_wrong_length(self, date_string: str) -> None: self.assertEqual(date.get_date_from_timestamp(date_string, None), None) diff --git a/tests/test_date_data.py b/tests/test_date_data.py index 8868f6fb3..57103fbd0 100644 --- a/tests/test_date_data.py +++ b/tests/test_date_data.py @@ -6,19 +6,19 @@ class TestDateData: - def test_get_item_like_dict(self): + def test_get_item_like_dict(self) -> None: date = datetime(year=5432, month=3, day=1) dd = DateData(date_obj=date, period="day", locale="de") assert dd["date_obj"] == date assert dd["period"] == "day" assert dd["locale"] == "de" - def test_get_item_like_dict_keyerror(self): + def test_get_item_like_dict_keyerror(self) -> None: dd = DateData(date_obj=None, period="day", locale="de") with pytest.raises(KeyError, match="date"): dd["date"] - def test_set_item_like_dict(self): + def test_set_item_like_dict(self) -> None: dd = DateData() assert dd.date_obj is None @@ -26,7 +26,7 @@ def test_set_item_like_dict(self): dd["date_obj"] = date assert dd.date_obj == date - def test_set_item_like_dict_keyerror(self): + def test_set_item_like_dict_keyerror(self) -> None: dd = DateData() with pytest.raises(KeyError, match="date"): dd["date"] = datetime(year=5432, month=3, day=1) @@ -76,6 +76,8 @@ def test_set_item_like_dict_keyerror(self): (None, "year", "fr", "DateData(date_obj=None, period='year', locale='fr')"), ], ) - def test_repr(self, date, period, locale, expected): + def test_repr( + self, date: datetime | None, period: str, locale: str | None, expected: str + ) -> None: dd = DateData(date_obj=date, period=period, locale=locale) assert dd.__repr__() == expected diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 3c947d096..07ed0dc7f 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1,14 +1,16 @@ import unittest -from datetime import datetime, timedelta, timezone +from collections.abc import Callable +from datetime import datetime, timedelta, timezone, tzinfo from functools import wraps +from typing import Any from unittest.mock import Mock, patch from parameterized import param, parameterized import dateparser.timezone_parser from dateparser import parse -from dateparser.date import DateDataParser, date_parser -from dateparser.date_parser import DateParser +from dateparser.date import DateData, DateDataParser +from dateparser.date_parser import DateParser, date_parser from dateparser.parser import _parse_absolute from dateparser.timezone_parser import StaticTzInfo from dateparser.utils import normalize_unicode @@ -16,12 +18,12 @@ class TestDateParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.parser = NotImplemented - self.result = NotImplemented - self.date_parser = NotImplemented - self.date_result = NotImplemented + self.parser: DateDataParser = NotImplemented + self.result: DateData = NotImplemented + self.date_parser: Mock = NotImplemented + self.date_result: tuple[datetime, str | None] = NotImplemented @parameterized.expand( [ @@ -234,7 +236,7 @@ def setUp(self): param("27. siječnja 1994. u ponoć", datetime(1994, 1, 27, 0, 0)), ] ) - def test_dates_parsing(self, date_string, expected): + def test_dates_parsing(self, date_string: str, expected: datetime) -> None: self.given_parser( settings={"NORMALIZE": False, "RELATIVE_BASE": datetime(2012, 11, 13)} ) @@ -248,7 +250,9 @@ def test_dates_parsing(self, date_string, expected): param("hr", "02/10/2016 u 17:20", datetime(2016, 10, 2, 17, 20)), ] ) - def test_dates_parsing_with_language(self, language, date_string, expected): + def test_dates_parsing_with_language( + self, language: str, date_string: str, expected: datetime + ) -> None: self.given_parser( languages=[language], settings={ @@ -266,7 +270,9 @@ def test_dates_parsing_with_language(self, language, date_string, expected): param("2016020417:10", datetime(2016, 2, 4, 17, 10)), ] ) - def test_dates_parsing_no_spaces(self, date_string, expected): + def test_dates_parsing_no_spaces( + self, date_string: str, expected: datetime + ) -> None: self.given_parser( settings={ "NORMALIZE": False, @@ -279,7 +285,7 @@ def test_dates_parsing_no_spaces(self, date_string, expected): self.then_period_is("day") self.then_date_obj_exactly_is(expected) - def test_stringified_datetime_should_parse_fine(self): + def test_stringified_datetime_should_parse_fine(self) -> None: expected_date = datetime(2012, 11, 13, 10, 15, 5, 330256) self.given_parser(settings={"RELATIVE_BASE": expected_date}) date_string = str(self.parser.get_date_data("today")["date_obj"]) @@ -446,7 +452,9 @@ def test_stringified_datetime_should_parse_fine(self): param("सन् 1989 11 फ़रवरी 09:43", datetime(1989, 2, 11, 9, 43)), ] ) - def test_dates_parsing_with_normalization(self, date_string, expected): + def test_dates_parsing_with_normalization( + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={"NORMALIZE": True, "RELATIVE_BASE": datetime(2012, 11, 13)} @@ -464,7 +472,9 @@ def test_dates_parsing_with_normalization(self, date_string, expected): param("08/17/14 17:00 (PDT)", datetime(2014, 8, 18, 0, 0)), ] ) - def test_parsing_with_time_zones_and_converting_to_UTC(self, date_string, expected): + def test_parsing_with_time_zones_and_converting_to_UTC( + self, date_string: str, expected: datetime + ) -> None: self.given_parser(settings={"TO_TIMEZONE": "UTC"}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -501,8 +511,8 @@ def test_parsing_with_time_zones_and_converting_to_UTC(self, date_string, expect ] ) def test_dateparser_should_return_tzaware_date_when_tz_info_present_in_date_string( - self, date_string, timezone_str, expected - ): + self, date_string: str, timezone_str: str, expected: datetime + ) -> None: self.given_parser() self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -528,8 +538,8 @@ def test_dateparser_should_return_tzaware_date_when_tz_info_present_in_date_stri ] ) def test_dateparser_should_return_date_in_setting_timezone_if_timezone_info_present_in_datestring_and_in_settings( - self, date_string, setting_timezone, expected - ): + self, date_string: str, setting_timezone: str, expected: datetime + ) -> None: self.given_parser(settings={"TIMEZONE": setting_timezone}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -565,7 +575,9 @@ def test_dateparser_should_return_date_in_setting_timezone_if_timezone_info_pres param("2019-09-28WIB19:17:34+07:00", datetime(2019, 9, 28, 12, 17, 34)), ] ) - def test_parsing_with_utc_offsets(self, date_string, expected): + def test_parsing_with_utc_offsets( + self, date_string: str, expected: datetime + ) -> None: self.given_parser(settings={"TO_TIMEZONE": "utc"}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -573,7 +585,7 @@ def test_parsing_with_utc_offsets(self, date_string, expected): self.then_timezone_parsed_is("UTC") self.then_date_obj_exactly_is(expected) - def test_empty_dates_string_is_not_parsed(self): + def test_empty_dates_string_is_not_parsed(self) -> None: self.when_date_is_parsed_by_date_parser("") self.then_error_was_raised(ValueError, ["Empty string"]) @@ -593,7 +605,7 @@ def test_empty_dates_string_is_not_parsed(self): param("12/09/18567", "Unable to parse: 18567"), ] ) - def test_dates_not_parsed(self, date_string, message): + def test_dates_not_parsed(self, date_string: str, message: str) -> None: self.when_date_is_parsed_by_date_parser(date_string) self.then_error_was_raised(ValueError, message) @@ -613,7 +625,7 @@ def test_dates_not_parsed(self, date_string, message): param("3/3/94", datetime(1994, 3, 3)), ] ) - def test_preferably_past_dates(self, date_string, expected): + def test_preferably_past_dates(self, date_string: str, expected: datetime) -> None: self.given_parser( settings={ "PREFER_DATES_FROM": "past", @@ -638,7 +650,9 @@ def test_preferably_past_dates(self, date_string, expected): param("3/3/94", datetime(2094, 3, 3)), ] ) - def test_preferably_future_dates(self, date_string, expected): + def test_preferably_future_dates( + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={ @@ -656,8 +670,8 @@ def test_preferably_future_dates(self, date_string, expected): ] ) def test_preferably_future_dates_relative_last_week_of_month( - self, date_string, expected - ): + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={ @@ -680,7 +694,9 @@ def test_preferably_future_dates_relative_last_week_of_month( param("14:05", datetime(2015, 2, 15, 14, 5)), ] ) - def test_dates_without_preference(self, date_string, expected): + def test_dates_without_preference( + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={ @@ -700,8 +716,8 @@ def test_dates_without_preference(self, date_string, expected): ] ) def test_preferably_past_dates_leap_year( - self, date_string, relative_base, expected - ): + self, date_string: str, relative_base: datetime, expected: datetime + ) -> None: self.given_parser( settings={"PREFER_DATES_FROM": "past", "RELATIVE_BASE": relative_base} ) @@ -717,8 +733,8 @@ def test_preferably_past_dates_leap_year( ] ) def test_preferably_future_dates_leap_year( - self, date_string, relative_base, expected - ): + self, date_string: str, relative_base: datetime, expected: datetime + ) -> None: self.given_parser( settings={"PREFER_DATES_FROM": "future", "RELATIVE_BASE": relative_base} ) @@ -735,8 +751,8 @@ def test_preferably_future_dates_leap_year( ] ) def test_dates_without_preference_leap_year( - self, date_string, relative_base, expected - ): + self, date_string: str, relative_base: datetime, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={ @@ -783,8 +799,11 @@ def test_dates_without_preference_leap_year( ] ) def test_dates_with_day_missing_preferring_current_day_of_month( - self, date_string, today=None, expected=None - ): + self, + date_string: str, + today: datetime | None = None, + expected: datetime | None = None, + ) -> None: self.given_parser( settings={"PREFER_DAY_OF_MONTH": "current", "RELATIVE_BASE": today} ) @@ -827,8 +846,11 @@ def test_dates_with_day_missing_preferring_current_day_of_month( ] ) def test_dates_with_day_missing_preferring_last_day_of_month( - self, date_string, today=None, expected=None - ): + self, + date_string: str, + today: datetime | None = None, + expected: datetime | None = None, + ) -> None: self.given_parser( settings={"PREFER_DAY_OF_MONTH": "last", "RELATIVE_BASE": today} ) @@ -865,8 +887,11 @@ def test_dates_with_day_missing_preferring_last_day_of_month( ] ) def test_dates_with_day_missing_preferring_first_day_of_month( - self, date_string, today=None, expected=None - ): + self, + date_string: str, + today: datetime | None = None, + expected: datetime | None = None, + ) -> None: self.given_parser( settings={"PREFER_DAY_OF_MONTH": "first", "RELATIVE_BASE": today} ) @@ -882,8 +907,8 @@ def test_dates_with_day_missing_preferring_first_day_of_month( ] ) def test_that_day_preference_does_not_affect_dates_with_explicit_day( - self, prefer_day_of_month=None - ): + self, prefer_day_of_month: str | None = None + ) -> None: self.given_parser( settings={ "PREFER_DAY_OF_MONTH": prefer_day_of_month, @@ -894,7 +919,7 @@ def test_that_day_preference_does_not_affect_dates_with_explicit_day( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(datetime(2012, 4, 24)) - def test_date_is_parsed_when_skip_tokens_are_supplied(self): + def test_date_is_parsed_when_skip_tokens_are_supplied(self) -> None: self.given_parser( settings={"SKIP_TOKENS": ["de"], "RELATIVE_BASE": datetime(2015, 2, 12)} ) @@ -912,8 +937,8 @@ def test_date_is_parsed_when_skip_tokens_are_supplied(self): ] ) def test_error_should_be_raised_for_invalid_dates_with_too_large_day_number( - self, date_string, message - ): + self, date_string: str, message: str + ) -> None: self.when_date_is_parsed_by_date_parser(date_string) self.then_error_was_raised( ValueError, ["day is out of range for month", "must be in range", message] @@ -934,8 +959,8 @@ def test_error_should_be_raised_for_invalid_dates_with_too_large_day_number( ] ) def test_iso_datestamp_format_should_always_parse( - self, date_string, languages, expected - ): + self, date_string: str, languages: list[str], expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( languages=languages, settings={"PREFER_LOCALE_DATE_ORDER": False} @@ -958,8 +983,8 @@ def test_iso_datestamp_format_should_always_parse( ] ) def test_iso_datestamp_format_should_parse_with_locale_date_order( - self, date_string, languages, expected - ): + self, date_string: str, languages: list[str], expected: datetime + ) -> None: # Regression test for #360: dates starting with a four-digit year # (e.g. ISO 8601 dates) must parse even when the locale date order # is not year-first (Italian and French use DMY), without needing @@ -980,8 +1005,8 @@ def test_iso_datestamp_format_should_parse_with_locale_date_order( ] ) def test_year_first_date_with_explicit_date_order( - self, date_string, date_order, expected - ): + self, date_string: str, date_order: str, expected: datetime + ) -> None: self.given_parser(languages=["en"], settings={"DATE_ORDER": date_order}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -1008,7 +1033,7 @@ def test_year_first_date_with_explicit_date_order( ), ] ) - def test_parse_timestamp(self, date_string, expected): + def test_parse_timestamp(self, date_string: str, expected: datetime) -> None: self.given_local_tz_offset(0) self.given_parser(settings={"TO_TIMEZONE": "UTC"}) self.when_date_is_parsed(date_string) @@ -1022,7 +1047,9 @@ def test_parse_timestamp(self, date_string, expected): param("-1015673450000001", expected=datetime(1937, 10, 25, 12, 29, 10, 1)), ] ) - def test_parse_negative_timestamp(self, date_string, expected): + def test_parse_negative_timestamp( + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={"TO_TIMEZONE": "UTC", "PARSERS": ["negative-timestamp"]} @@ -1052,7 +1079,9 @@ def test_parse_negative_timestamp(self, date_string, expected): ), ] ) - def test_parse_timestamp_with_time_as_period(self, date_string, expected): + def test_parse_timestamp_with_time_as_period( + self, date_string: str, expected: datetime + ) -> None: self.given_local_tz_offset(0) self.given_parser( settings={"TO_TIMEZONE": "UTC", "RETURN_TIME_AS_PERIOD": True} @@ -1093,7 +1122,12 @@ def test_parse_timestamp_with_time_as_period(self, date_string, expected): param("2001год", expected=datetime(2001, 2, 15), period="year"), ] ) - def test_extracted_period(self, date_string, expected=None, period=None): + def test_extracted_period( + self, + date_string: str, + expected: datetime | None = None, + period: str | None = None, + ) -> None: self.given_local_tz_offset(0) self.given_parser(settings={"RELATIVE_BASE": datetime(2015, 2, 15, 15, 30)}) self.when_date_is_parsed(date_string) @@ -1112,8 +1146,11 @@ def test_extracted_period(self, date_string, expected=None, period=None): ] ) def test_period_is_time_if_return_time_as_period_setting_applied_and_time_component_present( - self, date_string, expected=None, period=None - ): + self, + date_string: str, + expected: datetime | None = None, + period: str | None = None, + ) -> None: self.given_parser(settings={"RETURN_TIME_AS_PERIOD": True}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -1130,8 +1167,11 @@ def test_period_is_time_if_return_time_as_period_setting_applied_and_time_compon ] ) def test_period_is_time_if_return_time_as_period_and_relative_base_settings_applied_and_time_component_present( - self, date_string, expected=None, period=None - ): + self, + date_string: str, + expected: datetime | None = None, + period: str | None = None, + ) -> None: self.given_parser( settings={ "RETURN_TIME_AS_PERIOD": True, @@ -1152,8 +1192,11 @@ def test_period_is_time_if_return_time_as_period_and_relative_base_settings_appl ] ) def test_period_is_day_if_return_time_as_period_setting_applied_and_time_component_is_not_present( - self, date_string, expected=None, period=None - ): + self, + date_string: str, + expected: datetime | None = None, + period: str | None = None, + ) -> None: self.given_parser(settings={"RETURN_TIME_AS_PERIOD": True}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -1167,8 +1210,11 @@ def test_period_is_day_if_return_time_as_period_setting_applied_and_time_compone ] ) def test_period_is_day_if_return_time_as_period_setting_not_applied( - self, date_string, expected=None, period=None - ): + self, + date_string: str, + expected: datetime | None = None, + period: str | None = None, + ) -> None: self.given_parser( settings={ "RETURN_TIME_AS_PERIOD": False, @@ -1223,18 +1269,23 @@ def test_period_is_day_if_return_time_as_period_setting_not_applied( param("12 13 December", expected=datetime(2013, 12, 12), order="DMY"), ] ) - def test_order(self, date_string, expected=None, order=None): + def test_order( + self, + date_string: str, + expected: datetime | None = None, + order: str | None = None, + ) -> None: self.given_parser(settings={"DATE_ORDER": order}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) - def test_locale_order_is_not_swapped(self): + def test_locale_order_is_not_swapped(self) -> None: self.given_parser(languages=["fr"]) self.when_date_is_parsed("01/13/2021") self.then_date_obj_exactly_is(None) - def test_order_is_not_swapped_with_a_month_name(self): + def test_order_is_not_swapped_with_a_month_name(self) -> None: self.given_parser(languages=["en"], settings={"DATE_ORDER": "DMY"}) self.when_date_is_parsed("12/24, Monday 15 March 2021") self.then_date_obj_exactly_is(None) @@ -1280,8 +1331,12 @@ def test_order_is_not_swapped_with_a_month_name(self): ] ) def test_two_digit_day_is_not_confused_with_year( - self, date_string, expected=None, languages=None, settings=None - ): + self, + date_string: str, + expected: datetime | None = None, + languages: list[str] | None = None, + settings: dict[str, Any] | None = None, + ) -> None: self.given_parser( languages=languages, settings={"RELATIVE_BASE": datetime(2019, 6, 27), **(settings or {})}, @@ -1297,7 +1352,12 @@ def test_two_digit_day_is_not_confused_with_year( param("201108", expected=datetime(2008, 11, 20, 0, 0), order="DMY"), ] ) - def test_order_no_spaces(self, date_string, expected=None, order=None): + def test_order_no_spaces( + self, + date_string: str, + expected: datetime | None = None, + order: str | None = None, + ) -> None: self.given_parser(settings={"DATE_ORDER": order, "PARSERS": ["no-spaces-time"]}) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -1332,8 +1392,12 @@ def test_order_no_spaces(self, date_string, expected=None, order=None): ] ) def test_if_settings_provided_date_order_is_retained( - self, date_string, expected=None, languages=None, settings=None - ): + self, + date_string: str, + expected: datetime | None = None, + languages: list[str] | None = None, + settings: dict[str, Any] | None = None, + ) -> None: self.given_parser(languages=languages, settings=settings) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() @@ -1350,8 +1414,8 @@ def test_if_settings_provided_date_order_is_retained( ] ) def test_parsing_strings_containing_only_separator_tokens( - self, date_string, expected - ): + self, date_string: str, expected: None + ) -> None: self.given_parser() self.when_date_is_parsed(date_string) self.then_period_is("day") @@ -1402,8 +1466,8 @@ def test_parsing_strings_containing_only_separator_tokens( ] ) def test_prefer_dates_from_with_timezone( - self, date_string, expected, test_settings - ): + self, date_string: str, expected: datetime, test_settings: dict[str, Any] + ) -> None: self.given_parser( settings={ "TO_TIMEZONE": "etc/utc", @@ -1463,8 +1527,13 @@ def test_prefer_dates_from_with_timezone( ] ) def test_dates_with_no_day_or_month( - self, date_string, prefer_day, prefer_month, today=None, expected=None - ): + self, + date_string: str, + prefer_day: str, + prefer_month: str, + today: datetime | None = None, + expected: datetime | None = None, + ) -> None: self.given_parser( settings={ "PREFER_DAY_OF_MONTH": prefer_day, @@ -1476,15 +1545,17 @@ def test_dates_with_no_day_or_month( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) - def test_dates_with_no_day_or_month_use_same_current_date_for_month_and_day(self): + def test_dates_with_no_day_or_month_use_same_current_date_for_month_and_day( + self, + ) -> None: class ParserDateTime(datetime): @classmethod - def now(cls, tz=None): + def now(cls, tz: tzinfo | None = None) -> datetime: # type: ignore[override] return datetime(2026, 5, 31, 12, 0, tzinfo=tz) class UtilsDateTime(datetime): @classmethod - def now(cls, tz=None): + def now(cls, tz: tzinfo | None = None) -> datetime: # type: ignore[override] return datetime(2026, 6, 1, 12, 0, tzinfo=tz) with ( @@ -1548,8 +1619,11 @@ def now(cls, tz=None): ] ) def test_relative_date_with_time_offset( - self, date_string, offset_calculator, description - ): + self, + date_string: str, + offset_calculator: Callable[[datetime], datetime], + description: str, + ) -> None: """Ensure +/- signs in time offsets are parsed correctly.""" base_date = datetime(2026, 1, 19, 12, 0, 0) expected = offset_calculator(base_date) @@ -1563,13 +1637,14 @@ def test_relative_date_with_time_offset( ) self.assertIsNotNone(result, f"Failed to parse: {description}") + assert result is not None self.assertEqual( expected, result, f"{description}: Expected {expected}, got {result}", ) - def given_local_tz_offset(self, offset): + def given_local_tz_offset(self, offset: int) -> None: self.add_patch( patch.object( dateparser.timezone_parser, @@ -1578,7 +1653,7 @@ def given_local_tz_offset(self, offset): ) ) - def test_yesterday_plus_and_minus_expected_values(self): + def test_yesterday_plus_and_minus_expected_values(self) -> None: """Verify correct time offset calculations for yesterday.""" # Base: 2026-01-08 21:38:10 base_date = datetime(2026, 1, 8, 21, 38, 10) @@ -1667,14 +1742,21 @@ def test_yesterday_plus_and_minus_expected_values(self): ] ) def test_use_given_language_order_setting( - self, date_string, expected=None, languages=None, locales=None, settings=None - ): + self, + date_string: str, + expected: datetime | None = None, + languages: list[str] | None = None, + locales: list[str] | None = None, + settings: dict[str, Any] | None = None, + ) -> None: self.given_parser(languages=languages, locales=locales, settings=settings) self.when_date_is_parsed(date_string) self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) - def test_use_given_order_parameter_still_preserves_order_without_setting(self): + def test_use_given_order_parameter_still_preserves_order_without_setting( + self, + ) -> None: # The pre-existing ``use_given_order`` constructor argument must keep working # on its own (the new setting is OR-ed with it, not a replacement). self.given_parser(languages=["es", "en"], use_given_order=True) @@ -1682,7 +1764,7 @@ def test_use_given_order_parameter_still_preserves_order_without_setting(self): self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(datetime(2020, 12, 11, 0, 0)) - def test_use_given_language_order_setting_fixes_top_level_parse(self): + def test_use_given_language_order_setting_fixes_top_level_parse(self) -> None: # Regression test for https://github.com/scrapinghub/dateparser/issues/770 # The top-level ``parse`` must honour the given language order through the # ``USE_GIVEN_LANGUAGE_ORDER`` setting. @@ -1703,10 +1785,12 @@ def test_use_given_language_order_setting_fixes_top_level_parse(self): ), ) - def given_parser(self, *args, **kwds): - def collecting_get_date_data(parse): + def given_parser(self, *args: Any, **kwds: Any) -> None: + def collecting_get_date_data( + parse: Callable[..., tuple[datetime, str | None]], + ) -> Callable[..., tuple[datetime, str | None]]: @wraps(parse) - def wrapped(*args, **kwargs): + def wrapped(*args: Any, **kwargs: Any) -> tuple[datetime, str | None]: self.date_result = parse(*args, **kwargs) return self.date_result @@ -1722,26 +1806,26 @@ def wrapped(*args, **kwargs): self.add_patch(patch("dateparser.date.date_parser", new=self.date_parser)) self.parser = DateDataParser(*args, **kwds) - def when_date_is_parsed(self, date_string): + def when_date_is_parsed(self, date_string: str) -> None: self.result = self.parser.get_date_data(date_string) - def when_date_is_parsed_by_date_parser(self, date_string): + def when_date_is_parsed_by_date_parser(self, date_string: str) -> None: try: - self.result = DateParser().parse(date_string, parse_method=_parse_absolute) + DateParser().parse(date_string, parse_method=_parse_absolute) except Exception as error: self.error = error - def then_period_is(self, period): + def then_period_is(self, period: str | None) -> None: self.assertEqual(period, self.result["period"]) - def then_date_obj_exactly_is(self, expected): + def then_date_obj_exactly_is(self, expected: datetime | None) -> None: self.assertEqual(expected, self.result["date_obj"]) - def then_date_was_parsed_by_date_parser(self): + def then_date_was_parsed_by_date_parser(self) -> None: self.assertNotEqual(NotImplemented, self.date_result, "Date was not parsed") self.assertEqual(self.result["date_obj"], self.date_result[0]) - def then_timezone_parsed_is(self, tzstr): + def then_timezone_parsed_is(self, tzstr: str) -> None: self.assertTrue(tzstr in repr(self.result["date_obj"].tzinfo)) self.result["date_obj"] = self.result["date_obj"].replace(tzinfo=None) @@ -1768,7 +1852,9 @@ def then_timezone_parsed_is(self, tzstr): param("two day later", timedelta(days=2), "two day later (without plural)"), ] ) - def test_word_numbers_with_later(self, date_string, expected_delta, description): + def test_word_numbers_with_later( + self, date_string: str, expected_delta: timedelta, description: str + ) -> None: """Test that word numbers (one, two, three, etc.) work with 'later' pattern.""" base_date = datetime(2025, 6, 15, 12, 0, 0) expected = base_date + expected_delta @@ -1782,6 +1868,7 @@ def test_word_numbers_with_later(self, date_string, expected_delta, description) ) self.assertIsNotNone(result, f"Failed to parse: {description}") + assert result is not None if "approx" in description: # For approximate cases, ensure the result is after the base date # and not later than the expected upper bound. @@ -1811,7 +1898,9 @@ def test_word_numbers_with_later(self, date_string, expected_delta, description) param("5 hours from now", timedelta(hours=5), "5 hours from now"), ] ) - def test_word_numbers_advanced(self, date_string, expected_delta, description): + def test_word_numbers_advanced( + self, date_string: str, expected_delta: timedelta, description: str + ) -> None: """Test number parsing with word numbers (1-12) in 'from now' phrases.""" base_date = datetime(2025, 6, 15, 12, 0, 0) expected = base_date + expected_delta @@ -1825,6 +1914,7 @@ def test_word_numbers_advanced(self, date_string, expected_delta, description): ) self.assertIsNotNone(result, f"Failed to parse: {description}") + assert result is not None self.assertEqual( expected, result, @@ -1877,12 +1967,12 @@ def test_word_numbers_advanced(self, date_string, expected_delta, description): ) def test_prefer_dates_from_with_date_formats( self, - date_string, - date_format, - prefer_from, - expected_year, - description, - ): + date_string: str, + date_format: str, + prefer_from: str, + expected_year: int, + description: str, + ) -> None: """Test that PREFER_DATES_FROM setting works with date_formats parameter (Issue #445).""" result = parse( date_string, @@ -1894,13 +1984,14 @@ def test_prefer_dates_from_with_date_formats( ) self.assertIsNotNone(result, f"Failed to parse: {description}") + assert result is not None self.assertEqual( expected_year, result.year, f"{description}: Expected year {expected_year}, got {result.year}", ) - def test_prefer_dates_from_with_date_formats_and_relative_base(self): + def test_prefer_dates_from_with_date_formats_and_relative_base(self) -> None: """Test that PREFER_DATES_FROM respects RELATIVE_BASE with date_formats.""" # Use a relative base in the past (e.g., 1980-01-01) # When parsing '1/15/64' with RELATIVE_BASE='1980-01-01' and PREFER_DATES_FROM='past', @@ -1916,6 +2007,7 @@ def test_prefer_dates_from_with_date_formats_and_relative_base(self): ) self.assertIsNotNone(result) + assert result is not None self.assertEqual( 1964, result.year, @@ -1936,13 +2028,14 @@ def test_prefer_dates_from_with_date_formats_and_relative_base(self): ) self.assertIsNotNone(result) + assert result is not None self.assertEqual( 2064, result.year, f"RELATIVE_BASE not respected: Expected 2064, got {result.year}", ) - def test_prefer_dates_from_with_date_formats_tz_aware_relative_base(self): + def test_prefer_dates_from_with_date_formats_tz_aware_relative_base(self) -> None: """Test that a tz-aware RELATIVE_BASE does not crash (Bug #1 fix).""" result = parse( "1/15/64", @@ -1953,9 +2046,10 @@ def test_prefer_dates_from_with_date_formats_tz_aware_relative_base(self): }, ) self.assertIsNotNone(result) + assert result is not None self.assertEqual(1964, result.year) - def test_prefer_dates_from_with_date_formats_feb29_non_leap(self): + def test_prefer_dates_from_with_date_formats_feb29_non_leap(self) -> None: """Test that Feb 29 shifted to a non-leap year finds the next valid leap year (Bug #2 fix).""" # 2/29/00 parses as 2000-02-29; shifting +100 → 2100 which is not a leap year. # _apply_century_preference finds the next valid leap year: 2104. @@ -1968,6 +2062,7 @@ def test_prefer_dates_from_with_date_formats_feb29_non_leap(self): }, ) self.assertIsNotNone(result) + assert result is not None self.assertEqual(2104, result.year) self.assertEqual(2, result.month) self.assertEqual(29, result.day) @@ -1980,7 +2075,7 @@ def test_prefer_dates_from_with_date_formats_feb29_non_leap(self): param(date_string="2000366", expected=datetime(2000, 12, 31)), ] ) - def test_day_of_year_is_parsed(self, date_string, expected): + def test_day_of_year_is_parsed(self, date_string: str, expected: datetime) -> None: """Test that %j maps the day of year onto the right date (Issue #271).""" self.assertEqual(expected, parse(date_string, date_formats=["%Y%j"])) @@ -1990,7 +2085,7 @@ def test_day_of_year_is_parsed(self, date_string, expected): param(date_string="1999777"), ] ) - def test_out_of_range_day_of_year_is_not_parsed(self, date_string): + def test_out_of_range_day_of_year_is_not_parsed(self, date_string: str) -> None: """Test that an invalid %j value is not read as another date (Issue #271).""" self.assertIsNone(parse(date_string, date_formats=["%Y%j"])) @@ -2005,14 +2100,14 @@ def test_out_of_range_day_of_year_is_not_parsed(self, date_string): ] ) def test_weekday_month_abbreviation_conflict_is_read_as_weekday( - self, date_string, date_formats - ): + self, date_string: str, date_formats: list[str] | None + ) -> None: """Italian "mar" abbreviates both "martedì" (Tue) and "marzo" (Mar). When another, unambiguous month ("giu") is present in the same string, "mar" must be read as the weekday, comma or not, or the string fails to parse entirely (Issue #1061).""" result = parse(date_string, date_formats=date_formats, languages=["it"]) - self.assertIsNotNone(result) + assert result is not None self.assertEqual(datetime(2022, 6, 7, 8, 56, 47), result.replace(tzinfo=None)) @parameterized.expand( @@ -2034,12 +2129,16 @@ def test_weekday_month_abbreviation_conflict_is_read_as_weekday( ] ) def test_weekday_month_abbreviation_conflict_is_read_as_month( - self, date_string, expected_year, expected_month, expected_day=None - ): + self, + date_string: str, + expected_year: int, + expected_month: int, + expected_day: int | None = None, + ) -> None: """Without another, unambiguous month elsewhere in the string, the ambiguous Italian "mar" abbreviation must still be read as the month.""" result = parse(date_string, languages=["it"]) - self.assertIsNotNone(result) + assert result is not None self.assertEqual(expected_year, result.year) self.assertEqual(expected_month, result.month) if expected_day is not None: diff --git a/tests/test_dateparser_data_integrity.py b/tests/test_dateparser_data_integrity.py index f81a300a7..62a2cd01c 100644 --- a/tests/test_dateparser_data_integrity.py +++ b/tests/test_dateparser_data_integrity.py @@ -7,7 +7,7 @@ from dateparser_scripts.write_complete_data import write_complete_data -def test_dateparser_data_integrity(): +def test_dateparser_data_integrity() -> None: files = write_complete_data(in_memory=True) for filename in files: diff --git a/tests/test_fasttext.py b/tests/test_fasttext.py new file mode 100644 index 000000000..0b088074c --- /dev/null +++ b/tests/test_fasttext.py @@ -0,0 +1,8 @@ +import pytest + + +def test_fasttext_is_deprecated() -> None: + with pytest.warns(DeprecationWarning, match="fastText support is deprecated"): + from dateparser.custom_language_detection import fasttext # noqa: PLC0415 + with pytest.raises(ImportError): + fasttext.detect_languages("14 June 2020", 0.0) diff --git a/tests/test_french_republican.py b/tests/test_french_republican.py index bcf6af774..94e08b96b 100644 --- a/tests/test_french_republican.py +++ b/tests/test_french_republican.py @@ -23,8 +23,9 @@ class TestFrenchRepublicanCalendar(BaseTestCase): param("1 Floréal an. 79", datetime(1871, 4, 21)), ] ) - def test_dates(self, date_string, expected): + def test_dates(self, date_string: str, expected: datetime) -> None: date_data = FrenchRepublicanCalendar(date_string).get_date() + assert date_data is not None self.assertEqual(date_data.date_obj, expected) self.assertEqual(date_data.period, "day") @@ -36,7 +37,9 @@ def test_dates(self, date_string, expected): param("Sans-culottides an I", datetime(1793, 9, 17), "month"), ] ) - def test_prefer_first(self, date_string, expected, period): + def test_prefer_first( + self, date_string: str, expected: datetime, period: str + ) -> None: first = settings.replace( PREFER_DAY_OF_MONTH="first", PREFER_MONTH_OF_YEAR="first" ) @@ -44,14 +47,14 @@ def test_prefer_first(self, date_string, expected, period): _french_republican_parser.parse(date_string, first), (expected, period) ) - def test_prefer_current(self): + def test_prefer_current(self) -> None: current = settings.replace(RELATIVE_BASE=datetime(2026, 9, 29)) self.assertEqual( _french_republican_parser.parse("an VIII", current), (datetime(1799, 9, 29), "year"), ) - def test_prefer_last(self): + def test_prefer_last(self) -> None: last = settings.replace(PREFER_DAY_OF_MONTH="last", PREFER_MONTH_OF_YEAR="last") self.assertEqual( _french_republican_parser.parse("an III", last), @@ -69,5 +72,5 @@ def test_prefer_last(self): param("18 brumaire 1799"), ] ) - def test_invalid(self, date_string): + def test_invalid(self, date_string: str) -> None: self.assertIsNone(FrenchRepublicanCalendar(date_string).get_date()) diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index df78b4c35..9bf93878b 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -1,39 +1,40 @@ import unittest -from datetime import date, datetime, time, timedelta +from collections.abc import Callable +from datetime import date, datetime, time, timedelta, tzinfo from functools import wraps from time import monotonic +from typing import Any from unittest.mock import Mock, patch from zoneinfo import ZoneInfo -import pytz from dateutil.relativedelta import relativedelta from parameterized import param, parameterized import dateparser import dateparser.data.date_translation_data.en as en_data -from dateparser.conf import settings -from dateparser.date import DateDataParser, freshness_date_parser -from dateparser.freshness_date_parser import PATTERN +from dateparser.conf import Settings, settings +from dateparser.date import DateData, DateDataParser +from dateparser.freshness_date_parser import PATTERN, freshness_date_parser from dateparser.languages.dictionary import Dictionary from dateparser.utils import normalize_unicode from tests import BaseTestCase class TestFreshnessDateDataParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() self.now = datetime(2014, 9, 1, 10, 30) - self.date_string = NotImplemented - self.parser = NotImplemented - self.result = NotImplemented - self.freshness_parser = NotImplemented - self.freshness_result = NotImplemented + self.date_string: str = NotImplemented + self.parser: DateDataParser = NotImplemented + self.result: DateData = NotImplemented + self.freshness_parser: Mock = NotImplemented + self.freshness_result: DateData = NotImplemented self.date = NotImplemented self.time = NotImplemented settings.TIMEZONE = "utc" - def now_with_timezone(self, tz): + def now_with_timezone(self, tz: tzinfo | None) -> datetime: now = self.now return datetime(now.year, now.month, now.day, now.hour, now.minute, tzinfo=tz) @@ -44,7 +45,9 @@ def now_with_timezone(self, tz): param("yesterday at 11:30", ago={"hours": 23}, period="time"), ] ) - def test_relative_past_dates_with_time_as_period(self, date_string, ago, period): + def test_relative_past_dates_with_time_as_period( + self, date_string: str, ago: dict[str, Any], period: str + ) -> None: self.given_parser(settings={"NORMALIZE": False, "RETURN_TIME_AS_PERIOD": True}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -920,7 +923,9 @@ def test_relative_past_dates_with_time_as_period(self, date_string, ago, period) param("21 izinsuku ezedlule", ago={"days": 21}, period="day"), ] ) - def test_relative_past_dates(self, date_string, ago, period): + def test_relative_past_dates( + self, date_string: str, ago: dict[str, Any], period: str + ) -> None: self.given_parser(settings={"NORMALIZE": False}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -1731,7 +1736,9 @@ def test_relative_past_dates(self, date_string, ago, period): param("21 izinsuku ezedlule", ago={"days": 21}, period="day"), ] ) - def test_normalized_relative_dates(self, date_string, ago, period): + def test_normalized_relative_dates( + self, date_string: str, ago: dict[str, Any], period: str + ) -> None: date_string = normalize_unicode(date_string) self.given_parser(settings={"NORMALIZE": True}) self.given_date_string(date_string) @@ -2345,7 +2352,9 @@ def test_normalized_relative_dates(self, date_string, ago, period): param("4 週後", in_future={"weeks": 4}, period="week"), ] ) - def test_relative_future_dates(self, date_string, in_future, period): + def test_relative_future_dates( + self, date_string: str, in_future: dict[str, Any], period: str + ) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() @@ -2360,7 +2369,7 @@ def test_relative_future_dates(self, date_string, in_future, period): param("4 heures ago"), ] ) - def test_insane_dates(self, date_string): + def test_insane_dates(self, date_string: str) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() @@ -2380,7 +2389,7 @@ def test_insane_dates(self, date_string): param("123455678976543 month"), ] ) - def test_dates_not_supported_by_date_time(self, date_string): + def test_dates_not_supported_by_date_time(self, date_string: str) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() @@ -2394,7 +2403,9 @@ def test_dates_not_supported_by_date_time(self, date_string): param("3mons ago", ago={"months": 3}, period="month"), # 1123 ] ) - def test_known_issues(self, date_string, ago, period): + def test_known_issues( + self, date_string: str, ago: dict[str, Any], period: str + ) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() @@ -2409,7 +2420,9 @@ def test_known_issues(self, date_string, ago, period): param("há alguns segundos", boundary={"seconds": 45}, period="day"), ] ) - def test_inexplicit_dates(self, date_string, boundary, period): + def test_inexplicit_dates( + self, date_string: str, boundary: dict[str, int], period: str + ) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() @@ -2434,14 +2447,16 @@ def test_inexplicit_dates(self, date_string, boundary, period): param("tomorrow at 2 PM", date(2014, 9, 2), time(14, 0)), ] ) - def test_freshness_date_with_time(self, date_string, date, time): + def test_freshness_date_with_time( + self, date_string: str, date: date, time: time + ) -> None: self.given_parser() self.given_date_string(date_string) self.when_date_is_parsed() self.then_date_is(date) self.then_time_is(time) - def test_freshness_date_with_time_and_timezone(self): + def test_freshness_date_with_time_and_timezone(self) -> None: self.given_parser(settings={"TIMEZONE": "local"}) self.given_date_string("tomorrow 8:30 CST") self.when_date_is_parsed() @@ -2460,8 +2475,8 @@ def test_freshness_date_with_time_and_timezone(self): ] ) def test_freshness_date_with_pytz_timezones( - self, date_string, timezone, date, time - ): + self, date_string: str, timezone: str, date: date, time: time + ) -> None: self.given_parser(settings={"TIMEZONE": timezone}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -2485,8 +2500,8 @@ def test_freshness_date_with_pytz_timezones( ] ) def test_freshness_date_with_timezone_conversion( - self, date_string, timezone, to_timezone, date, time - ): + self, date_string: str, timezone: str, to_timezone: str, date: date, time: time + ) -> None: self.given_parser( settings={ "TIMEZONE": timezone, @@ -2499,7 +2514,7 @@ def test_freshness_date_with_timezone_conversion( self.then_date_is(date) self.then_time_is(time) - def test_freshness_date_with_to_timezone_setting(self): + def test_freshness_date_with_to_timezone_setting(self) -> None: _settings = settings.replace( TIMEZONE="local", TO_TIMEZONE="UTC", @@ -2507,10 +2522,8 @@ def test_freshness_date_with_to_timezone_setting(self): ) parser = dateparser.freshness_date_parser.FreshnessDateDataParser() - timezone = ( - ZoneInfo(key="US/Eastern") if ZoneInfo else pytz.timezone("US/Eastern") - ) - parser.get_local_tz = Mock(return_value=timezone) + timezone = ZoneInfo(key="US/Eastern") + parser.get_local_tz = Mock(return_value=timezone) # type: ignore[method-assign] result = parser.get_date_data("1 minute ago", _settings) result = result["date_obj"] self.assertEqual(result.date(), date(2014, 9, 1)) @@ -2524,8 +2537,8 @@ def test_freshness_date_with_to_timezone_setting(self): ] ) def test_freshness_date_with_timezone_abbreviations( - self, date_string, timezone, date, time - ): + self, date_string: str, timezone: str, date: date, time: time + ) -> None: self.given_parser(settings={"TIMEZONE": timezone}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -2540,8 +2553,8 @@ def test_freshness_date_with_timezone_abbreviations( ] ) def test_freshness_date_with_timezone_utc_offset( - self, date_string, timezone, date, time - ): + self, date_string: str, timezone: str, date: date, time: time + ) -> None: self.given_parser(settings={"TIMEZONE": timezone}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -2593,7 +2606,9 @@ def test_freshness_date_with_timezone_utc_offset( param("0,5 hours ago", date(2010, 6, 4), time(12, 45)), ] ) - def test_freshness_date_with_relative_base(self, date_string, date, time): + def test_freshness_date_with_relative_base( + self, date_string: str, date: date, time: time + ) -> None: self.given_parser(settings={"RELATIVE_BASE": datetime(2010, 6, 4, 13, 15)}) self.given_date_string(date_string) self.when_date_is_parsed() @@ -2606,7 +2621,9 @@ def test_freshness_date_with_relative_base(self, date_string, date, time): param("2 years", date(2008, 6, 4), time(13, 15)), ] ) - def test_freshness_date_with_relative_base_past(self, date_string, date, time): + def test_freshness_date_with_relative_base_past( + self, date_string: str, date: date, time: time + ) -> None: self.given_parser( settings={ "PREFER_DATES_FROM": "past", @@ -2624,7 +2641,9 @@ def test_freshness_date_with_relative_base_past(self, date_string, date, time): param("2 years", date(2012, 6, 4), time(13, 15)), ] ) - def test_freshness_date_with_relative_base_future(self, date_string, date, time): + def test_freshness_date_with_relative_base_future( + self, date_string: str, date: date, time: time + ) -> None: self.given_parser( settings={ "PREFER_DATES_FROM": "future", @@ -2636,7 +2655,7 @@ def test_freshness_date_with_relative_base_future(self, date_string, date, time) self.then_date_is(date) self.then_time_is(time) - def test_long_digit_run_does_not_hang(self): + def test_long_digit_run_does_not_hang(self) -> None: # Possessive quantifiers (\d++[.,]?\d*+) prevent quadratic backtracking. # Without the fix, PATTERN.findall('9' * 3200) takes ~23 s; with it, ~0.02 s. long_digits = "9" * 3200 @@ -2656,13 +2675,15 @@ def test_long_digit_run_does_not_hang(self): elapsed, 1.0, "split_relative_regex backtracked on long digit run" ) - def given_date_string(self, date_string): + def given_date_string(self, date_string: str) -> None: self.date_string = date_string - def given_parser(self, settings=None): - def collecting_get_date_data(get_date_data): + def given_parser(self, settings: Settings | dict[str, Any] | None = None) -> None: + def collecting_get_date_data( + get_date_data: Callable[..., DateData], + ) -> Callable[..., DateData]: @wraps(get_date_data) - def wrapped(*args, **kwargs): + def wrapped(*args: Any, **kwargs: Any) -> DateData: self.freshness_result = get_date_data(*args, **kwargs) return self.freshness_result @@ -2678,7 +2699,7 @@ def wrapped(*args, **kwargs): self.freshness_parser = Mock(wraps=freshness_date_parser) - dt_mock = Mock(wraps=dateparser.freshness_date_parser.datetime) + dt_mock = Mock(wraps=dateparser.freshness_date_parser.datetime) # type: ignore[attr-defined] dt_mock.now = Mock(side_effect=self.now_with_timezone) self.add_patch(patch("dateparser.freshness_date_parser.datetime", new=dt_mock)) self.add_patch( @@ -2686,43 +2707,47 @@ def wrapped(*args, **kwargs): ) self.parser = DateDataParser(settings=settings) - def when_date_is_parsed(self): + def when_date_is_parsed(self) -> None: try: self.result = self.parser.get_date_data(self.date_string) except Exception as error: self.error = error - def then_date_is(self, date): + def then_date_is(self, date: date) -> None: self.assertEqual(date, self.result["date_obj"].date()) - def then_time_is(self, time): + def then_time_is(self, time: time) -> None: self.assertEqual(time, self.result["date_obj"].time()) - def then_timezone_is(self, timezone): + def then_timezone_is(self, timezone: str) -> None: self.assertEqual(timezone, self.result["date_obj"].tzname()) - def then_period_is(self, period): + def then_period_is(self, period: str) -> None: self.assertEqual(period, self.result["period"]) - def then_date_obj_is_between(self, low_boundary, high_boundary): + def then_date_obj_is_between( + self, low_boundary: datetime, high_boundary: datetime + ) -> None: self.assertGreater(self.result["date_obj"], low_boundary) self.assertLess(self.result["date_obj"], high_boundary) - def then_date_obj_is_exactly_this_time_ago(self, ago): + def then_date_obj_is_exactly_this_time_ago(self, ago: dict[str, Any]) -> None: self.assertEqual(self.now - relativedelta(**ago), self.result["date_obj"]) - def then_date_obj_is_exactly_this_time_in_future(self, in_future): + def then_date_obj_is_exactly_this_time_in_future( + self, in_future: dict[str, Any] + ) -> None: self.assertEqual(self.now + relativedelta(**in_future), self.result["date_obj"]) - def then_date_was_not_parsed(self): + def then_date_was_not_parsed(self) -> None: self.assertIsNone( self.result["date_obj"], f'"{self.date_string}" should not be parsed' ) - def then_date_was_parsed_by_freshness_parser(self): + def then_date_was_parsed_by_freshness_parser(self) -> None: self.assertEqual(self.result, self.freshness_result) - def then_error_was_not_raised(self): + def then_error_was_not_raised(self) -> None: self.assertEqual(NotImplemented, self.error) diff --git a/tests/test_hijri.py b/tests/test_hijri.py index 8f0bc2a39..3e49ebcc2 100644 --- a/tests/test_hijri.py +++ b/tests/test_hijri.py @@ -3,6 +3,7 @@ pytest.importorskip("hijridate") from datetime import datetime +from typing import TYPE_CHECKING from parameterized import param, parameterized @@ -10,21 +11,30 @@ from dateparser.conf import settings from tests import BaseTestCase +if TYPE_CHECKING: + from dateparser.date import DateData + class TestHijriParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented - self.date_string = NotImplemented - self.parser = NotImplemented + self.result: DateData | None = NotImplemented + self.date_string: str = NotImplemented + self.parser: HijriCalendar = NotImplemented self.translated = NotImplemented - def when_date_is_given(self, dt_string, date_formats, languages): + def when_date_is_given( + self, + dt_string: str, + date_formats: list[str] | None, + languages: list[str] | None, + ) -> None: self.date_string = dt_string self.parser = HijriCalendar(dt_string) self.result = self.parser.get_date() - def then_parsed_datetime_is(self, dt): + def then_parsed_datetime_is(self, dt: datetime) -> None: + assert self.result is not None self.assertEqual(dt, self.result["date_obj"]) @parameterized.expand( @@ -59,8 +69,12 @@ def then_parsed_datetime_is(self, dt): ] ) def test_datetime_parsing( - self, dt_string, dt_obj, date_formats=None, languages=None - ): + self, + dt_string: str, + dt_obj: datetime, + date_formats: list[str] | None = None, + languages: list[str] | None = None, + ) -> None: settings.DATE_ORDER = "DMY" self.when_date_is_given(dt_string, date_formats, languages) self.then_parsed_datetime_is(dt_obj) diff --git a/tests/test_jalali.py b/tests/test_jalali.py index 859c8e204..cc4c137a2 100644 --- a/tests/test_jalali.py +++ b/tests/test_jalali.py @@ -3,6 +3,7 @@ pytest.importorskip("convertdate") from datetime import datetime +from typing import TYPE_CHECKING from parameterized import param, parameterized @@ -10,16 +11,19 @@ from dateparser.calendars.jalali_parser import PersianDate, jalali_parser from tests import BaseTestCase +if TYPE_CHECKING: + from dateparser.date import DateData + class TestPersianDate(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.persian_date = NotImplemented + self.persian_date: PersianDate = NotImplemented - def when_date_is_given(self, year, month, day): + def when_date_is_given(self, year: int, month: int, day: int) -> None: self.persian_date = PersianDate(year, month, day) - def then_weekday_is(self, weekday): + def then_weekday_is(self, weekday: int | None) -> None: self.assertEqual(self.persian_date.weekday(), weekday) @parameterized.expand( @@ -28,32 +32,35 @@ def then_weekday_is(self, weekday): param(year=1348, month=2, day=28, weekday=0), param(year=1348, month=3, day=27, weekday=2), param(year=1348, month=4, day=11, weekday=3), + param(year=1348, month=1, day=32, weekday=None), param(year=1348, month=12, day=31, weekday=None), ] ) - def test_weekday(self, year, month, day, weekday): + def test_weekday( + self, year: int, month: int, day: int, weekday: int | None + ) -> None: self.when_date_is_given(year, month, day) self.then_weekday_is(weekday) class TestJalaliParser(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.translated = NotImplemented + self.translated: str = NotImplemented - def when_date_is_given(self, date_string): + def when_date_is_given(self, date_string: str) -> None: self.translated = jalali_parser.to_latin(date_string) - def then_month_is_parsed_as(self, month_name): + def then_month_is_parsed_as(self, month_name: str) -> None: self.assertEqual(month_name, self.translated) - def then_weekday_is_parsed_as(self, weekday): + def then_weekday_is_parsed_as(self, weekday: str) -> None: self.assertEqual(weekday, self.translated) - def then_digit_is_parsed_as(self, digit): + def then_digit_is_parsed_as(self, digit: str) -> None: self.assertEqual(digit, self.translated) - def then_numeral_parsed_is(self, datetime): + def then_numeral_parsed_is(self, datetime: str) -> None: self.assertEqual(datetime, self.translated) @parameterized.expand( @@ -72,7 +79,7 @@ def then_numeral_parsed_is(self, datetime): param(date_string="اسفند", latin="Esfand"), ] ) - def test_replace_months(self, date_string, latin): + def test_replace_months(self, date_string: str, latin: str) -> None: self.when_date_is_given(date_string) self.then_month_is_parsed_as(latin) @@ -87,7 +94,7 @@ def test_replace_months(self, date_string, latin): param(date_string="جمعه", latin="Friday"), ] ) - def test_replace_weekdays(self, date_string, latin): + def test_replace_weekdays(self, date_string: str, latin: str) -> None: self.when_date_is_given(date_string) self.then_weekday_is_parsed_as(latin) @@ -99,7 +106,7 @@ def test_replace_weekdays(self, date_string, latin): param(date_string="۰۵۶۱۲۷۳۸۹۴", latin="0561273894"), ] ) - def test_replace_digits(self, date_string, latin): + def test_replace_digits(self, date_string: str, latin: str) -> None: self.when_date_is_given(date_string) self.then_digit_is_parsed_as(latin) @@ -164,24 +171,27 @@ def test_replace_digits(self, date_string, latin): param(persian="سی و یکم", numeral="31"), ] ) - def test_replace_day_literal_with_numerals(self, persian, numeral): + def test_replace_day_literal_with_numerals( + self, persian: str, numeral: str + ) -> None: self.when_date_is_given(persian) self.then_numeral_parsed_is(numeral) class TestJalaliCalendar(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.result = NotImplemented - self.date_string = NotImplemented - self.calendar = NotImplemented + self.result: DateData | None = NotImplemented + self.date_string: str = NotImplemented + self.calendar: JalaliCalendar = NotImplemented - def when_date_is_given(self, date_string): + def when_date_is_given(self, date_string: str) -> None: self.date_string = date_string self.calendar = JalaliCalendar(date_string) self.result = self.calendar.get_date() - def then_date_parsed_is(self, datetime): + def then_date_parsed_is(self, datetime: datetime) -> None: + assert self.result is not None self.assertEqual(datetime, self.result["date_obj"]) @parameterized.expand( @@ -255,6 +265,10 @@ def then_date_parsed_is(self, datetime): ), ] ) - def test_get_date(self, date_string, dt): + def test_get_date(self, date_string: str, dt: datetime) -> None: self.when_date_is_given(date_string) self.then_date_parsed_is(dt) + + def test_get_date_invalid(self) -> None: + self.when_date_is_given("foo") + self.assertIsNone(self.result) diff --git a/tests/test_language_detect.py b/tests/test_language_detect.py index 2ab1cda45..350e4b999 100644 --- a/tests/test_language_detect.py +++ b/tests/test_language_detect.py @@ -19,43 +19,43 @@ class LangDetectBasicTest(unittest.TestCase): """Tests for basic langdetect functionality""" - def test_returns_list(self): + def test_returns_list(self) -> None: result = lang_detect_detect_languages("14 June 2020", 0.0) self.assertIsInstance(result, list) - def test_detects_english(self): + def test_detects_english(self) -> None: result = lang_detect_detect_languages( "The meeting is scheduled for Tuesday, July 22, 2014", 0.5 ) self.assertIn("en", result) - def test_detects_spanish(self): + def test_detects_spanish(self) -> None: result = lang_detect_detect_languages( "La reunión está programada para el martes 22 de julio de 2014", 0.5 ) self.assertIn("es", result) - def test_detects_french(self): + def test_detects_french(self) -> None: result = lang_detect_detect_languages( "La réunion est prévue pour le mardi 22 juillet 2014", 0.5 ) self.assertIn("fr", result) - def test_detects_german(self): + def test_detects_german(self) -> None: result = lang_detect_detect_languages( "Das Treffen ist für Dienstag, den 22. Juli 2014 geplant", 0.5 ) self.assertIn("de", result) - def test_handles_numeric_only_input(self): + def test_handles_numeric_only_input(self) -> None: result = lang_detect_detect_languages("10-10-2021", 0.5) self.assertEqual(result, []) - def test_handles_empty_string(self): + def test_handles_empty_string(self) -> None: result = lang_detect_detect_languages("", 0.5) self.assertEqual(result, []) - def test_confidence_threshold_filters_results(self): + def test_confidence_threshold_filters_results(self) -> None: # With low threshold, should detect language result_low = lang_detect_detect_languages("14 June 2020", 0.0) self.assertGreater(len(result_low), 0) @@ -69,50 +69,50 @@ def test_confidence_threshold_filters_results(self): class LangDetectIntegrationTest(unittest.TestCase): """Tests for langdetect integration with dateparser""" - def test_parse_with_langdetect_english(self): + def test_parse_with_langdetect_english(self) -> None: result = parse( "Tuesday Jul 22, 2014", detect_languages_function=lang_detect_detect_languages, ) self.assertEqual(result, datetime(2014, 7, 22, 0, 0, 0)) - def test_parse_with_langdetect_spanish(self): + def test_parse_with_langdetect_spanish(self) -> None: result = parse( "martes 22 de julio de 2014", detect_languages_function=lang_detect_detect_languages, ) - self.assertIsNotNone(result) + assert result is not None self.assertEqual(result.year, 2014) self.assertEqual(result.month, 7) self.assertEqual(result.day, 22) - def test_parse_with_langdetect_french(self): + def test_parse_with_langdetect_french(self) -> None: result = parse( "mardi 22 juillet 2014", detect_languages_function=lang_detect_detect_languages, ) - self.assertIsNotNone(result) + assert result is not None self.assertEqual(result.year, 2014) self.assertEqual(result.month, 7) self.assertEqual(result.day, 22) - def test_datedataparser_with_langdetect(self): + def test_datedataparser_with_langdetect(self) -> None: ddp = DateDataParser(detect_languages_function=lang_detect_detect_languages) result = ddp.get_date_data("Tuesday Jul 22, 2014") self.assertEqual(result["date_obj"], datetime(2014, 7, 22, 0, 0, 0)) - def test_search_dates_with_langdetect(self): + def test_search_dates_with_langdetect(self) -> None: result = search_dates( "The event is on January 3, 2017 and ends February 1st", detect_languages_function=lang_detect_detect_languages, ) - self.assertIsNotNone(result) + assert result is not None self.assertEqual(len(result), 2) # Check that dates are found self.assertEqual(result[0][1], datetime(2017, 1, 3, 0, 0)) self.assertEqual(result[1][1], datetime(2017, 2, 1, 0, 0)) - def test_parse_without_langdetect_still_works(self): + def test_parse_without_langdetect_still_works(self) -> None: # Ensure dateparser works without custom language detection result = parse("Tuesday Jul 22, 2014") self.assertEqual(result, datetime(2014, 7, 22, 0, 0, 0)) @@ -123,15 +123,17 @@ class MockLangDetectTest(unittest.TestCase): # Mock test for parse, search_dates and DateDataParser + result: object + detect_languages = Mock() detect_languages.return_value = ["en"] # parse - def when_date_is_parsed_using_parse(self, dt_string): + def when_date_is_parsed_using_parse(self, dt_string: str) -> None: self.result = parse(dt_string, detect_languages_function=self.detect_languages) - def then_date_obj_exactly_is(self, expected_date_obj): + def then_date_obj_exactly_is(self, expected_date_obj: object) -> None: self.assertEqual(expected_date_obj, self.result) @parameterized.expand( @@ -139,13 +141,15 @@ def then_date_obj_exactly_is(self, expected_date_obj): param("Tuesday Jul 22, 2014", datetime(2014, 7, 22, 0, 0, 0)), ] ) - def test_custom_language_detect_mock_parse(self, dt_string, expected_date_obj): + def test_custom_language_detect_mock_parse( + self, dt_string: str, expected_date_obj: datetime + ) -> None: self.when_date_is_parsed_using_parse(dt_string) self.then_date_obj_exactly_is(expected_date_obj) # DateDataParser - def when_date_is_parsed_using_with_datedataparser(self, dt_string): + def when_date_is_parsed_using_with_datedataparser(self, dt_string: str) -> None: ddp = DateDataParser(detect_languages_function=self.detect_languages) self.result = ddp.get_date_data(dt_string)["date_obj"] @@ -155,14 +159,14 @@ def when_date_is_parsed_using_with_datedataparser(self, dt_string): ] ) def test_custom_language_detect_mock_datedataparser( - self, dt_string, expected_date_obj - ): + self, dt_string: str, expected_date_obj: datetime + ) -> None: self.when_date_is_parsed_using_with_datedataparser(dt_string) self.then_date_obj_exactly_is(expected_date_obj) # search_date - def when_date_is_parsed_using_with_search_dates(self, dt_string): + def when_date_is_parsed_using_with_search_dates(self, dt_string: str) -> None: self.result = search_dates( dt_string, detect_languages_function=self.detect_languages ) @@ -179,7 +183,7 @@ def when_date_is_parsed_using_with_search_dates(self, dt_string): ] ) def test_custom_language_detect_mock_search_dates( - self, dt_string, expected_date_obj - ): + self, dt_string: str, expected_date_obj: list[tuple[str, datetime]] + ) -> None: self.when_date_is_parsed_using_with_search_dates(dt_string) self.then_date_obj_exactly_is(expected_date_obj) diff --git a/tests/test_languages.py b/tests/test_languages.py index bcfd0304e..334d054df 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -1,19 +1,24 @@ import logging from datetime import datetime from io import StringIO +from typing import Any from unittest.mock import patch import pytest from parameterized import param, parameterized from dateparser import parse -from dateparser.conf import apply_settings, settings +from dateparser.conf import Settings, apply_settings, settings from dateparser.date import DateDataParser from dateparser.languages import Locale, default_loader from dateparser.languages.dictionary import Dictionary from dateparser.languages.validation import LanguageValidator from dateparser.search import search_dates -from dateparser.search.detection import AutoDetectLanguage, ExactLanguages +from dateparser.search.detection import ( + AutoDetectLanguage, + BaseLanguageDetector, + ExactLanguages, +) from dateparser.utils import normalize_unicode from tests import BaseTestCase @@ -38,7 +43,9 @@ class TestLocaleTranslation: ("23 März 18:37", "23 march 18:37", "de", False), ], ) - def test_keep_formatting(self, date_string, expected, locale, keep_formatting): + def test_keep_formatting( + self, date_string: str, expected: str, locale: str, keep_formatting: bool + ) -> None: result = default_loader.get_locale(locale).translate( date_string=date_string, keep_formatting=keep_formatting, settings=settings ) @@ -47,14 +54,14 @@ def test_keep_formatting(self, date_string, expected, locale, keep_formatting): class TestBundledLanguages(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.language = NotImplemented - self.datetime_string = NotImplemented - self.translation = NotImplemented - self.tokens = NotImplemented - self.result = NotImplemented - self.settings = NotImplemented + self.language: Locale = NotImplemented + self.datetime_string: str = NotImplemented + self.translation: str = NotImplemented + self.tokens: list[str] = NotImplemented + self.result: bool = NotImplemented + self.settings: Settings = NotImplemented @parameterized.expand( [ @@ -1096,7 +1103,9 @@ def setUp(self): param("zu", "son 23 umasingana 1996", "sunday 23 january 1996"), ] ) - def test_translation(self, shortname, datetime_string, expected_translation): + def test_translation( + self, shortname: str, datetime_string: str, expected_translation: str + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2099,8 +2108,8 @@ def test_translation(self, shortname, datetime_string, expected_translation): ] ) def test_freshness_translation( - self, shortname, datetime_string, expected_translation - ): + self, shortname: str, datetime_string: str, expected_translation: str + ) -> None: self.given_settings(settings={"NORMALIZE": False}) # Finnish language use "t" as hour, so empty SKIP_TOKENS. if shortname == "fi": @@ -2388,7 +2397,9 @@ def test_freshness_translation( param("naq", "13 ǃkhanǀgôab 1887", ["13", " ", "ǃkhanǀgôab", " ", "1887"]), ] ) - def test_split(self, shortname, datetime_string, expected_tokens): + def test_split( + self, shortname: str, datetime_string: str, expected_tokens: list[str] + ) -> None: self.given_settings(settings={"NORMALIZE": False}) self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2419,7 +2430,9 @@ def test_split(self, shortname, datetime_string, expected_tokens): param("bn", "3 সপ্তাহ", strip_timezone=False), ] ) - def test_applicable_languages(self, shortname, datetime_string, strip_timezone): + def test_applicable_languages( + self, shortname: str, datetime_string: str, strip_timezone: bool + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2434,7 +2447,9 @@ def test_applicable_languages(self, shortname, datetime_string, strip_timezone): param("cs", "3 hafta", strip_timezone=False), ] ) - def test_not_applicable_languages(self, shortname, datetime_string, strip_timezone): + def test_not_applicable_languages( + self, shortname: str, datetime_string: str, strip_timezone: bool + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2451,8 +2466,8 @@ def test_not_applicable_languages(self, shortname, datetime_string, strip_timezo ] ) def test_applicable_languages_when_ignoring_surrounding_text( - self, shortname, datetime_string - ): + self, shortname: str, datetime_string: str + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2469,8 +2484,8 @@ def test_applicable_languages_when_ignoring_surrounding_text( ] ) def test_not_applicable_languages_when_ignoring_surrounding_text( - self, shortname, datetime_string - ): + self, shortname: str, datetime_string: str + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2494,8 +2509,8 @@ def test_not_applicable_languages_when_ignoring_surrounding_text( ] ) def test_translation_when_ignoring_surrounding_text( - self, shortname, datetime_string, expected_translation - ): + self, shortname: str, datetime_string: str, expected_translation: str + ) -> None: self.given_settings() self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -2503,33 +2518,36 @@ def test_translation_when_ignoring_surrounding_text( self.then_string_translated_to(expected_translation) @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings - def given_string(self, datetime_string): + def given_string(self, datetime_string: str) -> None: if self.settings.NORMALIZE: datetime_string = normalize_unicode(datetime_string) self.datetime_string = datetime_string - def given_bundled_language(self, shortname): + def given_bundled_language(self, shortname: str) -> None: self.language = default_loader.get_locale(shortname) - def when_datetime_string_translated(self): + def when_datetime_string_translated(self) -> None: self.translation = self.language.translate( self.datetime_string, settings=self.settings ) - def when_datetime_string_splitted(self, keep_formatting=False): + def when_datetime_string_splitted(self, keep_formatting: bool = False) -> None: self.tokens = self.language._get_dictionary(self.settings).split( self.datetime_string ) - def when_datetime_string_checked_if_applicable(self, strip_timezone): + def when_datetime_string_checked_if_applicable(self, strip_timezone: bool) -> None: self.result = self.language.is_applicable( self.datetime_string, strip_timezone, settings=self.settings ) - def when_datetime_string_checked_if_applicable_ignoring_surrounding_text(self): + def when_datetime_string_checked_if_applicable_ignoring_surrounding_text( + self, + ) -> None: self.result = self.language.is_applicable( self.datetime_string, strip_timezone=False, @@ -2537,23 +2555,23 @@ def when_datetime_string_checked_if_applicable_ignoring_surrounding_text(self): ignore_surrounding_text=True, ) - def when_datetime_string_translated_ignoring_surrounding_text(self): + def when_datetime_string_translated_ignoring_surrounding_text(self) -> None: self.translation = self.language.translate( self.datetime_string, settings=self.settings, ignore_surrounding_text=True, ) - def then_string_translated_to(self, expected_string): + def then_string_translated_to(self, expected_string: str) -> None: self.assertEqual(expected_string, self.translation) - def then_tokens_are(self, expected_tokens): + def then_tokens_are(self, expected_tokens: list[str]) -> None: self.assertEqual(expected_tokens, self.tokens) - def then_language_is_applicable(self): + def then_language_is_applicable(self) -> None: self.assertTrue(self.result) - def then_language_is_not_applicable(self): + def then_language_is_not_applicable(self) -> None: self.assertFalse(self.result) @@ -2562,19 +2580,21 @@ class BaseLanguageDetectorTestCase(BaseTestCase): NOT_DETECTED = object() - def setUp(self): + def setUp(self) -> None: super().setUp() - self.datetime_string = NotImplemented - self.detector = NotImplemented - self.detected_language = NotImplemented - self.known_languages = None + self.datetime_string: str = NotImplemented + self.detector: BaseLanguageDetector = NotImplemented + self.detected_language: object = NotImplemented + self.known_languages: list[Locale] | None = None @parameterized.expand( [ param("1 january 2015", "en"), ] ) - def test_valid_dates_detected(self, datetime_string, expected_language): + def test_valid_dates_detected( + self, datetime_string: str, expected_language: str + ) -> None: self.given_locales(expected_language) self.given_detector() self.given_settings() @@ -2587,7 +2607,7 @@ def test_valid_dates_detected(self, datetime_string, expected_language): param("foo"), ] ) - def test_invalid_dates_not_detected(self, datetime_string): + def test_invalid_dates_not_detected(self, datetime_string: str) -> None: self.given_locales("en") self.given_detector() self.given_settings() @@ -2595,7 +2615,7 @@ def test_invalid_dates_not_detected(self, datetime_string): self.when_searching_for_first_applicable_language() self.then_no_language_was_detected() - def test_invalid_date_after_valid_date_not_detected(self): + def test_invalid_date_after_valid_date_not_detected(self) -> None: self.given_settings() self.given_locales("en") self.given_detector() @@ -2604,7 +2624,7 @@ def test_invalid_date_after_valid_date_not_detected(self): self.when_searching_for_first_applicable_language() self.then_no_language_was_detected() - def test_valid_date_after_invalid_date_detected(self): + def test_valid_date_after_invalid_date_detected(self) -> None: self.given_locales("en") self.given_settings() self.given_detector() @@ -2613,28 +2633,29 @@ def test_valid_date_after_invalid_date_detected(self): self.when_searching_for_first_applicable_language() self.then_language_was_detected("en") - def given_locales(self, *shortnames): + def given_locales(self, *shortnames: str) -> None: self.known_languages = [ default_loader.get_locale(shortname) for shortname in shortnames ] @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings - def given_previously_detected_string(self, datetime_string): + def given_previously_detected_string(self, datetime_string: str) -> None: for _ in self.detector.iterate_applicable_languages( datetime_string, modify=True, settings=self.settings ): break - def given_string(self, datetime_string): + def given_string(self, datetime_string: str) -> None: self.datetime_string = datetime_string - def given_detector(self): + def given_detector(self) -> None: raise NotImplementedError - def when_searching_for_first_applicable_language(self): + def when_searching_for_first_applicable_language(self) -> None: for language in self.detector.iterate_applicable_languages( self.datetime_string, modify=True, settings=self.settings ): @@ -2643,13 +2664,14 @@ def when_searching_for_first_applicable_language(self): else: self.detected_language = self.NOT_DETECTED - def then_language_was_detected(self, shortname): + def then_language_was_detected(self, shortname: str) -> None: self.assertIsInstance( self.detected_language, Locale, "Language was not properly detected" ) + assert isinstance(self.detected_language, Locale) self.assertEqual(shortname, self.detected_language.shortname) - def then_no_language_was_detected(self): + def then_no_language_was_detected(self) -> None: self.assertIs(self.detected_language, self.NOT_DETECTED) @@ -2664,7 +2686,7 @@ class TestExactLanguages(BaseLanguageDetectorTestCase): param("01-01-12", ["en"]), ] ) - def test_exact_languages(self, datetime_string, shortnames): + def test_exact_languages(self, datetime_string: str, shortnames: list[str]) -> None: self.given_settings() self.given_string(datetime_string) self.given_known_languages(shortnames) @@ -2672,25 +2694,27 @@ def test_exact_languages(self, datetime_string, shortnames): self.when_using_exact_languages() self.then_exact_languages_were_filtered(shortnames) - def test_none_raises_value_error(self): + def test_none_raises_value_error(self) -> None: with self.assertRaisesRegex( ValueError, r"language cannot be None for ExactLanguages" ): ExactLanguages(None) @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings - def given_known_languages(self, shortnames): + def given_known_languages(self, shortnames: list[str]) -> None: self.known_languages = [ default_loader.get_locale(shortname) for shortname in shortnames ] - def given_detector(self): + def given_detector(self) -> None: self.assertIsInstance( self.known_languages, list, "Require a list of languages to initialize" ) + assert self.known_languages is not None self.assertGreaterEqual( len(self.known_languages), 1, @@ -2698,27 +2722,29 @@ def given_detector(self): ) self.detector = ExactLanguages(languages=self.known_languages) - def when_using_exact_languages(self): + def when_using_exact_languages(self) -> None: self.exact_languages = self.detector.iterate_applicable_languages( self.datetime_string, modify=True, settings=self.settings ) - def then_exact_languages_were_filtered(self, shortnames): + def then_exact_languages_were_filtered(self, shortnames: list[str]) -> None: self.assertEqual( set(shortnames), {lang.shortname for lang in self.exact_languages} ) class BaseAutoDetectLanguageDetectorTestCase(BaseLanguageDetectorTestCase): - allow_redetection = NotImplemented + allow_redetection: bool = NotImplemented - def given_detector(self): + def given_detector(self) -> None: + assert self.known_languages is not None self.detector = AutoDetectLanguage( languages=self.known_languages, allow_redetection=self.allow_redetection ) @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings @@ -2737,16 +2763,15 @@ class TestAutoDetectLanguageDetectorWithRedetection( class TestLanguageValidatorWhenInvalid(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() self.validator = LanguageValidator self.captured_logs = StringIO() - self.validator.get_logger() self.sh = logging.StreamHandler(self.captured_logs) - self.validator.logger.addHandler(self.sh) + self.validator.get_logger().addHandler(self.sh) self.log_list = self.captured_logs.getvalue().split("\n")[0] - def get_log_str(self): + def get_log_str(self) -> str: return self.captured_logs.getvalue().split("\n")[0] @parameterized.expand( @@ -2758,7 +2783,9 @@ def get_log_str(self): ), ] ) - def test_validate_info_when_invalid_type(self, lang_id, lang_info, log_msg): + def test_validate_info_when_invalid_type( + self, lang_id: str, lang_info: object, log_msg: str + ) -> None: result = self.validator.validate_info(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2770,7 +2797,9 @@ def test_validate_info_when_invalid_type(self, lang_id, lang_info, log_msg): param("en", {"name": ""}, log_msg="Language 'en' does not have a name"), ] ) - def test_validate_name_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_name_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_name(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2785,7 +2814,9 @@ def test_validate_name_when_invalid(self, lang_id, lang_info, log_msg): ), ] ) - def test_validate_word_spacing_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_word_spacing_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_word_spacing(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2806,7 +2837,9 @@ def test_validate_word_spacing_when_invalid(self, lang_id, lang_info, log_msg): ), ] ) - def test_validate_skip_list_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_skip_list_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_skip_list(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2816,7 +2849,9 @@ def test_validate_skip_list_when_invalid(self, lang_id, lang_info, log_msg): param("en", {}), ] ) - def test_validate_skip_list_when_absent(self, lang_id, lang_info): + def test_validate_skip_list_when_absent( + self, lang_id: str, lang_info: dict[str, Any] + ) -> None: result = self.validator._validate_skip_list(lang_id, lang_info) self.assertTrue(result) @@ -2834,7 +2869,9 @@ def test_validate_skip_list_when_absent(self, lang_id, lang_info): ), ] ) - def test_validate_pertain_list_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_pertain_list_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_pertain_list(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2844,7 +2881,9 @@ def test_validate_pertain_list_when_invalid(self, lang_id, lang_info, log_msg): param("en", {}), ] ) - def test_validate_pertain_list_when_absent(self, lang_id, lang_info): + def test_validate_pertain_list_when_absent( + self, lang_id: str, lang_info: dict[str, Any] + ) -> None: result = self.validator._validate_pertain_list(lang_id, lang_info) self.assertTrue(result) @@ -2883,7 +2922,9 @@ def test_validate_pertain_list_when_absent(self, lang_id, lang_info): ), ] ) - def test_validate_weekdays_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_weekdays_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_weekdays(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2933,7 +2974,9 @@ def test_validate_weekdays_when_invalid(self, lang_id, lang_info, log_msg): ), ] ) - def test_validate_months_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_months_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_months(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -2973,7 +3016,9 @@ def test_validate_months_when_invalid(self, lang_id, lang_info, log_msg): ), ] ) - def test_validate_units_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_units_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_units(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -3001,7 +3046,9 @@ def test_validate_units_when_invalid(self, lang_id, lang_info, log_msg): ), ] ) - def test_validate_other_words_when_invalid(self, lang_id, lang_info, log_msg="na"): + def test_validate_other_words_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str = "na" + ) -> None: result = self.validator._validate_other_words(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -3011,7 +3058,9 @@ def test_validate_other_words_when_invalid(self, lang_id, lang_info, log_msg="na param("en", {}), ] ) - def test_validate_simplifications_when_absent(self, lang_id, lang_info): + def test_validate_simplifications_when_absent( + self, lang_id: str, lang_info: dict[str, Any] + ) -> None: result = self.validator._validate_simplifications(lang_id, lang_info) self.assertTrue(result) @@ -3065,7 +3114,9 @@ def test_validate_simplifications_when_absent(self, lang_id, lang_info): ), ] ) - def test_validate_simplifications_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_simplifications_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_simplifications(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -3087,8 +3138,8 @@ def test_validate_simplifications_when_invalid(self, lang_id, lang_info, log_msg ] ) def test_validate_sentence_splitter_group_when_invalid( - self, lang_id, lang_info, log_msg - ): + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_sentence_splitter_group(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -3102,7 +3153,9 @@ def test_validate_sentence_splitter_group_when_invalid( ), ] ) - def test_validate_extra_keys_when_invalid(self, lang_id, lang_info, log_msg): + def test_validate_extra_keys_when_invalid( + self, lang_id: str, lang_info: dict[str, Any], log_msg: str + ) -> None: result = self.validator._validate_extra_keys(lang_id, lang_info) self.assertEqual(log_msg, self.get_log_str()) self.assertFalse(result) @@ -3118,8 +3171,12 @@ def test_validate_extra_keys_when_invalid(self, lang_id, lang_info, log_msg): ] ) def test_parse_settings_default_languages( - self, date_string, languages, settings, expected - ): + self, + date_string: str, + languages: list[str], + settings: dict[str, Any], + expected: datetime, + ) -> None: result = parse(date_string, languages=languages, settings=settings) assert result == expected @@ -3134,8 +3191,12 @@ def test_parse_settings_default_languages( ] ) def test_date_data_parser_settings_default_languages( - self, date_string, languages, settings, expected - ): + self, + date_string: str, + languages: list[str], + settings: dict[str, Any], + expected: datetime, + ) -> None: ddp = DateDataParser(languages=languages, settings=settings) result = ddp.get_date_data(date_string) assert result.date_obj == expected @@ -3150,8 +3211,11 @@ def test_date_data_parser_settings_default_languages( ] ) def test_search_dates_settings_default_languages( - self, date_string, settings, expected - ): + self, + date_string: str, + settings: dict[str, Any], + expected: list[tuple[str, datetime]], + ) -> None: result = search_dates(date_string, settings=settings) assert result == expected @@ -3159,8 +3223,8 @@ def test_search_dates_settings_default_languages( [param(date_string="RANDOM_WORD ", settings={"DEFAULT_LANGUAGES": ["en"]})] ) def test_parse_settings_default_languages_no_language_detect( - self, date_string, settings - ): + self, date_string: str, settings: dict[str, Any] + ) -> None: result = parse(date_string, settings=settings) assert result is None @@ -3175,14 +3239,18 @@ def test_parse_settings_default_languages_no_language_detect( ] ) def test_parse_settings_default_languages_with_detected_language( - self, date_string, languages, expected, settings - ): + self, + date_string: str, + languages: list[str], + expected: datetime, + settings: dict[str, Any], + ) -> None: result = parse(date_string, languages=languages, settings=settings) assert result == expected class TestNoWordSpacingSecurity: - def test_dictionary_does_not_evaluate_no_word_spacing(self): + def test_dictionary_does_not_evaluate_no_word_spacing(self) -> None: locale_info = { "name": "Test", "skip": [], @@ -3197,7 +3265,7 @@ def test_dictionary_does_not_evaluate_no_word_spacing(self): os_system.assert_not_called() - def test_locale_does_not_evaluate_no_word_spacing(self): + def test_locale_does_not_evaluate_no_word_spacing(self) -> None: language_info = { "name": "Test", "simplifications": [{"x": "y"}], diff --git a/tests/test_loading.py b/tests/test_loading.py index 96e6adfcd..40d7bc7bd 100644 --- a/tests/test_loading.py +++ b/tests/test_loading.py @@ -1,22 +1,31 @@ from operator import attrgetter +from typing import TYPE_CHECKING import regex as re from parameterized import param, parameterized -from dateparser.languages.loader import default_loader +from dateparser.languages.loader import LocaleDataLoader, default_loader from tests import BaseTestCase +if TYPE_CHECKING: + from collections import OrderedDict + from collections.abc import Iterator + + from dateparser.languages.locale import Locale + class TestLoading(BaseTestCase): - def setUp(self): + data_loader: LocaleDataLoader + + def setUp(self) -> None: super().setUp() - self.locale_generator = NotImplemented + self.locale_generator: Iterator[Locale] = NotImplemented @classmethod - def setUpClass(cls): + def setUpClass(cls) -> None: cls.data_loader = default_loader - cls.data_loader._loaded_locales = {} - cls.data_loader._loaded_languages = {} + cls.data_loader._loaded_locales.clear() + cls.data_loader._loaded_languages.clear() @parameterized.expand( [ @@ -244,13 +253,13 @@ def setUpClass(cls): ) def test_loading( self, - given_languages, - given_locales, - given_region, - loaded_languages, - loaded_locales, - expected_locales, - ): + given_languages: list[str] | None, + given_locales: list[str] | None, + given_region: str | None, + loaded_languages: list[str], + loaded_locales: list[str], + expected_locales: list[str], + ) -> None: self.load_data( languages=given_languages, locales=given_locales, region=given_region ) @@ -258,20 +267,25 @@ def test_loading( self.then_loaded_languages_are(loaded_languages) self.then_loaded_locales_are(loaded_locales) - def load_data(self, languages, locales, region): + def load_data( + self, + languages: list[str] | None, + locales: list[str] | None, + region: str | None, + ) -> None: self.locale_generator = self.data_loader.get_locales( languages=languages, locales=locales, region=region, use_given_order=True ) - def then_loaded_languages_are(self, loaded_languages): + def then_loaded_languages_are(self, loaded_languages: list[str]) -> None: self.assertCountEqual( loaded_languages, self.data_loader._loaded_languages.keys() ) - def then_loaded_locales_are(self, loaded_locales): + def then_loaded_locales_are(self, loaded_locales: list[str]) -> None: self.assertCountEqual(loaded_locales, self.data_loader._loaded_locales.keys()) - def then_locales_are_yielded_in_order(self, expected_locales): + def then_locales_are_yielded_in_order(self, expected_locales: list[str]) -> None: self.assertEqual( list(map(attrgetter("shortname"), list(self.locale_generator))), expected_locales, @@ -282,11 +296,11 @@ class TestLocaleDataLoader(BaseTestCase): UNKNOWN_LANGUAGES_EXCEPTION_RE = re.compile(r"Unknown language\(s\): (.+)") UNKNOWN_LOCALES_EXCEPTION_RE = re.compile(r"Unknown locale\(s\): (.+)") - def setUp(self): + def setUp(self) -> None: super().setUp() self.data_loader = default_loader - self.data_loader._loaded_languages = {} - self.data_loader._loaded_locales = {} + self.data_loader._loaded_languages.clear() + self.data_loader._loaded_locales.clear() @parameterized.expand( [ @@ -296,7 +310,7 @@ def setUp(self): param(given_locales=["tl", "nl-SX", "de-BE"]), ] ) - def test_loading_with_given_order(self, given_locales): + def test_loading_with_given_order(self, given_locales: list[str]) -> None: self.load_data(given_locales, use_given_order=True) self.then_locales_are_yielded_in_order(given_locales) @@ -313,7 +327,9 @@ def test_loading_with_given_order(self, given_locales): ), ] ) - def test_loading_without_given_order(self, given_locales, expected_locales): + def test_loading_without_given_order( + self, given_locales: list[str], expected_locales: list[str] + ) -> None: self.load_data(given_locales, use_given_order=False) self.then_locales_are_yielded_in_order(expected_locales) @@ -325,7 +341,7 @@ def test_loading_without_given_order(self, given_locales, expected_locales): param(given_locales=["fr-NE", "ar-SY"]), ] ) - def test_get_locale_map_with_given_order(self, given_locales): + def test_get_locale_map_with_given_order(self, given_locales: list[str]) -> None: self.given_locale_map(locales=given_locales, use_given_order=True) self.then_locale_map_in_order(given_locales) @@ -345,7 +361,9 @@ def test_get_locale_map_with_given_order(self, given_locales): ), ] ) - def test_get_locale_map_without_given_order(self, given_locales, expected_locales): + def test_get_locale_map_without_given_order( + self, given_locales: list[str], expected_locales: list[str] + ) -> None: self.given_locale_map(locales=given_locales, use_given_order=False) self.then_locale_map_in_order(expected_locales) @@ -363,8 +381,8 @@ def test_get_locale_map_without_given_order(self, given_locales, expected_locale ] ) def test_error_raised_for_unknown_languages( - self, given_languages, unknown_languages - ): + self, given_languages: list[str], unknown_languages: list[str] + ) -> None: self.given_locale_map(languages=given_languages) self.then_error_for_unknown_languages_raised(unknown_languages) @@ -380,7 +398,9 @@ def test_error_raised_for_unknown_languages( param(given_locales=["nl-SX", "be-BE", "ca-FR"], unknown_locales=["be-BE"]), ] ) - def test_error_raised_for_unknown_locales(self, given_locales, unknown_locales): + def test_error_raised_for_unknown_locales( + self, given_locales: list[str], unknown_locales: list[str] + ) -> None: self.given_locale_map(locales=given_locales) self.then_error_for_unknown_locales_raised(unknown_locales) @@ -391,7 +411,9 @@ def test_error_raised_for_unknown_locales(self, given_locales, unknown_locales): param(given_locales=["ca-TA", "ca", "fr"]), ] ) - def test_error_raised_for_conflicting_locales(self, given_locales): + def test_error_raised_for_conflicting_locales( + self, given_locales: list[str] + ) -> None: self.given_locale_map(locales=given_locales) self.then_error_was_raised( ValueError, "Locales should not have same language and different region" @@ -404,52 +426,64 @@ def test_error_raised_for_conflicting_locales(self, given_locales): param(given_locales=["af-NA", "da", "af"]), ] ) - def test_conflicting_locales_load_if_allow_conflicting_locales(self, given_locales): + def test_conflicting_locales_load_if_allow_conflicting_locales( + self, given_locales: list[str] + ) -> None: self.load_data( given_locales, use_given_order=True, allow_conflicting_locales=True ) self.then_locales_are_yielded_in_order(given_locales) def load_data( - self, given_locales, use_given_order=False, allow_conflicting_locales=False - ): + self, + given_locales: list[str], + use_given_order: bool = False, + allow_conflicting_locales: bool = False, + ) -> None: self.locale_generator = self.data_loader.get_locales( locales=given_locales, use_given_order=use_given_order, allow_conflicting_locales=allow_conflicting_locales, ) - def given_locale_map(self, languages=None, locales=None, use_given_order=True): + def given_locale_map( + self, + languages: list[str] | None = None, + locales: list[str] | None = None, + use_given_order: bool = True, + ) -> None: try: - self.locale_map = self.data_loader.get_locale_map( + self.locale_map: OrderedDict[str, Locale] = self.data_loader.get_locale_map( languages=languages, locales=locales, use_given_order=use_given_order ) except Exception as error: self.error = error - def then_locales_are_yielded_in_order(self, expected_locales): + def then_locales_are_yielded_in_order(self, expected_locales: list[str]) -> None: self.assertEqual( list(map(attrgetter("shortname"), list(self.locale_generator))), expected_locales, ) - def then_locale_map_in_order(self, expected_locales): + def then_locale_map_in_order(self, expected_locales: list[str]) -> None: self.assertEqual(list(self.locale_map.keys()), expected_locales) - def then_error_for_unknown_languages_raised(self, unknown_languages): + def then_error_for_unknown_languages_raised( + self, unknown_languages: list[str] + ) -> None: self.assertIsInstance(self.error, ValueError) match = self.UNKNOWN_LANGUAGES_EXCEPTION_RE.match(str(self.error)) - self.assertTrue(match) + assert match is not None languages = match.group(1).split(", ") self.assertCountEqual( languages, [repr(unknown_language) for unknown_language in unknown_languages], ) - def then_error_for_unknown_locales_raised(self, unknown_locales): + def then_error_for_unknown_locales_raised(self, unknown_locales: list[str]) -> None: self.assertIsInstance(self.error, ValueError) match = self.UNKNOWN_LOCALES_EXCEPTION_RE.match(str(self.error)) - self.assertTrue(match) + assert match is not None locales = match.group(1).split(", ") self.assertCountEqual( locales, [repr(unknown_locale) for unknown_locale in unknown_locales] diff --git a/tests/test_parser.py b/tests/test_parser.py index 47aa434cd..2a2325022 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -1,9 +1,10 @@ import warnings from datetime import datetime, time +from typing import Any from parameterized import param, parameterized -from dateparser.conf import apply_settings +from dateparser.conf import Settings, apply_settings from dateparser.parser import _no_spaces_parser, _parser, time_parser, tokenizer from tests import BaseTestCase @@ -91,27 +92,29 @@ class TestTokenizer(BaseTestCase): ), ] ) - def test_tokenization(self, date_string, expected_tokens, expected_types): + def test_tokenization( + self, date_string: str, expected_tokens: list[str], expected_types: list[int] + ) -> None: self.given_tokenizer(date_string) self.when_tokenized() self.then_tokens_were(expected_tokens) self.then_token_types_were(expected_types) - def given_tokenizer(self, date_string): + def given_tokenizer(self, date_string: str) -> None: self.tokenizer = tokenizer(date_string) - def when_tokenized(self): - self.result = list(self.tokenizer.tokenize()) + def when_tokenized(self) -> None: + self.result: list[tuple[str, int]] = list(self.tokenizer.tokenize()) - def then_tokens_were(self, expected_tokens): + def then_tokens_were(self, expected_tokens: list[str]) -> None: self.assertEqual([token_type[0] for token_type in self.result], expected_tokens) - def then_token_types_were(self, expected_types): + def then_token_types_were(self, expected_types: list[int]) -> None: self.assertEqual([token_type[1] for token_type in self.result], expected_types) class TestNoSpaceParser(BaseTestCase): - def test_date_with_spaces_is_not_parsed(self): + def test_date_with_spaces_is_not_parsed(self) -> None: datestring = "2013 25 12" self.given_parser() self.given_settings() @@ -130,7 +133,7 @@ def test_date_with_spaces_is_not_parsed(self): ), ] ) - def test_empty_string_is_not_parsed(self, date_string): + def test_empty_string_is_not_parsed(self, date_string: str) -> None: self.given_parser() self.given_settings() self.when_date_is_parsed(date_string) @@ -146,7 +149,7 @@ def test_empty_string_is_not_parsed(self, date_string): ), ] ) - def test_colons_string_is_not_parsed(self, date_string): + def test_colons_string_is_not_parsed(self, date_string: str) -> None: self.given_parser() self.given_settings() self.when_date_is_parsed(date_string) @@ -154,7 +157,7 @@ def test_colons_string_is_not_parsed(self, date_string): ValueError, [f"Unable to parse date from: {date_string}"] ) - def test_date_with_alphabets_is_not_parsed(self): + def test_date_with_alphabets_is_not_parsed(self) -> None: datestring = "12AUG2015" self.given_parser() self.given_settings() @@ -288,8 +291,12 @@ def test_date_with_alphabets_is_not_parsed(self): ] ) def test_date_are_parsed_in_order_supplied( - self, date_string, expected_date, expected_period, date_order - ): + self, + date_string: str, + expected_date: datetime, + expected_period: str, + date_order: str, + ) -> None: self.given_parser() self.given_settings(settings={"DATE_ORDER": date_order}) self.when_date_is_parsed(date_string) @@ -311,8 +318,8 @@ def test_date_are_parsed_in_order_supplied( ] ) def test_default_order_used_if_date_order_not_supplied( - self, date_string, expected_date, expected_period - ): + self, date_string: str, expected_date: datetime, expected_period: str + ) -> None: self.given_parser() self.given_settings(settings={"DATE_ORDER": ""}) self.when_date_is_parsed(date_string) @@ -359,8 +366,8 @@ def test_default_order_used_if_date_order_not_supplied( ] ) def test_best_order_used_if_date_order_not_supplied_to_8_digit_numbers( - self, date_string, expected_date, expected_period - ): + self, date_string: str, expected_date: datetime, expected_period: str + ) -> None: self.given_parser() self.given_settings(settings={"DATE_ORDER": ""}) self.when_date_is_parsed(date_string) @@ -373,7 +380,9 @@ def test_best_order_used_if_date_order_not_supplied_to_8_digit_numbers( param(date_string="987654321234567890123456789", date_order="DMY"), ] ) - def test_error_is_raised_when_date_cannot_be_parsed(self, date_string, date_order): + def test_error_is_raised_when_date_cannot_be_parsed( + self, date_string: str, date_order: str + ) -> None: self.given_parser() self.given_settings(settings={"DATE_ORDER": date_order}) self.when_date_is_parsed(date_string) @@ -399,37 +408,42 @@ def test_error_is_raised_when_date_cannot_be_parsed(self, date_string, date_orde param(format_string="%M%S.%f", expected_period="day"), ] ) - def test_get_period_function(self, format_string, expected_period): + def test_get_period_function( + self, format_string: str, expected_period: str + ) -> None: self.given_parser() self.when_get_period_is_called(format_string) self.then_returned_period_is(expected_period) - def given_parser(self): + def given_parser(self) -> None: self.parser = _no_spaces_parser @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings - def when_date_is_parsed(self, date_string): + def when_date_is_parsed(self, date_string: str) -> None: try: - self.result = self.parser.parse(date_string, self.settings) + self.result: tuple[datetime, str] | str = self.parser.parse( + date_string, self.settings + ) except Exception as error: self.error = error - def when_get_period_is_called(self, format_string): + def when_get_period_is_called(self, format_string: str) -> None: self.result = self.parser._get_period(format_string) - def then_date_exactly_is(self, expected_date): + def then_date_exactly_is(self, expected_date: datetime) -> None: self.assertEqual(self.result[0], expected_date) - def then_period_exactly_is(self, expected_period): + def then_period_exactly_is(self, expected_period: str) -> None: self.assertEqual(self.result[1], expected_period) - def then_date_is_not_parsed(self): + def then_date_is_not_parsed(self) -> None: self.assertIsNone(self.result) - def then_returned_period_is(self, expected_period): + def then_returned_period_is(self, expected_period: str) -> None: self.assertEqual(self.result, expected_period) @@ -443,7 +457,9 @@ class TestParser(BaseTestCase): param(date_string="31/2010"), ] ) - def test_error_is_raised_when_incomplete_dates_given(self, date_string): + def test_error_is_raised_when_incomplete_dates_given( + self, date_string: str + ) -> None: self.given_parser() self.given_settings(settings={"STRICT_PARSING": True}) self.then_error_is_raised_when_date_is_parsed(date_string) @@ -457,7 +473,9 @@ def test_error_is_raised_when_incomplete_dates_given(self, date_string): param(date_string="31/2010"), ] ) - def test_error_is_raised_when_partially_complete_dates_given(self, date_string): + def test_error_is_raised_when_partially_complete_dates_given( + self, date_string: str + ) -> None: self.given_parser() self.given_settings(settings={"REQUIRE_PARTS": ["day", "month", "year"]}) self.then_error_is_raised_when_date_is_parsed(date_string) @@ -469,7 +487,7 @@ def test_error_is_raised_when_partially_complete_dates_given(self, date_string): param(date_string="2010"), ] ) - def test_error_is_raised_when_day_part_missing(self, date_string): + def test_error_is_raised_when_day_part_missing(self, date_string: str) -> None: self.given_parser() self.given_settings(settings={"REQUIRE_PARTS": ["day"]}) self.then_error_is_raised_when_date_is_parsed(date_string) @@ -480,7 +498,7 @@ def test_error_is_raised_when_day_part_missing(self, date_string): param(date_string="31/2010"), ] ) - def test_error_is_raised_when_month_part_missing(self, date_string): + def test_error_is_raised_when_month_part_missing(self, date_string: str) -> None: self.given_parser() self.given_settings(settings={"REQUIRE_PARTS": ["month"]}) self.then_error_is_raised_when_date_is_parsed(date_string) @@ -491,7 +509,7 @@ def test_error_is_raised_when_month_part_missing(self, date_string): param(date_string="March"), ] ) - def test_error_is_raised_when_year_part_missing(self, date_string): + def test_error_is_raised_when_year_part_missing(self, date_string: str) -> None: self.given_parser() self.given_settings(settings={"REQUIRE_PARTS": ["year"]}) self.then_error_is_raised_when_date_is_parsed(date_string) @@ -503,8 +521,8 @@ def test_error_is_raised_when_year_part_missing(self, date_string): ] ) def test_error_is_raised_when_preferred_year_is_out_of_range( - self, relative_base, prefer_dates_from - ): + self, relative_base: datetime, prefer_dates_from: str + ) -> None: self.given_parser() self.given_settings( settings={ @@ -514,20 +532,21 @@ def test_error_is_raised_when_preferred_year_is_out_of_range( ) self.then_error_is_raised_when_date_is_parsed("March 3") - def given_parser(self): + def given_parser(self) -> None: self.parser = _parser @apply_settings - def given_settings(self, settings=None): + def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> None: + assert isinstance(settings, Settings) self.settings = settings - def when_date_is_parsed(self, date_string): + def when_date_is_parsed(self, date_string: str) -> None: try: self.parser.parse(date_string, self.settings) except Exception as error: self.error = error - def then_error_is_raised_when_date_is_parsed(self, date_string): + def then_error_is_raised_when_date_is_parsed(self, date_string: str) -> None: with self.assertRaises(ValueError): self.parser.parse(date_string, self.settings) @@ -542,8 +561,8 @@ def then_error_is_raised_when_date_is_parsed(self, date_string): ] ) def test_parser_does_not_raise_ambiguious_date_deprecation_warning( - self, date_string - ): + self, date_string: str + ) -> None: with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.when_date_is_parsed(date_string) @@ -575,7 +594,7 @@ class TestTimeParser(BaseTestCase): param(date_string="14:30:15.330100", timeobj=time(14, 30, 15, 330100)), ] ) - def test_time_is_parsed(self, date_string, timeobj): + def test_time_is_parsed(self, date_string: str, timeobj: time) -> None: self.given_parser() self.when_time_is_parsed(date_string) self.then_time_exactly_is(timeobj) @@ -591,7 +610,7 @@ def test_time_is_parsed(self, date_string, timeobj): param(date_string="2.45 PM"), ] ) - def test_error_is_raised_for_invalid_time_string(self, date_string): + def test_error_is_raised_for_invalid_time_string(self, date_string: str) -> None: self.given_parser() self.when_time_is_parsed(date_string) self.then_error_was_raised( @@ -599,14 +618,14 @@ def test_error_is_raised_for_invalid_time_string(self, date_string): [f"{date_string} does not seem to be a valid time string"], ) - def given_parser(self): + def given_parser(self) -> None: self.parser = time_parser - def when_time_is_parsed(self, datestring): + def when_time_is_parsed(self, datestring: str) -> None: try: - self.result = self.parser(datestring) + self.result: time = self.parser(datestring) except Exception as error: self.error = error - def then_time_exactly_is(self, timeobj): + def then_time_exactly_is(self, timeobj: time) -> None: self.assertEqual(self.result, timeobj) diff --git a/tests/test_pickle.py b/tests/test_pickle.py index 937517f0c..82354f929 100644 --- a/tests/test_pickle.py +++ b/tests/test_pickle.py @@ -7,26 +7,27 @@ class TestPickle(BaseTestCase): - def test_pickling_basic_parsed_object(self): + def test_pickling_basic_parsed_object(self) -> None: now = parse("now") self.assertIsInstance(now, datetime) pickle_dumps = pickle.dumps(now) self.assertIsInstance(pickle_dumps, bytes) - def test_pickling_parsed_object_with_tz(self): + def test_pickling_parsed_object_with_tz(self) -> None: now_in_utc = parse("now in UTC") self.assertIsInstance(now_in_utc, datetime) + assert now_in_utc is not None self.assertIsInstance(now_in_utc.tzinfo, StaticTzInfo) pickle_dumps = pickle.dumps(now_in_utc) self.assertIsInstance(pickle_dumps, bytes) - def test_unpickling_basic_parsed_object(self): + def test_unpickling_basic_parsed_object(self) -> None: now = parse("now") pickle_dumps = pickle.dumps(now) pickle_loads = pickle.loads(pickle_dumps) self.assertIsInstance(pickle_loads, datetime) - def test_unpickling_parsed_object_with_tz(self): + def test_unpickling_parsed_object_with_tz(self) -> None: now_in_utc = parse("now in UTC") pickle_dumps = pickle.dumps(now_in_utc) pickle_loads = pickle.loads(pickle_dumps) diff --git a/tests/test_search.py b/tests/test_search.py index 365925c8e..0a6bcfbf2 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1,5 +1,6 @@ import datetime from datetime import timedelta +from typing import Any import pytz from parameterized import param, parameterized @@ -16,19 +17,21 @@ class TestTranslateSearch(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() self.search_with_detection = DateSearchWithDetection() self.exact_language_search = self.search_with_detection.search - def run_search_dates_function_invalid_languages(self, text, languages, error_type): + def run_search_dates_function_invalid_languages( + self, text: str, languages: object, error_type: type[Exception] + ) -> None: try: - search_dates(text=text, languages=languages) + search_dates(text=text, languages=languages) # type: ignore[arg-type] except Exception as error: self.error = error self.assertIsInstance(self.error, error_type) - def check_error_message(self, message): + def check_error_message(self, message: str) -> None: self.assertEqual(str(self.error), message) @parameterized.expand( @@ -202,7 +205,7 @@ def check_error_message(self, message): param("sv", "fredag, 03 september 2014"), ] ) - def test_search_date_string(self, shortname, datetime_string): + def test_search_date_string(self, shortname: str, datetime_string: str) -> None: result = self.exact_language_search.search( shortname, datetime_string, settings=Settings() )[1][0] @@ -561,7 +564,14 @@ def test_search_date_string(self, shortname, datetime_string): ] ) @apply_settings - def test_search_and_parse(self, shortname, string, expected, settings=None): + def test_search_and_parse( + self, + shortname: str, + string: str, + expected: list[tuple[str, datetime.datetime]], + settings: Settings | dict[str, Any] | None = None, + ) -> None: + assert isinstance(settings, Settings) result = self.exact_language_search.search_parse( shortname, string, settings=settings ) @@ -723,7 +733,14 @@ def test_search_and_parse(self, shortname, string, expected, settings=None): ] ) @apply_settings - def test_relative_base_setting(self, shortname, string, expected, settings=None): + def test_relative_base_setting( + self, + shortname: str, + string: str, + expected: list[tuple[str, datetime.datetime]], + settings: Settings | dict[str, Any] | None = None, + ) -> None: + assert isinstance(settings, Settings) result = self.exact_language_search.search_parse( shortname, string, settings=settings ) @@ -807,7 +824,14 @@ def test_relative_base_setting(self, shortname, string, expected, settings=None) ] ) @apply_settings - def test_splitting_of_not_parsed(self, shortname, string, expected, settings=None): + def test_splitting_of_not_parsed( + self, + shortname: str, + string: str, + expected: list[tuple[str, datetime.datetime]], + settings: Settings | dict[str, Any] | None = None, + ) -> None: + assert isinstance(settings, Settings) result = self.exact_language_search.search_parse( shortname, string, settings=settings ) @@ -974,7 +998,7 @@ def test_splitting_of_not_parsed(self, shortname, string, expected, settings=Non param("en", "2007"), ] ) - def test_detection(self, shortname, text): + def test_detection(self, shortname: str, text: str) -> None: result = self.search_with_detection.detect_language(text, languages=None) self.assertEqual(result, shortname) @@ -1045,7 +1069,13 @@ def test_detection(self, shortname, text): ), ] ) - def test_date_search_function(self, text, languages, settings, expected): + def test_date_search_function( + self, + text: str, + languages: list[str] | None, + settings: dict[str, Any] | None, + expected: list[tuple[str, datetime.datetime]] | None, + ) -> None: result = search_dates(text, languages=languages, settings=settings) self.assertEqual(result, expected) @@ -1120,8 +1150,11 @@ def test_date_search_function(self, text, languages, settings, expected): ] ) def test_search_dates_with_a_relative_expression_next_to_a_date( - self, text, languages, expected - ): + self, + text: str, + languages: list[str], + expected: list[tuple[str, datetime.datetime]], + ) -> None: result = search_dates( text, languages=languages, settings={"RELATIVE_BASE": relative_base} ) @@ -1182,8 +1215,11 @@ def test_search_dates_with_a_relative_expression_next_to_a_date( ] ) def test_search_dates_with_a_relative_expression_reads_its_direction( - self, text, languages, expected - ): + self, + text: str, + languages: list[str], + expected: list[tuple[str, datetime.datetime]], + ) -> None: result = search_dates( text, languages=languages, settings={"RELATIVE_BASE": relative_base} ) @@ -1212,8 +1248,12 @@ def test_search_dates_with_a_relative_expression_reads_its_direction( ] ) def test_search_dates_returning_detected_languages_if_requested( - self, text, add_detected_language, expected - ): + self, + text: str, + add_detected_language: bool, + expected: list[tuple[str, datetime.datetime]] + | list[tuple[str, datetime.datetime, str]], + ) -> None: result = search_dates(text, add_detected_language=add_detected_language) self.assertEqual(result, expected) @@ -1222,7 +1262,9 @@ def test_search_dates_returning_detected_languages_if_requested( param(text="19 марта 2001", languages="wrong type: str instead of list"), ] ) - def test_date_search_function_invalid_languages_type(self, text, languages): + def test_date_search_function_invalid_languages_type( + self, text: str, languages: str + ) -> None: self.run_search_dates_function_invalid_languages( text=text, languages=languages, error_type=TypeError ) @@ -1235,13 +1277,15 @@ def test_date_search_function_invalid_languages_type(self, text, languages): param(text="19 марта 2001", languages=["unknown language code"]), ] ) - def test_date_search_function_invalid_language_code(self, text, languages): + def test_date_search_function_invalid_language_code( + self, text: str, languages: list[str] + ) -> None: self.run_search_dates_function_invalid_languages( text=text, languages=languages, error_type=ValueError ) self.check_error_message("Unknown language(s): 'unknown language code'") - def test_search_dates_with_prepositions(self): + def test_search_dates_with_prepositions(self) -> None: """Test `search_dates` for parsing Russian date ranges with prepositions and language detection.""" result = search_dates( "Сервис будет недоступен с 12 января по 30 апреля.", @@ -1350,8 +1394,13 @@ def test_search_dates_with_prepositions(self): ] ) def test_search_dates_multi_word_expression( - self, text, expected_text, expected_day, expected_month, description - ): + self, + text: str, + expected_text: str, + expected_day: int, + expected_month: int, + description: str, + ) -> None: """Test parsing of multi-word date expressions in Russian.""" result = search_dates(text, languages=["ru"]) expected = [ @@ -1440,7 +1489,13 @@ def test_search_dates_multi_word_expression( ), ] ) - def test_search_dates_time_span(self, expression, start, end, settings=None): + def test_search_dates_time_span( + self, + expression: str, + start: datetime.datetime, + end: datetime.datetime, + settings: dict[str, Any] | None = None, + ) -> None: result = search_dates( "messages received " + expression, languages=["en"], @@ -1450,12 +1505,13 @@ def test_search_dates_time_span(self, expression, start, end, settings=None): **(settings or {}), }, ) + assert result is not None self.assertEqual( [item for item in result if item[0].startswith(expression + " (")], [(expression + " (start)", start), (expression + " (end)", end)], ) - def test_search_dates_time_span_without_a_span_expression(self): + def test_search_dates_time_span_without_a_span_expression(self) -> None: result = search_dates( "messages received yesterday", languages=["en"], @@ -1466,7 +1522,7 @@ def test_search_dates_time_span_without_a_span_expression(self): ) self.assertEqual(result, [("yesterday", datetime.datetime(2025, 2, 17, 12, 0))]) - def test_search_dates_time_span_disabled_by_default(self): + def test_search_dates_time_span_disabled_by_default(self) -> None: result = search_dates( "messages received for the past month", languages=["en"], @@ -1476,7 +1532,7 @@ def test_search_dates_time_span_disabled_by_default(self): class TestNgramSearch(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() self.search_with_detection = DateSearchWithDetection() @@ -1524,14 +1580,16 @@ def setUp(self): ), ] ) - def test_ngram_search(self, shortname, text, expected): + def test_ngram_search( + self, shortname: str, text: str, expected: list[tuple[str, datetime.datetime]] + ) -> None: result = self.search_with_detection.search_dates( text, languages=[shortname], strategy="ngram" ) self.assertEqual(result["Language"], shortname) self.assertEqual(result["Dates"], expected) - def test_ngram_search_with_relative_base(self): + def test_ngram_search_with_relative_base(self) -> None: result = self.search_with_detection.search_dates( "posted 10 minutes ago", languages=["en"], @@ -1543,7 +1601,7 @@ def test_ngram_search_with_relative_base(self): [("10 minutes ago", datetime.datetime(2020, 1, 1, 11, 50))], ) - def test_ngram_search_returns_time_spans(self): + def test_ngram_search_returns_time_spans(self) -> None: result = self.search_with_detection.search_dates( "messages received for the past week", languages=["en"], @@ -1561,13 +1619,13 @@ def test_ngram_search_returns_time_spans(self): ], ) - def test_search_dates_with_ngram_strategy(self): + def test_search_dates_with_ngram_strategy(self) -> None: result = search_dates( "launched on 4 October 1957", languages=["en"], strategy="ngram" ) self.assertEqual(result, [("4 October 1957", datetime.datetime(1957, 10, 4))]) - def test_search_dates_with_ngram_strategy_and_detected_language(self): + def test_search_dates_with_ngram_strategy_and_detected_language(self) -> None: result = search_dates( "launched on 4 October 1957", languages=["en"], @@ -1578,13 +1636,13 @@ def test_search_dates_with_ngram_strategy_and_detected_language(self): result, [("4 October 1957", datetime.datetime(1957, 10, 4), "en")] ) - def test_search_dates_ngram_strategy_returns_none_when_no_dates_found(self): + def test_search_dates_ngram_strategy_returns_none_when_no_dates_found(self) -> None: self.assertIsNone( search_dates( "Hello world nothing here at all", languages=["en"], strategy="ngram" ) ) - def test_unknown_strategy_raises_error(self): + def test_unknown_strategy_raises_error(self) -> None: with self.assertRaisesRegex(ValueError, "strategy must be"): search_dates("4 October 1957", languages=["en"], strategy="unknown") diff --git a/tests/test_settings.py b/tests/test_settings.py index 605e88ad2..af82f4ef7 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -1,24 +1,25 @@ from datetime import datetime, tzinfo +from typing import Any import pytest from parameterized import param, parameterized from dateparser import DateDataParser, parse -from dateparser.conf import SettingValidationError, apply_settings, settings +from dateparser.conf import Settings, SettingValidationError, apply_settings, settings from tests import BaseTestCase -def test_function(settings=None): +def test_function(settings: object = None) -> object: return settings class TimeZoneSettingsTest(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.given_ds = NotImplemented - self.result = NotImplemented + self.given_ds: str = NotImplemented + self.result: datetime | None = NotImplemented self.timezone = NotImplemented - self.confs = NotImplemented + self.confs: Settings = NotImplemented @parameterized.expand( [ @@ -32,7 +33,7 @@ def setUp(self): param("12 Feb 2015 8:30 PM ACT", datetime(2015, 2, 12, 20, 30), "ACT"), ] ) - def test_should_return_and_assert_tz(self, ds, dt, tz): + def test_should_return_and_assert_tz(self, ds: str, dt: datetime, tz: str) -> None: self.given(ds) self.given_configurations({}) self.when_date_is_parsed() @@ -48,7 +49,9 @@ def test_should_return_and_assert_tz(self, ds, dt, tz): param("12 Feb 2015 8:30 PM", datetime(2015, 2, 12, 20, 30), ""), ] ) - def test_only_return_explicit_timezone(self, ds, dt, tz): + def test_only_return_explicit_timezone( + self, ds: str, dt: datetime, tz: str + ) -> None: self.given(ds) self.given_configurations({}) self.when_date_is_parsed() @@ -79,53 +82,60 @@ def test_only_return_explicit_timezone(self, ds, dt, tz): ), ] ) - def test_should_return_naive_if_RETURN_AS_TIMEZONE_AWARE_IS_FALSE(self, ds, dt): + def test_should_return_naive_if_RETURN_AS_TIMEZONE_AWARE_IS_FALSE( + self, ds: str, dt: datetime + ) -> None: self.given(ds) self.given_configurations({"RETURN_AS_TIMEZONE_AWARE": False}) self.when_date_is_parsed() self.then_date_is(dt) self.then_date_is_not_tz_aware() - def then_timezone_is(self, tzname): - self.assertEqual(self.result.tzinfo.tzname(""), tzname) + def then_timezone_is(self, tzname: str) -> None: + assert self.result is not None + assert self.result.tzinfo is not None + self.assertEqual(self.result.tzinfo.tzname(None), tzname) - def given(self, ds): + def given(self, ds: str) -> None: self.given_ds = ds - def given_configurations(self, confs): + def given_configurations(self, confs: dict[str, Any]) -> None: if "TIMEZONE" not in confs: confs.update({"TIMEZONE": "local"}) self.confs = settings.replace(**confs) - def when_date_is_parsed(self): + def when_date_is_parsed(self) -> None: self.result = parse(self.given_ds, settings=(self.confs or {})) - def then_date_is_tz_aware(self): + def then_date_is_tz_aware(self) -> None: + assert self.result is not None self.assertIsInstance(self.result.tzinfo, tzinfo) - def then_date_is_not_tz_aware(self): + def then_date_is_not_tz_aware(self) -> None: + assert self.result is not None self.assertIsNone(self.result.tzinfo) - def then_date_is(self, date): + def then_date_is(self, date: datetime) -> None: + assert self.result is not None dtc = self.result.replace(tzinfo=None) self.assertEqual(dtc, date) class SettingsTest(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() self.default_settings = settings def test_apply_settings_should_return_default_settings_when_no_settings_are_supplied_to_the_decorated_function( self, - ): + ) -> None: test_func = apply_settings(test_function) self.assertEqual(test_func(), self.default_settings) def test_apply_settings_should_return_non_default_settings_when_settings_are_supplied_to_the_decorated_function( self, - ): + ) -> None: test_func = apply_settings(test_function) self.assertNotEqual( test_func(settings={"PREFER_DATES_FROM": "past"}), self.default_settings @@ -133,7 +143,7 @@ def test_apply_settings_should_return_non_default_settings_when_settings_are_sup def test_apply_settings_shouldnt_create_new_settings_when_same_settings_are_supplied_to_the_decorated_function_more_than_once( self, - ): + ) -> None: test_func = apply_settings(test_function) settings_once = test_func(settings={"PREFER_DATES_FROM": "past"}) settings_twice = test_func(settings={"PREFER_DATES_FROM": "past"}) @@ -141,7 +151,7 @@ def test_apply_settings_shouldnt_create_new_settings_when_same_settings_are_supp def test_apply_settings_should_return_default_settings_when_called_with_no_settings_after_once_called_with_settings_supplied_to_the_decorated_function( self, - ): + ) -> None: test_func = apply_settings(test_function) settings_once = test_func(settings={"PREFER_DATES_FROM": "past"}) settings_twice = test_func() @@ -150,10 +160,10 @@ def test_apply_settings_should_return_default_settings_when_called_with_no_setti class InvalidSettingsTest(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - def test_error_is_raised_when_none_is_passed_in_settings(self): + def test_error_is_raised_when_none_is_passed_in_settings(self) -> None: test_func = apply_settings(test_function) with self.assertRaisesRegex(TypeError, r"Invalid.*None\}"): test_func(settings={"PREFER_DATES_FROM": None}) @@ -164,7 +174,7 @@ def test_error_is_raised_when_none_is_passed_in_settings(self): with self.assertRaisesRegex(TypeError, r"Invalid.*None\}"): test_func(settings={"TO_TIMEZONE": None}) - def test_error_is_raised_for_invalid_type_settings(self): + def test_error_is_raised_for_invalid_type_settings(self) -> None: test_func = apply_settings(test_function) try: test_func(settings=["current_period", False, "current"]) @@ -175,7 +185,7 @@ def test_error_is_raised_for_invalid_type_settings(self): ["settings can only be either dict or instance of Settings class"], ) - def test_check_settings_wrong_setting_name(self): + def test_check_settings_wrong_setting_name(self) -> None: with self.assertRaisesRegex( SettingValidationError, r".* is not a valid setting" ): @@ -208,7 +218,9 @@ def test_check_settings_wrong_setting_name(self): param("LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD", "1", "", 0.5), ] ) - def test_check_settings(self, setting, wrong_type, wrong_value, valid_value): + def test_check_settings( + self, setting: str, wrong_type: object, wrong_value: str, valid_value: object + ) -> None: with self.assertRaisesRegex( SettingValidationError, rf'"{setting}" must be .*, not "{type(wrong_type).__name__}".', @@ -227,7 +239,7 @@ def test_check_settings(self, setting, wrong_type, wrong_value, valid_value): # check that a valid value doesn't raise an error assert DateDataParser(settings={setting: valid_value}) - def test_check_settings_extra_check_require_parts(self): + def test_check_settings_extra_check_require_parts(self) -> None: with self.assertRaisesRegex( SettingValidationError, r'"REQUIRE_PARTS" setting contains invalid values: time', @@ -239,7 +251,7 @@ def test_check_settings_extra_check_require_parts(self): ): DateDataParser(settings={"REQUIRE_PARTS": ["month", "day", "month"]}) - def test_check_settings_extra_check_parsers(self): + def test_check_settings_extra_check_parsers(self) -> None: with self.assertRaisesRegex( SettingValidationError, r'Found unknown parsers in the "PARSERS" setting: no-spaces', @@ -254,7 +266,7 @@ def test_check_settings_extra_check_parsers(self): settings={"PARSERS": ["absolute-time", "timestamp", "absolute-time"]} ) - def test_check_settings_extra_check_confidence_threshold(self): + def test_check_settings_extra_check_confidence_threshold(self) -> None: with self.assertRaisesRegex( SettingValidationError, r"1.1 is not a valid value for " @@ -263,7 +275,7 @@ def test_check_settings_extra_check_confidence_threshold(self): ): DateDataParser(settings={"LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD": 1.1}) - def test_check_settings_extra_check_default_languages(self): + def test_check_settings_extra_check_default_languages(self) -> None: with self.assertRaisesRegex( SettingValidationError, "Found invalid languages in the 'DEFAULT_LANGUAGES' setting: 'abcd'", @@ -281,7 +293,7 @@ def test_check_settings_extra_check_default_languages(self): ("100000", datetime(1900, 1, 1, 10, 0)), ], ) -def test_no_spaces_strict_parsing(date_string, expected_result): +def test_no_spaces_strict_parsing(date_string: str, expected_result: datetime) -> None: parser = DateDataParser( settings={"PARSERS": ["no-spaces-time"], "STRICT_PARSING": False} ) @@ -293,13 +305,13 @@ def test_no_spaces_strict_parsing(date_string, expected_result): assert parser.get_date_data(date_string)["date_obj"] is None -def detect_languages(text, confidence_threshold): +def detect_languages(text: str, confidence_threshold: float) -> list[str]: if confidence_threshold > 0.5: return ["en"] return ["fr"] -def test_confidence_threshold_setting_is_applied(): +def test_confidence_threshold_setting_is_applied() -> None: ddp = DateDataParser( detect_languages_function=detect_languages, settings={"LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD": 0.6}, diff --git a/tests/test_thread_safety.py b/tests/test_thread_safety.py index 2d23e6538..ab2620fff 100644 --- a/tests/test_thread_safety.py +++ b/tests/test_thread_safety.py @@ -2,16 +2,23 @@ import sys import threading import unittest +from collections.abc import Callable, Iterable from concurrent.futures import ThreadPoolExecutor +from datetime import datetime +from typing import Literal, TypeVar import dateparser.data.date_translation_data.en as en_data from dateparser.conf import settings as base_settings -from dateparser.date import DateDataParser +from dateparser.date import DateData, DateDataParser from dateparser.languages.dictionary import Dictionary +from dateparser.languages.locale import Locale from dateparser.search import search_dates from dateparser.search.search import DateSearchWithDetection, _ExactLanguageSearch from tests import BaseTestCase +_T = TypeVar("_T") +_R = TypeVar("_R") + class TestThreadSafety(BaseTestCase): """Regression tests for thread-safety issues. @@ -21,7 +28,7 @@ class TestThreadSafety(BaseTestCase): https://github.com/scrapinghub/dateparser/issues/1369. """ - def setUp(self): + def setUp(self) -> None: super().setUp() # A tiny thread-switch interval makes the interpreter yield between # almost every bytecode, so the narrow check-then-read windows that @@ -30,16 +37,18 @@ def setUp(self): self._switch_interval = sys.getswitchinterval() sys.setswitchinterval(1e-7) - def tearDown(self): + def tearDown(self) -> None: sys.setswitchinterval(self._switch_interval) super().tearDown() - def _run_concurrently(self, func, args_list, workers=32): + def _run_concurrently( + self, func: Callable[[_T], _R], args_list: Iterable[_T], workers: int = 32 + ) -> list[_R]: with ThreadPoolExecutor(max_workers=workers) as executor: futures = [executor.submit(func, arg) for arg in args_list] return [future.result() for future in futures] - def test_dictionary_cache_eviction_concurrently(self): + def test_dictionary_cache_eviction_concurrently(self) -> None: # Issue #1291: concurrent population/eviction of the size-limited # dictionary caches raised intermittent ``KeyError`` because the cache # was read after a concurrent eviction could remove the entry. @@ -51,7 +60,7 @@ def test_dictionary_cache_eviction_concurrently(self): for i in range(24) ] - def hammer(index): + def hammer(index: int) -> bool: dictionary = dictionaries[index % len(dictionaries)] for _ in range(50): dictionary.split("2 days ago") @@ -61,7 +70,7 @@ def hammer(index): results = self._run_concurrently(hammer, range(24)) self.assertTrue(all(results)) - def test_settings_date_order_not_mutated_while_parsing(self): + def test_settings_date_order_not_mutated_while_parsing(self) -> None: # The absolute-time parser used to assign the locale-specific date order # onto the shared Settings object in place (restoring it afterwards), so # a concurrent parse could observe and use a foreign DATE_ORDER. Here the @@ -73,14 +82,14 @@ def test_settings_date_order_not_mutated_while_parsing(self): baseline = parser._settings.DATE_ORDER self.assertEqual(baseline, "MDY") - observed = set() + observed: set[str] = set() stop = threading.Event() - def watch(): + def watch() -> None: while not stop.is_set(): observed.add(parser._settings.DATE_ORDER) - def parse(i): + def parse(i: int) -> DateData: return parser.get_date_data( ["02.03.2014", "2014-03-02", "11.12.2013"][i % 3] ) @@ -95,7 +104,7 @@ def parse(i): self.assertEqual(observed, {baseline}) - def test_search_does_not_mutate_shared_relative_base(self): + def test_search_does_not_mutate_shared_relative_base(self) -> None: # search_dates used to assign RELATIVE_BASE onto the shared default # Settings while resolving relative dates, polluting it for concurrent # parses/searches. @@ -105,14 +114,16 @@ def test_search_does_not_mutate_shared_relative_base(self): ) baseline = base_settings.RELATIVE_BASE - observed = set() + observed: set[datetime | Literal[False]] = set() stop = threading.Event() - def watch(): + def watch() -> None: while not stop.is_set(): observed.add(base_settings.RELATIVE_BASE) - def search(i): + def search( + i: int, + ) -> list[tuple[str, datetime]] | list[tuple[str, datetime, str | None]] | None: return search_dates(text, languages=["ru"]) watcher = threading.Thread(target=watch) @@ -126,7 +137,7 @@ def search(i): self.assertTrue(all(result is not None for result in results)) self.assertEqual(observed, {baseline}) - def test_detect_language_does_not_leave_narrowed_detector_on_instance(self): + def test_detect_language_does_not_leave_narrowed_detector_on_instance(self) -> None: # Issue #1369 site 1: detect_language used to stash a FullTextLanguageDetector # on the process-wide singleton. _best_language narrows detector.languages # in place, so a concurrent search_dates can load another call's already- @@ -145,7 +156,7 @@ def test_detect_language_does_not_leave_narrowed_detector_on_instance(self): f"(issue #1369). leftover={leftover!r}", ) - def test_concurrent_search_dates_does_not_share_language_detector(self): + def test_concurrent_search_dates_does_not_share_language_detector(self) -> None: # Issue #1369 site 1: the store/load gap is a few bytecodes, so park each # thread immediately after it stores the detector. Sequential search_dates # is not a valid RED for this race. @@ -156,18 +167,18 @@ def test_concurrent_search_dates_does_not_share_language_detector(self): self.assertIsNotNone(sequential_ru) self.assertIsNotNone(sequential_en) - slot = {} + slot: dict[str, object] = {} barrier = threading.Barrier(2, timeout=10) - def _get(self): + def _get(self: DateSearchWithDetection) -> object: return slot["v"] - def _set(self, value): + def _set(self: DateSearchWithDetection, value: object) -> None: slot["v"] = value with contextlib.suppress(threading.BrokenBarrierError): barrier.wait() - DateSearchWithDetection.language_detector = property(_get, _set) + DateSearchWithDetection.language_detector = property(_get, _set) # type: ignore[attr-defined] try: with ThreadPoolExecutor(max_workers=2) as executor: ru, en = executor.map( @@ -175,12 +186,12 @@ def _set(self, value): [(ru_text, "ru"), (en_text, "en")], ) finally: - del DateSearchWithDetection.language_detector + del DateSearchWithDetection.language_detector # type: ignore[attr-defined] self.assertEqual(ru, sequential_ru) self.assertEqual(en, sequential_en) - def test_concurrent_search_dates_does_not_share_locale_slot(self): + def test_concurrent_search_dates_does_not_share_locale_slot(self) -> None: # Issue #1369 site 2: _ExactLanguageSearch.self.language is a 1-slot cache # on the same singleton. Park after get_current_language so a store from # the other thread lands before translate_search. @@ -194,13 +205,13 @@ def test_concurrent_search_dates_does_not_share_locale_slot(self): original = _ExactLanguageSearch.get_current_language barrier = threading.Barrier(2, timeout=10) - def patched(self, shortname): + def patched(self: _ExactLanguageSearch, shortname: str) -> Locale: result = original(self, shortname) with contextlib.suppress(threading.BrokenBarrierError): barrier.wait() return result - _ExactLanguageSearch.get_current_language = patched + _ExactLanguageSearch.get_current_language = patched # type: ignore[method-assign] try: with ThreadPoolExecutor(max_workers=2) as executor: ru, en = executor.map( @@ -208,7 +219,7 @@ def patched(self, shortname): [(ru_text, "ru"), (en_text, "en")], ) finally: - _ExactLanguageSearch.get_current_language = original + _ExactLanguageSearch.get_current_language = original # type: ignore[method-assign] self.assertEqual(ru, sequential_ru) self.assertEqual(en, sequential_en) diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index beadaa4d3..a09e2664a 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -1,5 +1,7 @@ import datetime as dt from datetime import datetime, timedelta +from types import ModuleType +from typing import ClassVar from unittest import SkipTest from unittest.mock import Mock, patch @@ -20,11 +22,11 @@ class TestTZPopping(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.initial_string = self.datetime_string = self.timezone_offset = ( - NotImplemented - ) + self.initial_string: str = NotImplemented + self.datetime_string: str = NotImplemented + self.timezone_offset: timedelta | None = NotImplemented @parameterized.expand( [ @@ -70,7 +72,9 @@ def setUp(self): param("16. srpna 2021 9:59:44 VEČ", 2), ] ) - def test_extracting_valid_offset(self, initial_string, expected_offset): + def test_extracting_valid_offset( + self, initial_string: str, expected_offset: float | None + ) -> None: self.given_string(initial_string) self.when_offset_popped_from_string() self.then_offset_is(expected_offset) @@ -100,32 +104,34 @@ def test_extracting_valid_offset(self, initial_string, expected_offset): param("2019-09-28WIB19:17:34+07:00", "2019-09-28 19:17:34"), ] ) - def test_timezone_deleted_from_string(self, initial_string, result_string): + def test_timezone_deleted_from_string( + self, initial_string: str, result_string: str + ) -> None: self.given_string(initial_string) self.when_offset_popped_from_string() self.then_string_modified_to(result_string) - def test_string_not_changed_if_no_timezone(self): + def test_string_not_changed_if_no_timezone(self) -> None: self.given_string("15 May 2004") self.when_offset_popped_from_string() self.then_string_modified_to("15 May 2004") - def given_string(self, string_): + def given_string(self, string_: str) -> None: self.initial_string = string_ - def when_offset_popped_from_string(self): + def when_offset_popped_from_string(self) -> None: self.datetime_string, timezone_offset = pop_tz_offset_from_string( self.initial_string ) - if timezone_offset: - self.timezone_offset = timezone_offset.utcoffset("") + if timezone_offset is not None: + self.timezone_offset = timezone_offset.utcoffset(None) else: self.timezone_offset = timezone_offset - def then_string_modified_to(self, expected_string): + def then_string_modified_to(self, expected_string: str) -> None: self.assertEqual(expected_string, self.datetime_string) - def then_offset_is(self, expected_offset): + def then_offset_is(self, expected_offset: float | None) -> None: delta = ( timedelta(hours=expected_offset) if expected_offset is not None else None ) @@ -143,16 +149,18 @@ class TestUnicodeDashOffsets(BaseTestCase): param("jan 15th UTC+06:00", 6), ] ) - def test_parses_dash_look_alike_offsets(self, date_string, expected_offset_hours): + def test_parses_dash_look_alike_offsets( + self, date_string: str, expected_offset_hours: int + ) -> None: parsed = parse(date_string) - self.assertIsNotNone(parsed) + assert parsed is not None self.assertEqual(parsed.utcoffset(), timedelta(hours=expected_offset_hours)) class TestLocalTZOffset(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.timezone_offset = NotImplemented + self.timezone_offset: timedelta = NotImplemented @parameterized.expand( [ @@ -163,7 +171,9 @@ def setUp(self): param(utc="2014-10-18 17:41", local="2014-10-18 17:41", offset=0), ] ) - def test_timezone_offset_calculation(self, utc, local, offset): + def test_timezone_offset_calculation( + self, utc: str, local: str, offset: float + ) -> None: try: self.given_time(utc, local) except OverflowError: @@ -171,10 +181,10 @@ def test_timezone_offset_calculation(self, utc, local, offset): self.when_offset_popped_from_string() self.then_offset_is(offset) - def when_offset_popped_from_string(self): + def when_offset_popped_from_string(self) -> None: self.timezone_offset = get_local_tz_offset() - def then_offset_is(self, expected_offset): + def then_offset_is(self, expected_offset: float | None) -> None: delta = ( timedelta(seconds=3600 * expected_offset) if expected_offset is not None @@ -182,8 +192,8 @@ def then_offset_is(self, expected_offset): ) self.assertEqual(delta, self.timezone_offset) - def given_time(self, utc_dt_string, local_dt_string): - datetime_cls = dateparser.timezone_parser.datetime + def given_time(self, utc_dt_string: str, local_dt_string: str) -> None: + datetime_cls = dateparser.timezone_parser.datetime # type: ignore[attr-defined] if not isinstance(datetime_cls, Mock): datetime_cls = Mock(wraps=datetime) utc_dt_obj = datetime.strptime(utc_dt_string, "%Y-%m-%d %H:%M").replace( @@ -191,7 +201,7 @@ def given_time(self, utc_dt_string, local_dt_string): ) local_dt_obj = datetime.strptime(local_dt_string, "%Y-%m-%d %H:%M") - def _dt_now(tz=None): + def _dt_now(tz: dt.tzinfo | None = None) -> datetime: if tz == dt.timezone.utc: return utc_dt_obj return local_dt_obj @@ -201,11 +211,11 @@ def _dt_now(tz=None): class TestTimeZoneConversion(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.settings = {} + self.settings: dict[str, str] = {} self.parser = parse - self.result = NotImplemented + self.result: datetime | None = NotImplemented @parameterized.expand( [ @@ -223,27 +233,29 @@ def setUp(self): ), ] ) - def test_timezone_conversion(self, datestring, from_tz, to_tz, expected): + def test_timezone_conversion( + self, datestring: str, from_tz: str, to_tz: str, expected: datetime + ) -> None: self.given_from_timezone(from_tz) self.given_to_timezone(to_tz) self.when_date_is_parsed(datestring) self.then_date_is(expected) - def given_from_timezone(self, timezone): + def given_from_timezone(self, timezone: str) -> None: self.settings["TIMEZONE"] = timezone - def given_to_timezone(self, timezone): + def given_to_timezone(self, timezone: str) -> None: self.settings["TO_TIMEZONE"] = timezone - def when_date_is_parsed(self, datestring): + def when_date_is_parsed(self, datestring: str) -> None: self.result = self.parser(datestring, settings=self.settings) - def then_date_is(self, date): + def then_date_is(self, date: datetime) -> None: self.assertEqual(date, self.result) class TestStaticTzInfo(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() @parameterized.expand( @@ -253,20 +265,24 @@ def setUp(self): param(given_date=datetime(2000, 2, 20, tzinfo=timezone("Pacific/Samoa"))), ] ) - def test_localize_raises_error_if_date_has_tzinfo(self, given_date): + def test_localize_raises_error_if_date_has_tzinfo( + self, given_date: datetime + ) -> None: self.timezone_info = StaticTzInfo("UTC\\+00:00", timedelta(0)) self.when_date_is_localized(given_date) self.then_error_was_raised( ValueError, ["Not naive datetime (tzinfo is already set)"] ) - def when_date_is_localized(self, given_date): + def when_date_is_localized(self, given_date: datetime) -> None: try: self.localized_date = self.timezone_info.localize(given_date) except Exception as error: self.error = error - def then_localized_date_is(self, expected_date, expected_tzname): + def then_localized_date_is( + self, expected_date: datetime, expected_tzname: str + ) -> None: self.assertEqual(self.localized_date.date(), expected_date.date()) self.assertEqual(self.localized_date.tzname(), expected_tzname) @@ -294,10 +310,10 @@ class TestIsTimezoneToken(BaseTestCase): param(token=" ", expected=False), ] ) - def test_is_timezone_token(self, token, expected): + def test_is_timezone_token(self, token: str, expected: bool) -> None: self.assertEqual(expected, is_timezone_token(token)) - def test_anchored_match_unlike_word_is_tz(self): + def test_anchored_match_unlike_word_is_tz(self) -> None: # word_is_tz prefix-matches ("ACT" of "ACTUALISÉ"); is_timezone_token is # anchored, so it does not — this is what keeps a noise word from # surviving as a timezone when edges are stripped. @@ -332,16 +348,20 @@ class TestTzDatabasePreference(BaseTestCase): "CST": {-21600, -18000, 28800}, } + checker: ClassVar[ModuleType] + tz_database: ClassVar[dict[str, set[int]]] + @classmethod - def setUpClass(cls): + def setUpClass(cls) -> None: super().setUpClass() cls.checker = tz_abbreviation_conflicts # Sampling every zone takes a moment, so it is done once for the class. cls.tz_database = tz_abbreviation_conflicts.tz_database_abbreviations() - def offset_of(self, date_string): + def offset_of(self, date_string: str) -> timedelta: _, timezone_offset = pop_tz_offset_from_string(date_string) self.assertIsNotNone(timezone_offset, f"no timezone found in {date_string!r}") + assert timezone_offset is not None return timezone_offset.utcoffset(None) @parameterized.expand( @@ -355,8 +375,8 @@ def offset_of(self, date_string): ] ) def test_unambiguous_abbreviation_uses_tz_database_offset( - self, date_string, expected_offset, abbreviation - ): + self, date_string: str, expected_offset: float, abbreviation: str + ) -> None: self.assertEqual(timedelta(hours=expected_offset), self.offset_of(date_string)) # And the tz database really does name only that one offset. self.assertEqual({int(expected_offset * 3600)}, self.tz_database[abbreviation]) @@ -368,10 +388,11 @@ def test_unambiguous_abbreviation_uses_tz_database_offset( ] ) def test_unambiguous_abbreviation_parses_end_to_end( - self, date_string, expected_offset, abbreviation - ): + self, date_string: str, expected_offset: float, abbreviation: str + ) -> None: # The #1321 report as a user would hit it, not just at the popping layer. parsed = parse(date_string, settings={"RETURN_AS_TIMEZONE_AWARE": True}) + assert parsed is not None self.assertEqual(timedelta(hours=expected_offset), parsed.utcoffset()) self.assertEqual(abbreviation, parsed.tzname()) @@ -388,8 +409,8 @@ def test_unambiguous_abbreviation_parses_end_to_end( ] ) def test_ambiguous_abbreviation_keeps_its_offset( - self, date_string, expected_offset - ): + self, date_string: str, expected_offset: float + ) -> None: # These keep the value dateparser has always used. The assertion below # holds whether or not the abbreviation stays ambiguous: what matters is # that the retained value is one a real zone uses, not an arbitrary one. @@ -397,7 +418,7 @@ def test_ambiguous_abbreviation_keeps_its_offset( abbreviation = date_string.rsplit(" ", 1)[1] self.assertIn(int(expected_offset * 3600), self.tz_database[abbreviation]) - def test_table_agrees_with_the_tz_database(self): + def test_table_agrees_with_the_tz_database(self) -> None: # The generalized check behind #1322: instead of asserting a fixed list # of abbreviations, ask the tz database about every abbreviation the two # tables share, so a regression on any of them is caught. @@ -410,18 +431,18 @@ def test_table_agrees_with_the_tz_database(self): conflicts = self.checker.find_conflicts(tz_database=self.tz_database) self.assertEqual([], conflicts, f"conflicts with the tz database: {conflicts}") - def test_report_runs_clean(self): + def test_report_runs_clean(self) -> None: # Exercises the module's entry point with its real defaults, which the # test above bypasses by passing the tz database in. self.assertEqual(0, self.checker.main()) - def test_reference_years_stay_in_settled_years(self): + def test_reference_years_stay_in_settled_years(self) -> None: # The tz database records future daylight-saving rules as predictions # that change between releases, so sampling them would tie the result to # the installed version rather than to real usage. self.assertLess(max(self.checker.REFERENCE_YEARS), datetime.now().year) - def test_pre_fix_offsets_are_reported_as_conflicts(self): + def test_pre_fix_offsets_are_reported_as_conflicts(self) -> None: # Reproduces the bug this change fixes, and keeps the whole-table check # from passing vacuously: the offsets shipped before #1322 are flagged. conflicts = self.checker.find_conflicts( @@ -436,7 +457,7 @@ def test_pre_fix_offsets_are_reported_as_conflicts(self): [tuple(conflict) for conflict in conflicts], ) - def test_offset_no_zone_uses_is_reported_even_when_ambiguous(self): + def test_offset_no_zone_uses_is_reported_even_when_ambiguous(self) -> None: # "CST" has several meanings, so none of them can be preferred, but +11 # is not one of them and is still worth reporting. (conflict,) = self.checker.find_conflicts( @@ -447,7 +468,7 @@ def test_offset_no_zone_uses_is_reported_even_when_ambiguous(self): self.assertNotIn(39600, conflict.tz_database_offsets) @parameterized.expand([param(-21600), param(28800)]) - def test_any_offset_a_zone_really_uses_is_accepted(self, offset): + def test_any_offset_a_zone_really_uses_is_accepted(self, offset: int) -> None: # Both US Central (-6) and China (+8) are legitimate readings of "CST". self.assertEqual( [], @@ -456,7 +477,7 @@ def test_any_offset_a_zone_really_uses_is_accepted(self, offset): ), ) - def test_abbreviations_outside_the_reference_window_are_ignored(self): + def test_abbreviations_outside_the_reference_window_are_ignored(self) -> None: # dateparser keeps abbreviations no zone is named after any more, such # as "AHST", so historical text still parses. The tz database says # nothing about them, so they are skipped rather than reported. @@ -468,14 +489,14 @@ def test_abbreviations_outside_the_reference_window_are_ignored(self): ), ) - def test_abbreviations_are_compared_case_insensitively(self): + def test_abbreviations_are_compared_case_insensitively(self) -> None: # dateparser matches abbreviations regardless of case, so the table's # "ChST" entry and the tz database's "ChST" are one abbreviation and # have to meet under the same key. self.assertIn("CHST", self.checker.static_tz_abbreviations()) self.assertIn("CHST", self.tz_database) - def test_numeric_zone_names_are_not_treated_as_abbreviations(self): + def test_numeric_zone_names_are_not_treated_as_abbreviations(self) -> None: # The tz database names zones that have no established abbreviation # after their offset, as in "+11" or "-0930". Those are offsets rather # than identities, and dateparser matches numeric offsets through its @@ -483,7 +504,7 @@ def test_numeric_zone_names_are_not_treated_as_abbreviations(self): self.assertEqual([], [name for name in self.tz_database if name[0] in "+-"]) self.assertIn("BST", self.tz_database) - def test_repeated_abbreviation_resolves_to_its_first_entry(self): + def test_repeated_abbreviation_resolves_to_its_first_entry(self) -> None: # "LMT" is listed four times with four different offsets. Only the first # can ever match, so that is the value the comparison has to use; # checking against all four would hide a wrong first entry. diff --git a/tests/test_utils.py b/tests/test_utils.py index a7d21c2a3..b5cda903c 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,15 +1,18 @@ import calendar import itertools +from collections.abc import Callable from datetime import datetime from unittest.mock import patch import pytest from parameterized import param, parameterized from pytz import UnknownTimeZoneError, utc +from pytz.tzinfo import BaseTzInfo import dateparser from dateparser.conf import settings from dateparser.search import search_dates +from dateparser.timezone_parser import StaticTzInfo from dateparser.utils import ( apply_timezone, apply_timezone_from_settings, @@ -25,29 +28,30 @@ class TestUtils(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - self.date_format = None - self.result = None + self.date_format: str | None = None + self.result: str | None = None - def test_patch_strptime_preserves_global_calendar(self): + def test_patch_strptime_preserves_global_calendar(self) -> None: before = vars(calendar).copy() patch_strptime() self.assertEqual(set(vars(calendar)), set(before)) for name, value in before.items(): self.assertIs(getattr(calendar, name), value, name) - def given_date_format(self, date_format): + def given_date_format(self, date_format: str) -> None: self.date_format = date_format - def when_date_separator_is_parsed(self): + def when_date_separator_is_parsed(self) -> None: + assert self.date_format is not None self.result = find_date_separator(self.date_format) - def then_date_separator_is(self, sep): + def then_date_separator_is(self, sep: str | None) -> None: self.assertEqual(self.result, sep) @staticmethod - def make_class_without_get_keys(): + def make_class_without_get_keys() -> type: class SomeClass: pass @@ -61,12 +65,12 @@ class SomeClass: ) ] ) - def test_separator_extraction(self, date_format, expected_sep): + def test_separator_extraction(self, date_format: str, expected_sep: str) -> None: self.given_date_format(date_format) self.when_date_separator_is_parsed() self.then_date_separator_is(expected_sep) - def test_separator_extraction_without_separator(self): + def test_separator_extraction_without_separator(self) -> None: self.given_date_format("%Y") self.when_date_separator_is_parsed() self.then_date_separator_is(None) @@ -78,8 +82,11 @@ def test_separator_extraction_without_separator(self): param(datetime(2015, 12, 12, tzinfo=utc), timezone="UTC", zone="UTC"), ] ) - def test_localize_timezone_function(self, date, timezone, zone): + def test_localize_timezone_function( + self, date: datetime, timezone: str, zone: str + ) -> None: tzaware_dt = localize_timezone(date, timezone) + assert isinstance(tzaware_dt.tzinfo, BaseTzInfo) self.assertEqual(tzaware_dt.tzinfo.zone, zone) @parameterized.expand( @@ -88,7 +95,9 @@ def test_localize_timezone_function(self, date, timezone, zone): param(datetime(2015, 12, 12), timezone="Asia/Karach"), ] ) - def test_localize_timezone_function_raise_error(self, date, timezone): + def test_localize_timezone_function_raise_error( + self, date: datetime, timezone: str + ) -> None: self.assertRaises(UnknownTimeZoneError, localize_timezone, date, timezone) @parameterized.expand( @@ -96,9 +105,12 @@ def test_localize_timezone_function_raise_error(self, date, timezone): param(datetime(2015, 12, 12), timezone="UTC+3", zone=r"UTC\+03:00"), ] ) - def test_localize_timezone_function_exception(self, date, timezone, zone): + def test_localize_timezone_function_exception( + self, date: datetime, timezone: str, zone: str + ) -> None: tzaware_dt = localize_timezone(date, timezone) - self.assertEqual(tzaware_dt.tzinfo._StaticTzInfo__name, zone) + assert isinstance(tzaware_dt.tzinfo, StaticTzInfo) + self.assertEqual(tzaware_dt.tzinfo.tzname(None), zone) @parameterized.expand( [ @@ -114,7 +126,9 @@ def test_localize_timezone_function_exception(self, date, timezone, zone): ), ] ) - def test_apply_timezone_function(self, date, timezone, expected): + def test_apply_timezone_function( + self, date: datetime, timezone: str, expected: datetime + ) -> None: result = apply_timezone(date, timezone) result = result.replace(tzinfo=None) self.assertEqual(expected, result) @@ -133,7 +147,9 @@ def test_apply_timezone_function(self, date, timezone, expected): ), ] ) - def test_apply_timezone_from_settings_function(self, date, timezone, expected): + def test_apply_timezone_from_settings_function( + self, date: datetime, timezone: str, expected: datetime + ) -> None: result = apply_timezone_from_settings( date, settings.replace(TO_TIMEZONE=timezone, TIMEZONE="UTC") ) @@ -146,7 +162,9 @@ def test_apply_timezone_from_settings_function(self, date, timezone, expected): ), ] ) - def test_apply_timezone_from_settings_function_none_settings(self, date, expected): + def test_apply_timezone_from_settings_function_none_settings( + self, date: datetime, expected: datetime + ) -> None: result = apply_timezone_from_settings(date, None) self.assertEqual(expected, result) @@ -160,13 +178,15 @@ def test_apply_timezone_from_settings_function_none_settings(self, date, expecte ), ] ) - def test_apply_timezone_from_settings_function_should_return_tz(self, date): + def test_apply_timezone_from_settings_function_should_return_tz( + self, date: datetime + ) -> None: result = apply_timezone_from_settings( date, settings.replace(RETURN_AS_TIMEZONE_AWARE=True) ) self.assertTrue(bool(result.tzinfo)) - def test_registry_when_get_keys_not_implemented(self): + def test_registry_when_get_keys_not_implemented(self) -> None: cl = self.make_class_without_get_keys() self.assertRaises(NotImplementedError, registry, cl) @@ -189,7 +209,9 @@ def test_registry_when_get_keys_not_implemented(self): param(2300, 12, 31), ] ) - def test_get_last_day_of_month(self, year, month, expected_last_day): + def test_get_last_day_of_month( + self, year: int, month: int, expected_last_day: int + ) -> None: assert get_last_day_of_month(year, month) == expected_last_day @@ -204,7 +226,7 @@ def test_get_last_day_of_month(self, year, month, expected_last_day): (0, -4), # even if this is not a valid year, it is the expected result ], ) -def test_get_previous_leap_year(year, expected_previous_leap_year): +def test_get_previous_leap_year(year: int, expected_previous_leap_year: int) -> None: assert get_previous_leap_year(year) == expected_previous_leap_year @@ -219,7 +241,7 @@ def test_get_previous_leap_year(year, expected_previous_leap_year): (0, 4), ], ) -def test_get_next_leap_year(year, expected_next_leap_year): +def test_get_next_leap_year(year: int, expected_next_leap_year: int) -> None: assert get_next_leap_year(year) == expected_next_leap_year @@ -232,7 +254,7 @@ def test_get_next_leap_year(year, expected_next_leap_year): lambda: search_dates("It was launched on 4 October 1957.", languages=["en"]), ], ) -def test_broken_local_timezone(parse): +def test_broken_local_timezone(parse: Callable[[], object]) -> None: with ( patch( "dateparser.utils.get_localzone", diff --git a/tests/test_utils_strptime.py b/tests/test_utils_strptime.py index a41fab8df..6edc58b1c 100644 --- a/tests/test_utils_strptime.py +++ b/tests/test_utils_strptime.py @@ -10,31 +10,33 @@ class TestStrptime(BaseTestCase): - def setUp(self): + def setUp(self) -> None: super().setUp() - def given_system_locale_is(self, locale_str): + def given_system_locale_is(self, locale_str: str) -> None: try: locale.setlocale(locale.LC_ALL, locale_str) except locale.Error: raise SkipTest(f"Locale {locale_str} is not installed") - def when_date_string_is_parsed(self, date_string, fmt): + def when_date_string_is_parsed(self, date_string: str, fmt: str) -> None: try: - self.result = strptime(date_string, fmt) + self.result: datetime | ValueError = strptime(date_string, fmt) except ValueError as e: self.result = e - def when_date_string_is_parsed_using_datetime_strptime(self, date_string, fmt): + def when_date_string_is_parsed_using_datetime_strptime( + self, date_string: str, fmt: str + ) -> None: try: self.result = datetime.strptime(date_string, fmt) except ValueError as e: self.result = e - def then_date_object_is(self, expected): + def then_date_object_is(self, expected: datetime) -> None: assert self.result == expected - def then_date_object_is_instance_of(self, expected): + def then_date_object_is_instance_of(self, expected: type[Exception]) -> None: assert isinstance(self.result, expected) @parameterized.expand( @@ -70,8 +72,8 @@ def then_date_object_is_instance_of(self, expected): ] ) def test_dates_with_months_are_parsed_if_locale_is_non_english( - self, date_string, fmt, expected - ): + self, date_string: str, fmt: str, expected: datetime + ) -> None: self.given_system_locale_is("fr_FR.UTF-8") self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is(expected) @@ -102,15 +104,15 @@ def test_dates_with_months_are_parsed_if_locale_is_non_english( ] ) def test_dates_with_days_are_parsed_if_locale_is_non_english( - self, date_string, fmt, expected - ): + self, date_string: str, fmt: str, expected: datetime + ) -> None: self.given_system_locale_is("fr_FR.UTF-8") self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is(expected) def test_parsing_date_should_fail_using_datetime_strptime_if_locale_is_non_english( self, - ): + ) -> None: self.given_system_locale_is("fr_FR.UTF-8") self.when_date_string_is_parsed_using_datetime_strptime( "21 february 2010", "%d %B %Y" @@ -171,7 +173,9 @@ def test_parsing_date_should_fail_using_datetime_strptime_if_locale_is_non_engli ), ] ) - def test_microseconds_are_parsed_correctly(self, date_string, fmt, expected): + def test_microseconds_are_parsed_correctly( + self, date_string: str, fmt: str, expected: datetime + ) -> None: self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is(expected) @@ -184,8 +188,8 @@ def test_microseconds_are_parsed_correctly(self, date_string, fmt, expected): ] ) def test_dates_with_no_year_do_not_raise_a_deprecation_warning( - self, date_string, fmt - ): + self, date_string: str, fmt: str + ) -> None: with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.when_date_string_is_parsed(date_string, fmt) @@ -233,7 +237,7 @@ def test_dates_with_no_year_do_not_raise_a_deprecation_warning( ) def test_dates_with_no_year_use_the_current_year( self, date_string: str, fmt: str, expected: datetime - ): + ) -> None: self.when_date_string_is_parsed(date_string, fmt) current_year = datetime.today().year expected = expected.replace(year=current_year) @@ -256,7 +260,9 @@ def test_dates_with_no_year_use_the_current_year( param("1999001 12:30", "%Y%j %H:%M", expected=datetime(1999, 1, 1, 12, 30)), ] ) - def test_day_of_year_is_parsed(self, date_string, fmt, expected): + def test_day_of_year_is_parsed( + self, date_string: str, fmt: str, expected: datetime + ) -> None: self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is(expected) @@ -274,7 +280,9 @@ def test_day_of_year_is_parsed(self, date_string, fmt, expected): param("1999777", "%Y%j"), ] ) - def test_day_of_year_out_of_range_is_not_parsed(self, date_string, fmt): + def test_day_of_year_out_of_range_is_not_parsed( + self, date_string: str, fmt: str + ) -> None: self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is_instance_of(ValueError) @@ -288,7 +296,7 @@ def test_day_of_year_out_of_range_is_not_parsed(self, date_string, fmt): ] ) def test_escaped_day_of_year_directive_is_a_literal( - self, date_string, fmt, expected - ): + self, date_string: str, fmt: str, expected: datetime + ) -> None: self.when_date_string_is_parsed(date_string, fmt) self.then_date_object_is(expected) diff --git a/tests/test_whitespace_preservation.py b/tests/test_whitespace_preservation.py index 8c90a42a3..9620e15d7 100644 --- a/tests/test_whitespace_preservation.py +++ b/tests/test_whitespace_preservation.py @@ -2,12 +2,17 @@ Tests for issue #1302: Whitespace preservation during translation """ +from typing import TYPE_CHECKING + from parameterized import param, parameterized from dateparser.conf import settings from dateparser.languages import default_loader from tests import BaseTestCase +if TYPE_CHECKING: + from dateparser.languages.locale import Locale + class TestWhitespacePreservation(BaseTestCase): """ @@ -17,11 +22,11 @@ class TestWhitespacePreservation(BaseTestCase): Issue #1302: Extra whitespace handling during date translation """ - def setUp(self): + def setUp(self) -> None: super().setUp() - self.language = NotImplemented - self.datetime_string = NotImplemented - self.translation = NotImplemented + self.language: Locale = NotImplemented + self.datetime_string: str = NotImplemented + self.translation: str = NotImplemented self.settings = settings @parameterized.expand( @@ -49,8 +54,8 @@ def setUp(self): ] ) def test_whitespace_preservation_during_translation( - self, shortname, datetime_string, expected_translation - ): + self, shortname: str, datetime_string: str, expected_translation: str + ) -> None: """Test that exact whitespace is preserved when translating date strings.""" self.given_bundled_language(shortname) self.given_string(datetime_string) @@ -70,31 +75,31 @@ def test_whitespace_preservation_during_translation( ] ) def test_whitespace_preservation_keep_formatting( - self, shortname, datetime_string, expected_translation - ): + self, shortname: str, datetime_string: str, expected_translation: str + ) -> None: """Test whitespace preservation with keep_formatting=True.""" self.given_bundled_language(shortname) self.given_string(datetime_string) self.when_datetime_string_translated_keep_formatting() self.then_string_translated_to(expected_translation) - def given_bundled_language(self, shortname): + def given_bundled_language(self, shortname: str) -> None: self.language = default_loader.get_locale(shortname) - def given_string(self, datetime_string): + def given_string(self, datetime_string: str) -> None: self.datetime_string = datetime_string - def when_datetime_string_translated(self): + def when_datetime_string_translated(self) -> None: self.translation = self.language.translate( self.datetime_string, settings=self.settings ) - def when_datetime_string_translated_keep_formatting(self): + def when_datetime_string_translated_keep_formatting(self) -> None: self.translation = self.language.translate( self.datetime_string, keep_formatting=True, settings=self.settings ) - def then_string_translated_to(self, expected_string): + def then_string_translated_to(self, expected_string: str) -> None: self.assertEqual( expected_string, self.translation, diff --git a/tox.ini b/tox.ini index b41781aa1..524145b48 100644 --- a/tox.ini +++ b/tox.ini @@ -1,5 +1,6 @@ [tox] -envlist = pre-commit,min,min-all,py310,py311,py312,py313,py314,all,scripts,docs,twinecheck,benchmark +min_version = 4.25.0 +envlist = pre-commit,mypy,min,min-all,py3{10-14},all,scripts,docs,twinecheck,benchmark [base] deps = @@ -55,6 +56,27 @@ deps = commands = pytest --cov=dateparser --cov-report=xml {posargs:tests/test_dateparser_data_integrity.py} +[testenv:mypy] +basepython = python3.10 +deps = + mypy==2.3.1 + convertdate==2.5.1 + gitpython==3.1.62 + hijridate==2.6.0 + langdetect==1.0.9 + parameterized==0.9.0 + parsel==1.12.0 + pytest==9.1.1 + pytest-codspeed==5.0.3 + ruamel.yaml==0.19.1 + types-python-dateutil==2.9.0.20260807 + types-pytz==2026.4.0.20260926 + types-regex==2026.9.10.20260911 + types-requests==2.33.0.20260906 + tzlocal==5.4.4 +commands = + mypy {posargs:dateparser dateparser_cli dateparser_scripts fuzzing tests} + [testenv:pre-commit] basepython = python3 deps = From a82a8c23c887ec5c77f157cb7f91b95e35ad2048 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 12:45:51 +0200 Subject: [PATCH 078/107] Stop dropping extra numbers when parsing dates (#1480) --- dateparser/parser.py | 44 +++++++++++++++++++++++++++++++++++-- dateparser/search/search.py | 18 ++++++++++++++- tests/test_date_parser.py | 12 ++++++++++ tests/test_search.py | 17 ++++++++++++++ 4 files changed, 88 insertions(+), 3 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index fb75bef4f..89e73e316 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -28,6 +28,7 @@ MICROSECOND = re.compile(r"\d{1,6}") EIGHT_DIGIT = re.compile(r"^\d{8}$") HOUR_MINUTE_REGEX = re.compile(r"^([0-9]|0[0-9]|1[0-9]|2[0-3]):[0-5][0-9]$") +_RANGE_DASHES = {"-", "–"} def no_space_parser_eligibile(datestring: str) -> bool: @@ -404,16 +405,45 @@ def __init__( # noqa: PLR0912, PLR0915 setattr(self, *res) known, unknown = get_unresolved_attrs(self) + unset_tokens = [ + unset_token + for unset_token in self.unset_tokens + if not ( + self._token_day and self._is_range(self._token_day[0], unset_token[0]) + ) + ] + if len(unset_tokens) > len(unknown): + raise ValueError("Too many numbers in date string") params: dict[str, int] = {} for attr in known: params.update({attr: getattr(self, attr)}) for attr in unknown: - for token, token_type, _ in self.unset_tokens: + for token, token_type, _ in unset_tokens: if token_type == 0: params.update({attr: int(token)}) setattr(self, f"_token_{attr}", token) setattr(self, attr, int(token)) + def _is_range(self, first: object, last: object) -> bool: + """Return whether *first* and *last* are the ends of a range, e.g. 12 + and 14 in “June 12-14, 2021”. A dash before *first* or after *last* + makes them part of a date instead, e.g. 4 and 25 in “6-4-25”.""" + + def is_dash(index: int) -> bool: + return ( + 0 <= index < len(self.tokens) + and self.tokens[index][0].lstrip(".") in _RANGE_DASHES + ) + + return any( + self.tokens[index][0] == first + and is_dash(index + 1) + and self.tokens[index + 2][0] == last + and not is_dash(index - 1) + and not is_dash(index + 3) + for index in range(len(self.tokens) - 2) + ) + @classmethod def _has_month_name(cls, tokens: Iterable[tuple[str, int]]) -> bool: for token, token_type in tokens: @@ -789,7 +819,17 @@ def parse_alpha( return set_and_return( token, token_type, component, do, skip_date_order=True ) - if component == "month": + if component == "month" and ( + not self.day + or self._is_range( + self._token_month[0], # type: ignore[index] + self._token_day[0], # type: ignore[index] + ) + ): + # A number read as the month becomes the day, which + # requires the day to be free, or to be the end of + # a range that starts at that number, e.g. 14 in + # “12-14 June”. index = self.auto_order.index("month") self.auto_order[index] = "day" self._token_day = self._token_month diff --git a/dateparser/search/search.py b/dateparser/search/search.py index 708b09e77..ecfb5ae48 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -181,6 +181,22 @@ def split_by_relative_expression( ) return possible_splits + def split_off_leading_number( + self, parser: DateDataParser, item: str, original: str + ) -> list[list[list[str]]]: + """Split a chunk that starts with a number into that number and the + rest, to find a date written after a number that is not part of it, + e.g. the decimals of “-58.5” before “06 Mar 2009”.""" + number, _, rest = item.partition(" ") + original_number, _, original_rest = original.partition(" ") + if ( + not number.isdigit() + or number != original_number + or parser.get_date_data(rest)["date_obj"] is None + ): + return [] + return [[[number, rest], [original_number, original_rest]]] + def split_if_not_parsed( self, parser: DateDataParser, @@ -190,7 +206,7 @@ def split_if_not_parsed( settings: Settings, ) -> list[list[list[str]]]: splitters = [",", "،", "——", "—", "–", ".", " "] - possible_splits: list[list[list[str]]] = [] + possible_splits = self.split_off_leading_number(parser, item, original) for splitter in splitters: if splitter in item and item.count(splitter) == original.count(splitter): possible_splits.extend(self.split_by(item, original, splitter)) diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 07ed0dc7f..6296c8348 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -234,6 +234,14 @@ def setUp(self) -> None: param("28. u studenom 2017.", datetime(2017, 11, 28, 0, 0)), param("13. veljače 1999. u podne", datetime(1999, 2, 13, 12, 0)), param("27. siječnja 1994. u ponoć", datetime(1994, 1, 27, 0, 0)), + # Day ranges + param("June 12-14, 2021", datetime(2021, 6, 12, 0, 0)), + param("Jun 12–14 2021", datetime(2021, 6, 12, 0, 0)), + param("12-14 June 2021", datetime(2021, 6, 12, 0, 0)), + param("12.-14. Juni 2021", datetime(2021, 6, 12, 0, 0)), + param("12.-14.06.2021", datetime(2021, 6, 12, 0, 0)), + param("12-14 июня 2021", datetime(2021, 6, 12, 0, 0)), + param("12 - 14 czerwca 2021", datetime(2021, 6, 12, 0, 0)), ] ) def test_dates_parsing(self, date_string: str, expected: datetime) -> None: @@ -603,6 +611,10 @@ def test_empty_dates_string_is_not_parsed(self) -> None: "Unable to parse: 8", ), param("12/09/18567", "Unable to parse: 18567"), + param("5 06 Mar 2009", "Unable to parse: march"), + param("Mar 5 06 2009", "Too many numbers in date string"), + param("6/4/25 0730", "Too many numbers in date string"), + param("6-4-25 0730", "Too many numbers in date string"), ] ) def test_dates_not_parsed(self, date_string: str, message: str) -> None: diff --git a/tests/test_search.py b/tests/test_search.py index 0a6bcfbf2..9d6a4728f 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1053,6 +1053,23 @@ def test_detection(self, shortname: str, text: str) -> None: settings={"STRICT_PARSING": True}, expected=[("23 juillet 2020", datetime.datetime(2020, 7, 23, 0, 0))], ), + param( + text="Bubble -58.5 06 Mar 2009 in need of -43.4 30 Oct 1974", + languages=["en"], + settings={"STRICT_PARSING": True}, + expected=[ + ("06 Mar 2009 in", datetime.datetime(2009, 3, 6, 0, 0)), + ("30 Oct 1974", datetime.datetime(1974, 10, 30, 0, 0)), + ], + ), + param( + text="The conference is June 12-14, 2021 in Boston.", + languages=["en"], + settings=None, + expected=[ + ("June 12-14, 2021 in", datetime.datetime(2021, 6, 12, 0, 0)) + ], + ), param(text="a Americ", languages=None, settings=None, expected=None), # Date with comma and apostrophe param( From a3fafe55f2a90c8165e4ed110082c0ae138c02b8 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 12:52:03 +0200 Subject: [PATCH 079/107] Add a script to evaluate dateparser on the dataset from #928 (#1463) --- CONTRIBUTING.rst | 30 +++++ dateparser_scripts/article_dates.py | 177 ++++++++++++++++++++++++++++ tests/test_article_dates.py | 32 +++++ 3 files changed, 239 insertions(+) create mode 100644 dateparser_scripts/article_dates.py create mode 100644 tests/test_article_dates.py diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst index e55c9e899..d481f9122 100644 --- a/CONTRIBUTING.rst +++ b/CONTRIBUTING.rst @@ -213,3 +213,33 @@ long-standing choice. When refreshing the table, slide ``REFERENCE_YEARS`` forward rather than widening it. Reaching further back re-admits abbreviations the tz database has since dropped and reports them as current. + +Evaluating against real-world dates +----------------------------------- + +:file:`dateparser_scripts/article_dates.py` runs dateparser on the 300k +article publication dates from #928, which it downloads to +:file:`~/.cache/dateparser/` on first use, and reports how often each of these +checks fails, per language and grouped by format:: + + python -m dateparser_scripts.article_dates --sample 5000 + +``error`` + Parsing raised an exception. +``unparsed`` + :func:`dateparser.parse` returned ``None``. +``searchable`` + :func:`dateparser.parse` returned ``None``, but + :func:`dateparser.search.search_dates` finds a date. +``future`` + The date is after March 2021, when the dataset was collected. +``hint-dependent`` + Passing the language of the article in *languages* changes the date. +``misdetected`` + The text parses in the language of the article, but a different one was + detected. + +The dataset has no expected dates, so these checks point at likely bugs +rather than prove them. To see how a change affects real-world input, run the +script with ``--output`` before and after the change, and compare both files +with ``diff``. The full dataset takes about 40 minutes on 8 cores. diff --git a/dateparser_scripts/article_dates.py b/dateparser_scripts/article_dates.py new file mode 100644 index 000000000..18396dd3b --- /dev/null +++ b/dateparser_scripts/article_dates.py @@ -0,0 +1,177 @@ +import argparse +import csv +import io +import os +import random +import re +import sys +import urllib.request +import zipfile +from collections import Counter, defaultdict, namedtuple +from datetime import datetime +from functools import cache +from multiprocessing import Pool +from pathlib import Path + +from dateparser.data.languages_info import language_order +from dateparser.date import DateDataParser +from dateparser.search import search_dates + +URL = ( + "https://github.com/scrapinghub/dateparser/files/6532578/" + "article_date_sample_Oct_2020_Mar_2021_public.csv.zip" +) +"""Dataset shared in #928: 300k article publication dates collected from the +web between October 2020 and March 2021.""" + +COLLECTION_END = datetime(2021, 4, 1) +"""No publication date in the dataset can be later than this, so later parsed +dates are wrong, and relative dates are resolved against it.""" + +SETTINGS = {"RELATIVE_BASE": COLLECTION_END} + +Result = namedtuple("Result", "text language date hinted locale found error") + +PROBLEMS = { + "error": lambda r: r.error is not None, + "unparsed": lambda r: r.date is None, + "searchable": lambda r: r.found, + "future": lambda r: ( + r.date is not None and r.date.replace(tzinfo=None) > COLLECTION_END + ), + "hint-dependent": lambda r: r.hinted is not None and r.hinted != r.date, + "misdetected": lambda r: ( + r.hinted is not None + and r.locale is not None + and re.search(r"[^\W\d_]{2}", r.text) is not None + and r.locale.split("-")[0] != r.language + ), +} +"""Checks run on every row. See CONTRIBUTING.rst for what each one means.""" + + +def cache_path(): + root = os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache" + return Path(root) / "dateparser" / URL.rsplit("/", 1)[1] + + +def load(path): + """Return a Counter of (text, language) pairs, downloading the dataset + to *path* first if missing.""" + if not path.exists(): + path.parent.mkdir(parents=True, exist_ok=True) + print(f"Downloading {URL} to {path}", file=sys.stderr) + urllib.request.urlretrieve(URL, path) + with zipfile.ZipFile(path) as archive: + (name,) = archive.namelist() + with archive.open(name) as f: + rows = csv.DictReader(io.TextIOWrapper(f, encoding="utf-8")) + return Counter( + (row["datePublishedRaw"], row["articleLanguage"]) for row in rows + ) + + +@cache +def parser(language=None): + return DateDataParser(languages=[language] if language else None, settings=SETTINGS) + + +def evaluate(item): + text, language = item + result = Result(text, language, None, None, None, False, None) + try: + data = parser().get_date_data(text) + result = result._replace(date=data.date_obj, locale=data.locale) + if language in language_order: + hinted = parser(language).get_date_data(text).date_obj + result = result._replace(hinted=hinted) + if data.date_obj is None: + found = search_dates(text, settings=SETTINGS) is not None + result = result._replace(found=found) + except Exception as exception: + result = result._replace(error=f"{type(exception).__name__}: {exception}") + return result + + +def shape(text): + """Return *text* with digits replaced by 9 and words by a, so that + strings written in the same format share a shape.""" + return re.sub(r"[^\W\d_]+", "a", re.sub(r"\d", "9", text)) + + +def report(results, counts, top, examples, out): + total = sum(counts.values()) + hits = {name: [r for r in results if check(r)] for name, check in PROBLEMS.items()} + + def weight(rs): + return sum(counts[r.text, r.language] for r in rs) + + print(f"{total} rows, {len(results)} distinct\n", file=out) + for name, rs in hits.items(): + print(f"{name}: {weight(rs)} ({weight(rs) / total:.1%})", file=out) + + by_language = defaultdict(list) + for r in results: + by_language[r.language].append(r) + print(f"\n{'language':>8} {'rows':>7}", *(f"{n:>14}" for n in hits), file=out) + ranked = sorted(by_language.items(), key=lambda item: -weight(item[1])) + for language, rs in ranked[:top]: + rows = weight(rs) + cells = (f"{weight(filter(PROBLEMS[n], rs)) / rows:>14.1%}" for n in hits) + print(f"{language or '-':>8} {rows:>7}", *cells, file=out) + + for name, rs in hits.items(): + groups = defaultdict(list) + for r in rs: + groups[shape(r.text)].append(r) + ranked = sorted(groups.items(), key=lambda item: -weight(item[1])) + print(f"\n== {name}: top shapes", file=out) + for s, group in ranked[:top]: + print(f"{weight(group):>7} {s!r}", file=out) + for r in group[:examples]: + print( + f" {r.language or '-':>3} {r.text!r} -> {r.date}" + f" (hinted: {r.hinted}, detected: {r.locale}" + f"{', ' + r.error if r.error else ''})", + file=out, + ) + + +def main(argv=None): + arg_parser = argparse.ArgumentParser( + description="Evaluate dateparser against the dataset from #928." + ) + arg_parser.add_argument("--data", type=Path, default=cache_path()) + arg_parser.add_argument("--sample", type=int, help="evaluate this many random rows") + arg_parser.add_argument("--language", help="only rows in this language") + arg_parser.add_argument( + "--top", type=int, default=15, help="how many languages and shapes to list" + ) + arg_parser.add_argument("--examples", type=int, default=3) + arg_parser.add_argument("--jobs", type=int, default=os.cpu_count()) + arg_parser.add_argument( + "--output", + type=Path, + help="write one line per distinct row, to compare runs with diff", + ) + args = arg_parser.parse_args(argv) + + counts = load(args.data) + if args.language is not None: + counts = Counter({k: n for k, n in counts.items() if k[1] == args.language}) + if args.sample: + rows = random.Random(0).sample(list(counts.elements()), args.sample) + counts = Counter(rows) + items = sorted(counts) + with Pool(args.jobs) as pool: + results = pool.map(evaluate, items, chunksize=100) + + report(results, counts, args.top, args.examples, sys.stdout) + if args.output: + with args.output.open("w", encoding="utf-8") as f: + for r in results: + print(*(repr(v) for v in r), sep="\t", file=f) + + +if __name__ == "__main__": + main() diff --git a/tests/test_article_dates.py b/tests/test_article_dates.py new file mode 100644 index 000000000..195c4fd87 --- /dev/null +++ b/tests/test_article_dates.py @@ -0,0 +1,32 @@ +import csv +import io +import zipfile + +from dateparser_scripts import article_dates + + +def test_report(tmp_path, capsys): + rows = io.StringIO() + writer = csv.writer(rows) + writer.writerow( + ["suffix", "articleLanguage", "webPageLanguages", "datePublishedRaw"] + ) + writer.writerow(["com", "en", "en", "October 22, 2020"]) + writer.writerow(["de", "de", "de", "05.03.2021"]) + writer.writerow(["de", "de", "de", "05.03.2021"]) + writer.writerow(["de", "de", "de", "Stellenangebot vom 04.11.2020"]) + data = tmp_path / "data.zip" + with zipfile.ZipFile(data, "w") as archive: + archive.writestr("data.csv", rows.getvalue()) + output = tmp_path / "output.tsv" + + article_dates.main(["--data", str(data), "--jobs", "1", "--output", str(output)]) + + report = capsys.readouterr().out + assert report.startswith("4 rows, 3 distinct\n") + assert "\nunparsed: 1 (25.0%)\n" in report + assert "\nsearchable: 1 (25.0%)\n" in report + assert "\nfuture: 2 (50.0%)\n" in report + assert "\nhint-dependent: 2 (50.0%)\n" in report + assert "\n 2 '99.99.9999'\n" in report + assert len(output.read_text().splitlines()) == 3 From 0961388cea5e45efba02350e8db0bb90407ee817 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 13:27:07 +0200 Subject: [PATCH 080/107] Fix mypy and ruff errors in the article dates script (#1499) --- dateparser_scripts/article_dates.py | 41 ++++++++++++++++++++--------- tests/test_article_dates.py | 5 +++- 2 files changed, 33 insertions(+), 13 deletions(-) diff --git a/dateparser_scripts/article_dates.py b/dateparser_scripts/article_dates.py index 18396dd3b..e99506894 100644 --- a/dateparser_scripts/article_dates.py +++ b/dateparser_scripts/article_dates.py @@ -7,11 +7,13 @@ import sys import urllib.request import zipfile -from collections import Counter, defaultdict, namedtuple +from collections import Counter, defaultdict +from collections.abc import Callable, Iterable from datetime import datetime from functools import cache from multiprocessing import Pool from pathlib import Path +from typing import NamedTuple, TextIO from dateparser.data.languages_info import language_order from dateparser.date import DateDataParser @@ -30,9 +32,18 @@ SETTINGS = {"RELATIVE_BASE": COLLECTION_END} -Result = namedtuple("Result", "text language date hinted locale found error") -PROBLEMS = { +class Result(NamedTuple): + text: str + language: str + date: datetime | None + hinted: datetime | None + locale: str | None + found: bool + error: str | None + + +PROBLEMS: dict[str, Callable[[Result], bool]] = { "error": lambda r: r.error is not None, "unparsed": lambda r: r.date is None, "searchable": lambda r: r.found, @@ -50,12 +61,12 @@ """Checks run on every row. See CONTRIBUTING.rst for what each one means.""" -def cache_path(): +def cache_path() -> Path: root = os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache" return Path(root) / "dateparser" / URL.rsplit("/", 1)[1] -def load(path): +def load(path: Path) -> Counter[tuple[str, str]]: """Return a Counter of (text, language) pairs, downloading the dataset to *path* first if missing.""" if not path.exists(): @@ -72,11 +83,11 @@ def load(path): @cache -def parser(language=None): +def parser(language: str | None = None) -> DateDataParser: return DateDataParser(languages=[language] if language else None, settings=SETTINGS) -def evaluate(item): +def evaluate(item: tuple[str, str]) -> Result: text, language = item result = Result(text, language, None, None, None, False, None) try: @@ -93,17 +104,23 @@ def evaluate(item): return result -def shape(text): +def shape(text: str) -> str: """Return *text* with digits replaced by 9 and words by a, so that strings written in the same format share a shape.""" return re.sub(r"[^\W\d_]+", "a", re.sub(r"\d", "9", text)) -def report(results, counts, top, examples, out): +def report( + results: list[Result], + counts: Counter[tuple[str, str]], + top: int, + examples: int, + out: TextIO, +) -> None: total = sum(counts.values()) hits = {name: [r for r in results if check(r)] for name, check in PROBLEMS.items()} - def weight(rs): + def weight(rs: Iterable[Result]) -> int: return sum(counts[r.text, r.language] for r in rs) print(f"{total} rows, {len(results)} distinct\n", file=out) @@ -137,7 +154,7 @@ def weight(rs): ) -def main(argv=None): +def main(argv: list[str] | None = None) -> None: arg_parser = argparse.ArgumentParser( description="Evaluate dateparser against the dataset from #928." ) @@ -160,7 +177,7 @@ def main(argv=None): if args.language is not None: counts = Counter({k: n for k, n in counts.items() if k[1] == args.language}) if args.sample: - rows = random.Random(0).sample(list(counts.elements()), args.sample) + rows = random.Random(0).sample(list(counts.elements()), args.sample) # noqa: S311 counts = Counter(rows) items = sorted(counts) with Pool(args.jobs) as pool: diff --git a/tests/test_article_dates.py b/tests/test_article_dates.py index 195c4fd87..e98ecff2b 100644 --- a/tests/test_article_dates.py +++ b/tests/test_article_dates.py @@ -1,11 +1,14 @@ import csv import io import zipfile +from pathlib import Path + +import pytest from dateparser_scripts import article_dates -def test_report(tmp_path, capsys): +def test_report(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None: rows = io.StringIO() writer = csv.writer(rows) writer.writerow( From 9a266e549583da697a70101138f173d19c063a65 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Wed, 30 Sep 2026 13:45:54 +0200 Subject: [PATCH 081/107] Bump the github-actions group with 5 updates (#1498) Bumps the github-actions group with 5 updates: | Package | From | To | | --- | --- | --- | | [actions/upload-artifact](https://github.com/actions/upload-artifact) | `4.6.2` | `7.0.1` | | [actions/checkout](https://github.com/actions/checkout) | `3.7.0` | `7.0.1` | | [actions/setup-python](https://github.com/actions/setup-python) | `5.6.0` | `7.0.0` | | [codecov/codecov-action](https://github.com/codecov/codecov-action) | `5.5.5` | `7.1.1` | | [actions/download-artifact](https://github.com/actions/download-artifact) | `7.0.0` | `8.0.1` | Updates `actions/upload-artifact` from 4.6.2 to 7.0.1 - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v4.6.2...043fb46d1a93c77aae656e7c1c64a875d1fc6a0a) Updates `actions/checkout` from 3.7.0 to 7.0.1 - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v3.7.0...3d3c42e5aac5ba805825da76410c181273ba90b1) Updates `actions/setup-python` from 5.6.0 to 7.0.0 - [Release notes](https://github.com/actions/setup-python/releases) - [Commits](https://github.com/actions/setup-python/compare/a26af69be951a213d495a4c3e4e4022e16d87065...5fda3b95a4ea91299a34e894583c3862153e4b97) Updates `codecov/codecov-action` from 5.5.5 to 7.1.1 - [Release notes](https://github.com/codecov/codecov-action/releases) - [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md) - [Commits](https://github.com/codecov/codecov-action/compare/0fb7174895f61a3b6b78fc075e0cd60383518dac...303a32d7a59b442fa8d48b6a1cc6825c09c847a5) Updates `actions/download-artifact` from 7.0.0 to 8.0.1 - [Release notes](https://github.com/actions/download-artifact/releases) - [Commits](https://github.com/actions/download-artifact/compare/37930b1c2abaa49bbe596cd826c3c89aef350131...3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-version: 7.0.1 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/checkout dependency-version: 7.0.1 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/setup-python dependency-version: 7.0.0 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: codecov/codecov-action dependency-version: 7.1.1 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions - dependency-name: actions/download-artifact dependency-version: 8.0.1 dependency-type: direct:production update-type: version-update:semver-major dependency-group: github-actions ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- .github/workflows/cifuzz.yml | 2 +- .github/workflows/codspeed.yml | 4 ++-- .github/workflows/main.yml | 6 +++--- .github/workflows/publish.yml | 8 ++++---- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml index 72661697f..eec6e7f84 100644 --- a/.github/workflows/cifuzz.yml +++ b/.github/workflows/cifuzz.yml @@ -21,7 +21,7 @@ jobs: fuzz-seconds: 600 output-sarif: true - name: Upload Crash - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 if: failure() && steps.build.outcome == 'success' with: name: artifacts diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml index d0d292952..4acf16db6 100644 --- a/.github/workflows/codspeed.yml +++ b/.github/workflows/codspeed.yml @@ -37,11 +37,11 @@ jobs: contents: read id-token: write steps: - - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false - name: Set up Python - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0 + uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 with: python-version: "3.13" - name: Install dependencies diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index eb60e95c7..afe5591d4 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -49,11 +49,11 @@ jobs: toxenv: py timezone: "Pacific/Fiji" steps: - - uses: actions/checkout@a37ce9120846195fa4ece8f58b268e6043cb2f26 # v3.7.0 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false - name: 'Set up Python ${{ matrix.python-version }}' - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0 + uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 with: python-version: ${{ matrix.python-version }} - name: Install language-pack-fr @@ -71,6 +71,6 @@ jobs: # has a coverage report, so uploading again only repeats the Codecov # notification for that SHA. if: github.event_name == 'push' || github.event_name == 'pull_request' - uses: codecov/codecov-action@0fb7174895f61a3b6b78fc075e0cd60383518dac # v5.5.5 + uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5 # v7.1.1 with: token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index bff2d411a..8ca4a33b4 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -12,11 +12,11 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@a37ce9120846195fa4ece8f58b268e6043cb2f26 # v3.7.0 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false - name: Set up Python - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0 + uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 with: python-version: "3.x" - name: Install dependencies @@ -28,7 +28,7 @@ jobs: python -m build . twine check dist/* - name: Upload package - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0 + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 with: name: packages path: dist/ @@ -49,7 +49,7 @@ jobs: steps: - name: Download package - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0 + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 with: name: packages path: dist/ From 778db6314d4fb88c1e2f56e40a7ebb25a323fdb5 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 13:58:47 +0200 Subject: [PATCH 082/107] Add a Minguo calendar for Taiwanese dates (#1489) --- README.rst | 14 +++++++-- dateparser/calendars/minguo.py | 57 ++++++++++++++++++++++++++++++++++ tests/test_minguo.py | 45 +++++++++++++++++++++++++++ 3 files changed, 114 insertions(+), 2 deletions(-) create mode 100644 dateparser/calendars/minguo.py create mode 100644 tests/test_minguo.py diff --git a/README.rst b/README.rst index 6135bd218..dfea1c0ba 100644 --- a/README.rst +++ b/README.rst @@ -361,8 +361,9 @@ Supported Calendars =================== Apart from the Gregorian calendar, `dateparser` supports the `Persian Jalali -calendar`, the `Hijri/Islamic calendar` and the `French Republican calendar`. -To use them, install the ``calendars`` extra (see `Installation`_). +calendar`, the `Hijri/Islamic calendar`, the `French Republican calendar` and +the `Minguo calendar`. To use the first three, install the ``calendars`` extra +(see `Installation`_). Example using the `Persian Jalali calendar `_: @@ -391,6 +392,15 @@ Example using the `French Republican calendar >>> FrenchRepublicanCalendar('18 brumaire an VIII').get_date() DateData(date_obj=datetime.datetime(1799, 11, 9, 0, 0), period='day', locale=None) +Example using the `Minguo calendar +`_: + +.. code:: python + + >>> from dateparser.calendars.minguo import MinguoCalendar + >>> MinguoCalendar('民國101年5月25日 08:36').get_date() + DateData(date_obj=datetime.datetime(2012, 5, 25, 8, 36), period='day', locale=None) + Dependencies ============ diff --git a/dateparser/calendars/minguo.py b/dateparser/calendars/minguo.py new file mode 100644 index 000000000..4af062990 --- /dev/null +++ b/dateparser/calendars/minguo.py @@ -0,0 +1,57 @@ +import calendar +from datetime import date, datetime, tzinfo +from typing import Any + +from dateparser.calendars import CalendarBase, non_gregorian_parser +from dateparser.conf import Settings + +_YEAR_OFFSET = 1911 + + +class _minguo: + @classmethod + def to_gregorian(cls, year: int, month: int, day: int) -> tuple[int, int, int]: + return year + _YEAR_OFFSET, month, day + + @classmethod + def from_gregorian(cls, year: int, month: int, day: int) -> tuple[int, int, int]: + return year - _YEAR_OFFSET, month, day + + @classmethod + def month_length(cls, year: int, month: int) -> int: + return calendar.monthrange(year + _YEAR_OFFSET, month)[1] + + +class _minguo_parser(non_gregorian_parser): + calendar_converter = _minguo + default_year = 101 + default_month = 1 + default_day = 1 + non_gregorian_date_cls = date + + def _get_date_obj(self, token: str, directive: str) -> Any: + if directive == "%Y": + if not (token.isdigit() and len(token) <= 3 and int(token)): + raise ValueError + return date(int(token), self.default_month, self.default_day) + return super()._get_date_obj(token, directive) + + @classmethod + def parse( + cls, + datestring: str, + settings: Settings, + tz: tzinfo | None = None, + date_order: str | None = None, + ) -> tuple[datetime, str | None]: + return super(non_gregorian_parser, cls).parse( + datestring, settings, tz, date_order or "YMD" + ) + + +class MinguoCalendar(CalendarBase): + """Calendar class for the `Minguo calendar + `_, used in + Taiwan.""" + + parser = _minguo_parser diff --git a/tests/test_minguo.py b/tests/test_minguo.py new file mode 100644 index 000000000..d81bd7338 --- /dev/null +++ b/tests/test_minguo.py @@ -0,0 +1,45 @@ +from datetime import datetime + +from parameterized import param, parameterized + +from dateparser.calendars.minguo import MinguoCalendar, _minguo_parser +from dateparser.conf import settings +from tests import BaseTestCase + + +class TestMinguoCalendar(BaseTestCase): + @parameterized.expand( + [ + param("101/05/25", datetime(2012, 5, 25)), + param("民國101年5月25日 08:36", datetime(2012, 5, 25, 8, 36)), + param("99.12.31", datetime(2010, 12, 31)), + param("5/1/2", datetime(1916, 1, 2)), + param("101/2/29", datetime(2012, 2, 29)), + ] + ) + def test_parse(self, date_string: str, expected: datetime) -> None: + date_data = MinguoCalendar(date_string).get_date() + assert date_data is not None + self.assertEqual(date_data.date_obj, expected) + self.assertEqual(date_data.period, "day") + + @parameterized.expand( + [ + param("101-02", datetime(2012, 2, 29), "month"), + param("110", datetime(2021, 3, 31), "year"), + ] + ) + def test_partial(self, date_string: str, expected: datetime, period: str) -> None: + current = settings.replace(RELATIVE_BASE=datetime(2026, 3, 31)) + self.assertEqual(_minguo_parser.parse(date_string, current), (expected, period)) + + @parameterized.expand( + [ + param("2012/05/25"), + param("0/1/1"), + param("102/2/29"), + param("101/05/25 08:36 92694"), + ] + ) + def test_invalid(self, date_string: str) -> None: + self.assertIsNone(MinguoCalendar(date_string).get_date()) From 0d9c72b44732512e2fa0a90e8cb6631c4cab1d19 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 14:02:47 +0200 Subject: [PATCH 083/107] Apply PREFER_DAY_OF_MONTH before PREFER_DATES_FROM picks the year (#1409) --- dateparser/parser.py | 2 +- docs/settings.rst | 2 +- tests/test_date_parser.py | 44 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 46 insertions(+), 2 deletions(-) diff --git a/dateparser/parser.py b/dateparser/parser.py index 89e73e316..d6dc532ea 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -608,7 +608,7 @@ def _correct_for_time_frame( # noqa: PLR0912, PLR0915 if self.month and not self.year: try: - if self.now < dateobj: + if self.now < self._correct_for_day(dateobj): if self.settings.PREFER_DATES_FROM == "past": dateobj = dateobj.replace(year=dateobj.year - 1) elif self.settings.PREFER_DATES_FROM == "future": diff --git a/docs/settings.rst b/docs/settings.rst index 6a26192a8..af6dd116a 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -97,7 +97,7 @@ If date string is missing some part, this option ensures consistent results depe datetime.datetime(2016, 3, 16, 0, 0) >>> # parsing with preference set for 'past' >>> parse('August', settings={'PREFER_DATES_FROM': 'past'}) - datetime.datetime(2015, 8, 15, 0, 0) + datetime.datetime(2014, 8, 16, 0, 0) ``RELATIVE_BASE``: allows setting the base datetime to use for interpreting partial or relative date strings. Defaults to the current date and time. diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 6296c8348..cae6e6130 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -931,6 +931,50 @@ def test_that_day_preference_does_not_affect_dates_with_explicit_day( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(datetime(2012, 4, 24)) + @parameterized.expand( + [ + param("past", "first", datetime(2025, 4, 1)), + param("past", "current", datetime(2025, 4, 4)), + param("past", "last", datetime(2024, 4, 30)), + param("future", "first", datetime(2026, 4, 1)), + param("future", "current", datetime(2026, 4, 4)), + param("future", "last", datetime(2025, 4, 30)), + ] + ) + def test_day_preference_decides_if_current_month_is_past_or_future( + self, prefer_dates_from: str, prefer_day_of_month: str, expected: datetime + ) -> None: + self.given_parser( + settings={ + "PREFER_DATES_FROM": prefer_dates_from, + "PREFER_DAY_OF_MONTH": prefer_day_of_month, + "RELATIVE_BASE": datetime(2025, 4, 4, 12), + } + ) + self.when_date_is_parsed("April") + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(expected) + + @parameterized.expand( + [ + param("past", datetime(2024, 2, 1), datetime(2023, 2, 28)), + param("future", datetime(2024, 3, 1), datetime(2025, 2, 28)), + ] + ) + def test_last_day_of_february_moved_to_another_year( + self, prefer_dates_from: str, today: datetime, expected: datetime + ) -> None: + self.given_parser( + settings={ + "PREFER_DATES_FROM": prefer_dates_from, + "PREFER_DAY_OF_MONTH": "last", + "RELATIVE_BASE": today, + } + ) + self.when_date_is_parsed("February") + self.then_date_was_parsed_by_date_parser() + self.then_date_obj_exactly_is(expected) + def test_date_is_parsed_when_skip_tokens_are_supplied(self) -> None: self.given_parser( settings={"SKIP_TOKENS": ["de"], "RELATIVE_BASE": datetime(2015, 2, 12)} From 36d0af5e0a6038a5ca1059be00f7d019c9487fb0 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 14:03:18 +0200 Subject: [PATCH 084/107] Apply PREFER_DAY_OF_MONTH and PREFER_MONTH_OF_YEAR to relative dates (#1413) --- dateparser/freshness_date_parser.py | 6 ++++++ tests/test_freshness_date_parser.py | 26 ++++++++++++++++++++++++++ 2 files changed, 32 insertions(+) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 68aab17e2..309db588d 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -9,6 +9,8 @@ _get_localzone, apply_timezone, localize_timezone, + set_correct_day_from_settings, + set_correct_month_from_settings, strip_braces, ) @@ -95,6 +97,10 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: date, period = self._parse_date(date_string, now, settings.PREFER_DATES_FROM) if date: + if period == "year": + date = set_correct_month_from_settings(date, settings, date.month) + if period in ("year", "month"): + date = set_correct_day_from_settings(date, settings, date.day) old_date = date date = apply_time(date, _time) if settings.RETURN_TIME_AS_PERIOD and old_date != date: diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 9bf93878b..7f6938ed1 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -2655,6 +2655,32 @@ def test_freshness_date_with_relative_base_future( self.then_date_is(date) self.then_time_is(time) + @parameterized.expand( + [ + param("this month", {"PREFER_DAY_OF_MONTH": "first"}, date(2010, 6, 1)), + param("next month", {"PREFER_DAY_OF_MONTH": "last"}, date(2010, 7, 31)), + param("2 months ago", {"PREFER_DAY_OF_MONTH": "last"}, date(2010, 4, 30)), + param("next month", {"PREFER_DAY_OF_MONTH": "current"}, date(2010, 7, 4)), + param("next week", {"PREFER_DAY_OF_MONTH": "first"}, date(2010, 6, 11)), + param( + "last year", + {"PREFER_MONTH_OF_YEAR": "first", "PREFER_DAY_OF_MONTH": "first"}, + date(2009, 1, 1), + ), + param("last year", {"PREFER_MONTH_OF_YEAR": "last"}, date(2009, 12, 4)), + ] + ) + def test_freshness_date_with_prefer_day_and_month( + self, date_string: str, prefer_settings: dict[str, Any], date: date + ) -> None: + self.given_parser( + settings={"RELATIVE_BASE": datetime(2010, 6, 4, 13, 15), **prefer_settings} + ) + self.given_date_string(date_string) + self.when_date_is_parsed() + self.then_date_is(date) + self.then_time_is(time(13, 15)) + def test_long_digit_run_does_not_hang(self) -> None: # Possessive quantifiers (\d++[.,]?\d*+) prevent quadratic backtracking. # Without the fix, PATTERN.findall('9' * 3200) takes ~23 s; with it, ~0.02 s. From 007661f0bf861494f869d2f1708cab5af323dbee Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 14:29:15 +0200 Subject: [PATCH 085/107] Report which date parts come from the input in DateData.parts (#1408) --- README.rst | 4 +- dateparser/calendars/__init__.py | 8 ++-- dateparser/calendars/french_republican.py | 5 ++- dateparser/date.py | 37 ++++++++++++---- dateparser/date_parser.py | 8 ++-- dateparser/freshness_date_parser.py | 36 +++++++++++----- dateparser/parser.py | 31 ++++++++++---- dateparser/utils/__init__.py | 51 +++++++++++++---------- docs/settings.rst | 4 +- docs/usage.rst | 6 +-- tests/test_date.py | 36 ++++++++++++++++ tests/test_date_data.py | 24 +++++++---- tests/test_date_parser.py | 10 +++-- tests/test_french_republican.py | 27 ++++++++---- tests/test_parser.py | 4 +- 15 files changed, 204 insertions(+), 87 deletions(-) diff --git a/README.rst b/README.rst index dfea1c0ba..c28939109 100644 --- a/README.rst +++ b/README.rst @@ -372,7 +372,7 @@ Example using the `Persian Jalali calendar >>> from dateparser.calendars.jalali import JalaliCalendar >>> JalaliCalendar('جمعه سی ام اسفند ۱۳۸۷').get_date() - DateData(date_obj=datetime.datetime(2009, 3, 20, 0, 0), period='day', locale=None) + DateData(date_obj=datetime.datetime(2009, 3, 20, 0, 0), period='day', locale=None, parts=('year', 'month', 'day')) Example using the `Hijri/Islamic calendar `_: @@ -381,7 +381,7 @@ Example using the `Hijri/Islamic calendar >>> from dateparser.calendars.hijri import HijriCalendar >>> HijriCalendar('17-01-1437 هـ 08:30 مساءً').get_date() - DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None) + DateData(date_obj=datetime.datetime(2015, 10, 30, 20, 30), period='day', locale=None, parts=('year', 'month', 'day', 'time')) Example using the `French Republican calendar `_: diff --git a/dateparser/calendars/__init__.py b/dateparser/calendars/__init__.py index cc4b2092a..14e9e35d2 100644 --- a/dateparser/calendars/__init__.py +++ b/dateparser/calendars/__init__.py @@ -10,7 +10,7 @@ class _CalendarParser(Protocol): def parse( self, datestring: str, settings: Settings - ) -> tuple[datetime, str | None]: ... + ) -> tuple[datetime, str | None, tuple[str, ...]]: ... class CalendarBase: @@ -28,8 +28,8 @@ def __init__(self, source: str) -> None: def get_date(self) -> DateData | None: try: - date_obj, period = self.parser.parse(self.source, settings) - return DateData(date_obj=date_obj, period=period) + date_obj, period, parts = self.parser.parse(self.source, settings) + return DateData(date_obj=date_obj, period=period, parts=parts) except ValueError: return None @@ -150,6 +150,6 @@ def parse( settings: Settings, tz: tzinfo | None = None, date_order: str | None = None, - ) -> tuple[datetime, str | None]: + ) -> tuple[datetime, str | None, tuple[str, ...]]: datestring = cls.to_latin(datestring) return super().parse(datestring, settings, tz, date_order) diff --git a/dateparser/calendars/french_republican.py b/dateparser/calendars/french_republican.py index 6634e57fe..285f97fc0 100644 --- a/dateparser/calendars/french_republican.py +++ b/dateparser/calendars/french_republican.py @@ -59,7 +59,7 @@ class _french_republican_parser: @classmethod def parse( cls, datestring: str, settings: "Settings" - ) -> tuple[datetime, str | None]: + ) -> tuple[datetime, str | None, tuple[str, ...]]: normalized = "".join( char for char in unicodedata.normalize("NFKD", datestring.strip()) @@ -92,7 +92,8 @@ def parse( ) date = datetime(*french_republican.to_gregorian(year, month, day)) period = "day" if match["day"] else "month" if match["month"] else "year" - return date, period + parts = ("year", "month", "day")[: ("year", "month", "day").index(period) + 1] + return date, period, parts class FrenchRepublicanCalendar(CalendarBase): diff --git a/dateparser/date.py b/dateparser/date.py index bbdd771c3..539f14174 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -18,6 +18,7 @@ from dateparser.utils import ( _get_localzone, _get_missing_parts, + _get_parts, apply_timezone_from_settings, get_next_leap_year, get_previous_leap_year, @@ -302,7 +303,9 @@ def parse_with_formats( date_obj = apply_timezone_from_settings(date_obj, settings) - return DateData(date_obj=date_obj, period=period) + return DateData( + date_obj=date_obj, period=period, parts=_get_parts(date_format) + ) return DateData(date_obj=None, period=period) @@ -364,6 +367,7 @@ def _try_timestamp_parser(self, negative: bool = False) -> "DateData": self.date_string, self._settings, negative=negative ), period="time" if self._settings.RETURN_TIME_AS_PERIOD else "day", + parts=("year", "month", "day", "time"), ) def _try_timestamp(self) -> "DateData": @@ -387,7 +391,7 @@ def _try_nospaces_parser(self) -> "DateData | None": return self._try_parser(parse_method=_parse_nospaces) def _try_parser( - self, parse_method: Callable[..., tuple[datetime, str | None]] + self, parse_method: Callable[..., tuple[datetime, str | None, tuple[str, ...]]] ) -> "DateData | None": original_order = self._settings.DATE_ORDER @@ -418,13 +422,13 @@ def _try_parser( for order in candidates: try: - date_obj, period = date_parser.parse( + date_obj, period, parts = date_parser.parse( translated, parse_method=parse_method, settings=self._settings, date_order=order, ) - return DateData(date_obj=date_obj, period=period) + return DateData(date_obj=date_obj, period=period, parts=parts) except ValueError: continue return None @@ -481,10 +485,16 @@ def __init__( date_obj: datetime | None = None, period: str | None = None, locale: str | None = None, + parts: tuple[str, ...] = (), ) -> None: self.date_obj = date_obj self.period = period self.locale = locale + self.parts = parts + """Parts of :attr:`date_obj` determined by the parsed string, as a + tuple with some or all of ``"year"``, ``"month"``, ``"day"`` and + ``"time"``, in that order. The remaining parts come from + :ref:`settings`, e.g. ``RELATIVE_BASE`` or ``PREFER_DAY_OF_MONTH``.""" def __getitem__(self, k: str) -> Any: if not hasattr(self, k): @@ -643,20 +653,29 @@ def get_date_data( Hence, the level of precision is ``month``: >>> DateDataParser().get_date_data('March 2015') - DateData(date_obj=datetime.datetime(2015, 3, 16, 0, 0), period='month', locale='en') + DateData(date_obj=datetime.datetime(2015, 3, 16, 0, 0), period='month', locale='en', + parts=('year', 'month')) Similarly, for date strings with no day and month information present, level of precision is ``year`` and day ``16`` and month ``6`` are from *current_date*. >>> DateDataParser().get_date_data('2014') - DateData(date_obj=datetime.datetime(2014, 6, 16, 0, 0), period='year', locale='en') + DateData(date_obj=datetime.datetime(2014, 6, 16, 0, 0), period='year', locale='en', + parts=('year',)) + + *Parts* lists the parts of the date that the given string determines, + including those that *period* cannot tell apart, like a missing year: + + >>> DateDataParser().get_date_data('16 March') + DateData(date_obj=datetime.datetime(2015, 3, 16, 0, 0), period='day', locale='en', + parts=('month', 'day')) Dates with time zone indications or UTC offsets are returned in UTC time unless specified using `Settings `__. >>> DateDataParser().get_date_data('23 March 2000, 1:21 PM CET') DateData(date_obj=datetime.datetime(2000, 3, 23, 13, 21, tzinfo=), - period='day', locale='en') + period='day', locale='en', parts=('year', 'month', 'day', 'time')) """ if not isinstance(date_string, str): @@ -706,9 +725,9 @@ def _parse_using_applicable_locales( def get_date_tuple(self, *args: Any, **kwargs: Any) -> tuple[Any, ...]: date_data = self.get_date_data(*args, **kwargs) - fields = date_data.__dict__.keys() + fields = {k: v for k, v in date_data.__dict__.items() if k != "parts"} date_tuple = collections.namedtuple("DateData", fields) # type: ignore[misc] # noqa: PYI024 - result: tuple[Any, ...] = date_tuple(**date_data.__dict__) + result: tuple[Any, ...] = date_tuple(**fields) return result def _get_applicable_locales( diff --git a/dateparser/date_parser.py b/dateparser/date_parser.py index e89a160af..47490ed60 100644 --- a/dateparser/date_parser.py +++ b/dateparser/date_parser.py @@ -12,10 +12,10 @@ class DateParser: def parse( self, date_string: str, - parse_method: Callable[..., tuple[datetime, str | None]], + parse_method: Callable[..., tuple[datetime, str | None, tuple[str, ...]]], settings: Settings | dict[str, Any] | None = None, date_order: str | None = None, - ) -> tuple[datetime, str | None]: + ) -> tuple[datetime, str | None, tuple[str, ...]]: assert isinstance(settings, Settings) date_string = str(date_string) @@ -25,7 +25,7 @@ def parse( date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) - date_obj, period = parse_method( + date_obj, period, parts = parse_method( date_string, settings=settings, tz=ptz, date_order=date_order ) @@ -53,7 +53,7 @@ def parse( ): date_obj = date_obj.replace(tzinfo=None) - return date_obj, period + return date_obj, period, parts date_parser = DateParser() diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 309db588d..14b881742 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -50,7 +50,7 @@ def get_local_tz(self) -> tzinfo: def parse( # noqa: PLR0912 self, date_string: str, settings: "Settings" - ) -> tuple[datetime | None, str | None]: + ) -> tuple[datetime | None, str | None, tuple[str, ...]]: date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) _time = self._parse_time(date_string, settings) @@ -94,7 +94,9 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: else: now = datetime.now(self.get_local_tz()) - date, period = self._parse_date(date_string, now, settings.PREFER_DATES_FROM) + date, period, parts = self._parse_date( + date_string, now, settings.PREFER_DATES_FROM + ) if date: if period == "year": @@ -105,6 +107,8 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: date = apply_time(date, _time) if settings.RETURN_TIME_AS_PERIOD and old_date != date: period = "time" + if isinstance(_time, time) and "time" not in parts: + parts += ("time",) if settings.TO_TIMEZONE: date = apply_timezone(date, settings.TO_TIMEZONE) @@ -116,13 +120,13 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: ): date = date.replace(tzinfo=None) - return date, period + return date, period, parts - def _parse_date( + def _parse_date( # noqa: PLR0912 self, date_string: str, now: datetime, prefer_dates_from: str - ) -> tuple[datetime, str] | tuple[None, None]: + ) -> tuple[datetime, str, tuple[str, ...]] | tuple[None, None, tuple[()]]: if not self._are_all_words_units(date_string): - return None, None + return None, None, () result = self.get_kwargs(date_string) if isinstance(result, tuple): @@ -132,7 +136,7 @@ def _parse_date( explicit_signs = {} if not kwargs: - return None, None + return None, None, () period = "day" if "days" not in kwargs: for k in ["weeks", "months", "years", "decades"]: @@ -165,7 +169,19 @@ def _parse_date( date = now + td - return date, period + # The smallest unit in the string determines which parts of the + # resulting date are meaningful. + parts: tuple[str, ...] + if kwargs.keys() & {"seconds", "minutes", "hours"}: + parts = ("year", "month", "day", "time") + elif kwargs.keys() & {"days", "weeks"}: + parts = ("year", "month", "day") + elif "months" in kwargs: + parts = ("year", "month") + else: + parts = ("year",) + + return date, period, parts def get_kwargs( self, date_string: str @@ -187,8 +203,8 @@ def get_kwargs( def get_date_data(self, date_string: str, settings: "Settings") -> "DateData": from dateparser.date import DateData # noqa: PLC0415 - date, period = self.parse(date_string, settings) - return DateData(date_obj=date, period=period) + date, period, parts = self.parse(date_string, settings) + return DateData(date_obj=date, period=period, parts=parts) freshness_date_parser = FreshnessDateDataParser() diff --git a/dateparser/parser.py b/dateparser/parser.py index d6dc532ea..92a30dab3 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -11,6 +11,7 @@ from dateparser.utils import ( _get_missing_parts, + _get_parts, get_last_day_of_month, get_next_leap_year, get_previous_leap_year, @@ -84,7 +85,7 @@ def _parse_absolute( settings: "Settings", tz: tzinfo | None = None, date_order: str | None = None, -) -> tuple[datetime, str | None]: +) -> tuple[datetime, str | None, tuple[str, ...]]: return _parser.parse(datestring, settings, tz, date_order=date_order) @@ -93,7 +94,7 @@ def _parse_nospaces( settings: "Settings", tz: tzinfo | None = None, date_order: str | None = None, -) -> tuple[datetime, str]: +) -> tuple[datetime, str, tuple[str, ...]]: return _no_spaces_parser.parse(datestring, settings, date_order=date_order) @@ -204,10 +205,12 @@ def _get_period(cls, format_string: str) -> str: return "year" @classmethod - def _find_best_matching_date(cls, datestring: str) -> tuple[datetime, str] | None: + def _find_best_matching_date( + cls, datestring: str + ) -> tuple[datetime, str, tuple[str, ...]] | None: for fmt in cls._preferred_formats_ordered_8_digit: with contextlib.suppress(Exception): - dt = strptime(datestring, fmt), cls._get_period(fmt) + dt = strptime(datestring, fmt), cls._get_period(fmt), _get_parts(fmt) if len(str(dt[0].year)) == 4: return dt return None @@ -215,7 +218,7 @@ def _find_best_matching_date(cls, datestring: str) -> tuple[datetime, str] | Non @classmethod def parse( cls, datestring: str, settings: "Settings", date_order: str | None = None - ) -> tuple[datetime, str]: + ) -> tuple[datetime, str, tuple[str, ...]]: if not no_space_parser_eligibile(datestring): raise ValueError(f"Unable to parse date from: {datestring}") @@ -233,11 +236,11 @@ def parse( if dt is not None: return dt nsp = cls() - ambiguous_date: tuple[datetime, str] | None = None + ambiguous_date: tuple[datetime, str, tuple[str, ...]] | None = None for token, _ in tokens.tokenize(): for fmt in nsp.date_formats[order]: with contextlib.suppress(Exception): - dt = strptime(token, fmt), cls._get_period(fmt) + dt = strptime(token, fmt), cls._get_period(fmt), _get_parts(fmt) if len(str(dt[0].year)) < 4: ambiguous_date = dt continue @@ -471,6 +474,16 @@ def _get_period(self) -> str: return "day" + def _get_parts(self) -> tuple[str, ...]: + parts = tuple(part for part in ("year", "month", "day") if getattr(self, part)) + if not parts and (hasattr(self, "_token_weekday") or self.time): + # A weekday or a time on its own is resolved to a full date by + # _correct_for_time_frame. + parts = ("year", "month", "day") + if self.time: + parts += ("time",) + return parts + def _get_datetime_obj(self, **params: Any) -> datetime: try: return datetime(**params) @@ -687,7 +700,7 @@ def parse( settings: "Settings", tz: tzinfo | None = None, date_order: str | None = None, - ) -> tuple[datetime, str | None]: + ) -> tuple[datetime, str | None, tuple[str, ...]]: tokens = list(tokenizer(datestring).tokenize()) date_order = date_order or settings.DATE_ORDER try: @@ -718,7 +731,7 @@ def parse( period = po._get_period() - return dateobj, period + return dateobj, period, po._get_parts() def _parse( self, token_type: int, token: str, skip_component: str | None = None diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 8c6ef20af..7403171d6 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -73,35 +73,44 @@ def find_date_separator(format: str) -> str | None: # noqa: A002 return None -def _get_missing_parts(fmt: str) -> list[str]: - """ - Return a list containing missing parts (day, month, year) - from a date format checking its directives - """ +_PART_DIRECTIVES = { + "year": ["%y", "%-y", "%Y"], + # %j (day of year) encodes month implicitly: a successful strptime with %j always + # populates the month field, so %j should count as providing month information. + "month": ["%b", "%B", "%m", "%-m", "%j", "%-j"], + "day": ["%d", "%-d", "%j", "%-j"], + "time": ["%H", "%-H", "%I", "%-I", "%M", "%-M", "%S", "%-S"], +} + + +def _get_parts(fmt: str) -> tuple[str, ...]: + """Return a tuple with the parts (year, month, day, time) that a date format + provides, based on its directives.""" + complete_week_date = False if "%U" in fmt or "%W" in fmt or "%V" in fmt: # A year, week number and weekday determine the complete date. Consume # %% pairs so literal directive names do not count as date components. directives = set(re.findall(r"%[%UWVwuAaYyG]", fmt)) - if ( + complete_week_date = bool( directives & {"%U", "%W", "%V"} and directives & {"%w", "%u", "%a", "%A"} and directives & {"%Y", "%y", "%G"} - ): - return [] - - directive_mapping = { - "day": ["%d", "%-d", "%j", "%-j"], - # %j (day of year) encodes month implicitly: a successful strptime with %j always - # populates the month field, so %j should count as providing month information. - "month": ["%b", "%B", "%m", "%-m", "%j", "%-j"], - "year": ["%y", "%-y", "%Y"], - } + ) + return tuple( + part + for part, directives in _PART_DIRECTIVES.items() + if (complete_week_date and part != "time") + or any(directive in fmt for directive in directives) + ) + - return [ - field - for field in ("day", "month", "year") - if not any(directive in fmt for directive in directive_mapping[field]) - ] +def _get_missing_parts(fmt: str) -> list[str]: + """ + Return a list containing missing parts (day, month, year) + from a date format checking its directives + """ + parts = _get_parts(fmt) + return [field for field in ("day", "month", "year") if field not in parts] def get_timezone_from_tz_string(tz_string: str) -> tzinfo: diff --git a/docs/settings.rst b/docs/settings.rst index af6dd116a..ad13fc63f 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -207,7 +207,7 @@ Language Detection >>> from dateparser.date import DateDataParser >>> DateDataParser(settings={'SKIP_TOKENS': ['de']}).get_date_data(u'27 Haziran 1981 de') # Turkish (at 27 June 1981) - DateData(date_obj=datetime.datetime(1981, 6, 27, 0, 0), period='day', locale='tr') + DateData(date_obj=datetime.datetime(1981, 6, 27, 0, 0), period='day', locale='tr', parts=('year', 'month', 'day')) ``NORMALIZE``: applies unicode normalization (removing accents, diacritics...) when parsing the words. Defaults to True. @@ -282,7 +282,7 @@ Defaults to ``False``. >>> ddp = DateDataParser(settings={'RETURN_TIME_AS_PERIOD': True}) >>> ddp.get_date_data('vr jan 24, 2014 12:49') - DateData(date_obj=datetime.datetime(2014, 1, 24, 12, 49), period='time', locale='nl') + DateData(date_obj=datetime.datetime(2014, 1, 24, 12, 49), period='time', locale='nl', parts=('year', 'month', 'day', 'time')) ``PARSERS``: it is a list of names of parsers to try, allowing to customize which parsers are tried against the input date string, and in which order they are diff --git a/docs/usage.rst b/docs/usage.rst index e8ca40f4a..7fe8955a2 100644 --- a/docs/usage.rst +++ b/docs/usage.rst @@ -17,8 +17,8 @@ See :ref:`performance` for ways to make parsing faster. >>> ddp = DateDataParser(languages=['de', 'nl']) >>> ddp.get_date_data('vr jan 24, 2014 12:49') - DateData(date_obj=datetime.datetime(2014, 1, 24, 12, 49), period='day', locale='nl') + DateData(date_obj=datetime.datetime(2014, 1, 24, 12, 49), period='day', locale='nl', parts=('year', 'month', 'day', 'time')) >>> ddp.get_date_data('18.10.14 um 22:56 Uhr') - DateData(date_obj=datetime.datetime(2014, 10, 18, 22, 56), period='day', locale='de') + DateData(date_obj=datetime.datetime(2014, 10, 18, 22, 56), period='day', locale='de', parts=('year', 'month', 'day', 'time')) >>> ddp.get_date_data('11 July 2012') - DateData(date_obj=None, period='day', locale=None) + DateData(date_obj=None, period='day', locale=None, parts=()) diff --git a/tests/test_date.py b/tests/test_date.py index e7394170f..f5c32c4a3 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1540,5 +1540,41 @@ def test_timestamp_with_wrong_length(self, date_string: str) -> None: self.assertEqual(date.get_date_from_timestamp(date_string, None), None) +YMD = ("year", "month", "day") + + +@pytest.mark.parametrize( + ("date_string", "date_formats", "settings", "expected"), + [ + ("2017", None, None, ("year",)), + ("January 2017", None, None, ("year", "month")), + ("22 May", None, None, ("month", "day")), + ("22 May 2017", None, None, YMD), + ("22 May 2017 10:30", None, None, (*YMD, "time")), + ("May 2017 4pm", None, None, ("year", "month", "time")), + ("Monday", None, None, YMD), + ("4pm", None, None, (*YMD, "time")), + ("22/05", ["%d/%m"], None, ("month", "day")), + ("22/05 10:30", ["%d/%m %H:%M"], None, ("month", "day", "time")), + ("20170522", None, {"DATE_ORDER": "YMD", "PARSERS": ["no-spaces-time"]}, YMD), + ("1439251200", None, None, (*YMD, "time")), + ("2 years ago", None, None, ("year",)), + ("3 months ago", None, None, ("year", "month")), + ("yesterday", None, None, YMD), + ("tomorrow 4pm", None, None, (*YMD, "time")), + ("2 hours ago", None, None, (*YMD, "time")), + ("foo", None, None, ()), + ], +) +def test_parts( + date_string: str, + date_formats: list[str] | None, + settings: dict[str, Any] | None, + expected: tuple[str, ...], +) -> None: + parser = date.DateDataParser(languages=["en"], settings=settings) + assert parser.get_date_data(date_string, date_formats).parts == expected + + if __name__ == "__main__": unittest.main() diff --git a/tests/test_date_data.py b/tests/test_date_data.py index 57103fbd0..21f055e04 100644 --- a/tests/test_date_data.py +++ b/tests/test_date_data.py @@ -38,13 +38,13 @@ def test_set_item_like_dict_keyerror(self) -> None: datetime(year=2020, month=10, day=28), "day", "en", - "DateData(date_obj=datetime.datetime(2020, 10, 28, 0, 0), period='day', locale='en')", + "DateData(date_obj=datetime.datetime(2020, 10, 28, 0, 0), period='day', locale='en', parts=())", ), ( datetime(year=2014, month=5, day=29, hour=3, minute=2), "day", "es", - "DateData(date_obj=datetime.datetime(2014, 5, 29, 3, 2), period='day', locale='es')", + "DateData(date_obj=datetime.datetime(2014, 5, 29, 3, 2), period='day', locale='es', parts=())", ), ( datetime( @@ -58,22 +58,32 @@ def test_set_item_like_dict_keyerror(self) -> None: ), "time", "fr", - "DateData(date_obj=datetime.datetime(2028, 7, 31, 3, 2, 12, 601265), period='time', locale='fr')", + "DateData(date_obj=datetime.datetime(2028, 7, 31, 3, 2, 12, 601265), period='time', locale='fr', parts=())", ), ( datetime(year=1994, month=8, day=1), "month", "ca", - "DateData(date_obj=datetime.datetime(1994, 8, 1, 0, 0), period='month', locale='ca')", + "DateData(date_obj=datetime.datetime(1994, 8, 1, 0, 0), period='month', locale='ca', parts=())", ), ( datetime(year=2033, month=10, day=12), "month", None, - "DateData(date_obj=datetime.datetime(2033, 10, 12, 0, 0), period='month', locale=None)", + "DateData(date_obj=datetime.datetime(2033, 10, 12, 0, 0), period='month', locale=None, parts=())", + ), + ( + None, + "day", + None, + "DateData(date_obj=None, period='day', locale=None, parts=())", + ), + ( + None, + "year", + "fr", + "DateData(date_obj=None, period='year', locale='fr', parts=())", ), - (None, "day", None, "DateData(date_obj=None, period='day', locale=None)"), - (None, "year", "fr", "DateData(date_obj=None, period='year', locale='fr')"), ], ) def test_repr( diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index cae6e6130..3675ef00c 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -23,7 +23,7 @@ def setUp(self) -> None: self.parser: DateDataParser = NotImplemented self.result: DateData = NotImplemented self.date_parser: Mock = NotImplemented - self.date_result: tuple[datetime, str | None] = NotImplemented + self.date_result: tuple[datetime, str | None, tuple[str, ...]] = NotImplemented @parameterized.expand( [ @@ -1843,10 +1843,12 @@ def test_use_given_language_order_setting_fixes_top_level_parse(self) -> None: def given_parser(self, *args: Any, **kwds: Any) -> None: def collecting_get_date_data( - parse: Callable[..., tuple[datetime, str | None]], - ) -> Callable[..., tuple[datetime, str | None]]: + parse: Callable[..., tuple[datetime, str | None, tuple[str, ...]]], + ) -> Callable[..., tuple[datetime, str | None, tuple[str, ...]]]: @wraps(parse) - def wrapped(*args: Any, **kwargs: Any) -> tuple[datetime, str | None]: + def wrapped( + *args: Any, **kwargs: Any + ) -> tuple[datetime, str | None, tuple[str, ...]]: self.date_result = parse(*args, **kwargs) return self.date_result diff --git a/tests/test_french_republican.py b/tests/test_french_republican.py index 94e08b96b..6d304edf8 100644 --- a/tests/test_french_republican.py +++ b/tests/test_french_republican.py @@ -28,37 +28,48 @@ def test_dates(self, date_string: str, expected: datetime) -> None: assert date_data is not None self.assertEqual(date_data.date_obj, expected) self.assertEqual(date_data.period, "day") + self.assertEqual(date_data.parts, ("year", "month", "day")) @parameterized.expand( [ - param("An XIV", datetime(1805, 9, 23), "year"), - param("An 3.eme", datetime(1794, 9, 22), "year"), - param("An IVme.", datetime(1795, 9, 23), "year"), - param("Sans-culottides an I", datetime(1793, 9, 17), "month"), + param("An XIV", datetime(1805, 9, 23), "year", ("year",)), + param("An 3.eme", datetime(1794, 9, 22), "year", ("year",)), + param("An IVme.", datetime(1795, 9, 23), "year", ("year",)), + param( + "Sans-culottides an I", + datetime(1793, 9, 17), + "month", + ("year", "month"), + ), ] ) def test_prefer_first( - self, date_string: str, expected: datetime, period: str + self, + date_string: str, + expected: datetime, + period: str, + parts: tuple[str, ...], ) -> None: first = settings.replace( PREFER_DAY_OF_MONTH="first", PREFER_MONTH_OF_YEAR="first" ) self.assertEqual( - _french_republican_parser.parse(date_string, first), (expected, period) + _french_republican_parser.parse(date_string, first), + (expected, period, parts), ) def test_prefer_current(self) -> None: current = settings.replace(RELATIVE_BASE=datetime(2026, 9, 29)) self.assertEqual( _french_republican_parser.parse("an VIII", current), - (datetime(1799, 9, 29), "year"), + (datetime(1799, 9, 29), "year", ("year",)), ) def test_prefer_last(self) -> None: last = settings.replace(PREFER_DAY_OF_MONTH="last", PREFER_MONTH_OF_YEAR="last") self.assertEqual( _french_republican_parser.parse("an III", last), - (datetime(1795, 9, 22), "year"), + (datetime(1795, 9, 22), "year", ("year",)), ) @parameterized.expand( diff --git a/tests/test_parser.py b/tests/test_parser.py index 2a2325022..96a80d7c9 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -425,8 +425,8 @@ def given_settings(self, settings: Settings | dict[str, Any] | None = None) -> N def when_date_is_parsed(self, date_string: str) -> None: try: - self.result: tuple[datetime, str] | str = self.parser.parse( - date_string, self.settings + self.result: tuple[datetime, str, tuple[str, ...]] | str = ( + self.parser.parse(date_string, self.settings) ) except Exception as error: self.error = error From e77f110b7d48101a3caaf7932970f05a6df99b40 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 14:44:37 +0200 Subject: [PATCH 086/107] Parse "the Nth of last/this/next month" as a day of that month (#1414) --- dateparser/freshness_date_parser.py | 15 +++++++++++++++ tests/test_freshness_date_parser.py | 6 ++++++ 2 files changed, 21 insertions(+) diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index 14b881742..ecf63e86c 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -23,6 +23,8 @@ _UNITS = r"decade|year|month|week|day|hour|minute|second" PATTERN = re.compile(rf"([+-]?\s*\d++[.,]?\d*+)\s*({_UNITS})\b", re.I | re.S | re.U) +# "the 1st of last month" translates to " 1 1 month ago". +_DAY_OF_MONTH = re.compile(r"^\s*(\d{1,2})\s+(?=(?:in\s+)?\d+\s+month\b)") class FreshnessDateDataParser: @@ -53,6 +55,10 @@ def parse( # noqa: PLR0912 ) -> tuple[datetime | None, str | None, tuple[str, ...]]: date_string = strip_braces(date_string) date_string, ptz = pop_tz_offset_from_string(date_string) + day = None + if match := _DAY_OF_MONTH.match(date_string): + day = int(match[1]) + date_string = date_string[match.end() :] _time = self._parse_time(date_string, settings) _settings_tz = settings.TIMEZONE.lower() @@ -98,6 +104,15 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: date_string, now, settings.PREFER_DATES_FROM ) + if date and day is not None: + if period != "month": + return None, None + try: + date = date.replace(day=day) + except ValueError: + return None, None + period = "day" + if date: if period == "year": date = set_correct_month_from_settings(date, settings, date.month) diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index 7f6938ed1..a0b662d37 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -2367,6 +2367,8 @@ def test_relative_future_dates( [ param("15th of Aug, 2014 Diane Bennett"), param("4 heures ago"), + param("the 31st of this month"), + param("the 1st of last month 2 days ago"), ] ) def test_insane_dates(self, date_string: str) -> None: @@ -2604,6 +2606,10 @@ def test_freshness_date_with_timezone_utc_offset( param("in 10.75 minutes", date(2010, 6, 4), time(13, 25, 45)), param("in 1.5 days", date(2010, 6, 6), time(1, 15)), param("0,5 hours ago", date(2010, 6, 4), time(12, 45)), + # Day of a relative month + param("the 1st of last month", date(2010, 5, 1), time(13, 15)), + param("the 1st of this month", date(2010, 6, 1), time(13, 15)), + param("30th of next month at 5pm", date(2010, 7, 30), time(17, 0)), ] ) def test_freshness_date_with_relative_base( From 6bd27c472665f821d128fe3ac8e1c8d03880c19c Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:10:34 +0200 Subject: [PATCH 087/107] Parse ISO 8601 fractional seconds written with a decimal comma (#1467) --- dateparser/date.py | 2 ++ tests/test_date.py | 4 ++++ tests/test_date_parser.py | 5 +++++ 3 files changed, 11 insertions(+) diff --git a/dateparser/date.py b/dateparser/date.py index 539f14174..45900d18f 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -96,6 +96,7 @@ r"(\d+)\.\s?(\d+)\.\s?(\d+)\.( u)?", flags=re.I | re.U ) RE_SANITIZE_PERIOD = re.compile(r"(?<=[^0-9\s])\.", flags=re.U) +RE_SANITIZE_DECIMAL_COMMA = re.compile(r"(?<=\d:\d{2}:\d{2}),(?=\d{3})") RE_SANITIZE_ON = re.compile(r"^.*?on:\s+(.*)") RE_SANITIZE_APOSTROPHE = re.compile("|".join(APOSTROPHE_LOOK_ALIKE_CHARS)) RE_SANITIZE_DASH = re.compile("|".join(DASH_LOOK_ALIKE_CHARS)) @@ -189,6 +190,7 @@ def sanitize_date(date_string: str) -> str: ) # extra '.' and 'u' interferes with parsing relative fractional dates date_string = sanitize_spaces(date_string) date_string = RE_SANITIZE_PERIOD.sub("", date_string) + date_string = RE_SANITIZE_DECIMAL_COMMA.sub(".", date_string) date_string = RE_SANITIZE_ON.sub(r"\1", date_string) date_string = RE_TRIM_COLONS.sub(r"\1", date_string) date_string = RE_SANITIZE_APOSTROPHE.sub("'", date_string) diff --git a/tests/test_date.py b/tests/test_date.py index f5c32c4a3..bc17713fd 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1356,6 +1356,10 @@ def test_remove_year_in_russian(self) -> None: self.assertEqual(date.sanitize_date("2005 г. 15:24"), "2005 15:24") self.assertEqual(date.sanitize_date("Авг."), "Авг") + def test_sanitize_date_decimal_comma(self) -> None: + self.assertEqual(date.sanitize_date("06:38:49,946"), "06:38:49.946") + self.assertEqual(date.sanitize_date("06:38:49,12 June"), "06:38:49,12 June") + def test_sanitize_date_colons(self) -> None: self.assertEqual(date.sanitize_date("2019:"), "2019") self.assertEqual(date.sanitize_date("31/07/2019:"), "31/07/2019") diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 3675ef00c..a005f8a6b 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1012,6 +1012,11 @@ def test_error_should_be_raised_for_invalid_dates_with_too_large_day_number( languages=["en"], expected=datetime(2015, 5, 2, 10, 20, 19), ), + param( + "2021-04-29T06:38:49,946902974+02:00", + languages=["fr"], + expected=datetime(2021, 4, 29, 6, 38, 49, 946902), + ), ] ) def test_iso_datestamp_format_should_always_parse( From ab3027d7d6f62c33b00f5490d4f33811d4699e16 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:10:50 +0200 Subject: [PATCH 088/107] Keep full stops between digits in search_dates sentences (#1471) --- dateparser/languages/locale.py | 2 ++ tests/test_search.py | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 2684a0fc5..e30316ff1 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -422,6 +422,8 @@ def _sentence_split( 5: r"[\r\n]+", # Thai 6: r"[\r\n؟!\.…]+(?:\s|$)+", } # Arabic and Farsi + # Full stops of fractional seconds and of dates like 13.07.2016. + abbreviation_string += r"(?!(?<=:\d\d)\.\d|(?<=\d)\.\d+\.\d|(?<=\d\.\d+)\.\d)" if "sentence_splitter_group" not in self.info: split_reg = abbreviation_string + splitters_dict[1] sentences = re.split(split_reg, string) diff --git a/tests/test_search.py b/tests/test_search.py index 9d6a4728f..1de047db9 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1041,6 +1041,24 @@ def test_detection(self, shortname: str, text: str) -> None: settings=None, expected=[("DECEMBER 21 19", datetime.datetime(2019, 12, 21, 0, 0))], ), + # Full stops between digits + param( + text="Sampled on 2019-10-19 20:28:35.973000 by the sensor", + languages=None, + settings=None, + expected=[ + ( + "2019-10-19 20:28:35.973000", + datetime.datetime(2019, 10, 19, 20, 28, 35, 973000), + ) + ], + ), + param( + text="test 13.07.2016 test", + languages=None, + settings=None, + expected=[("13.07.2016", datetime.datetime(2016, 7, 13, 0, 0))], + ), param( text="bonjour, pouvez vous me joindre svp par telephone 08 11 58 54 41", languages=None, From a4956505740db92714838ea076d1b5d9f4f96555 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:11:43 +0200 Subject: [PATCH 089/107] Try other meanings of ambiguous words when a date does not parse (#1491) --- dateparser/date.py | 94 ++++++++++++++++++++++++------ dateparser/languages/dictionary.py | 22 ++++++- dateparser/languages/locale.py | 39 ++++++++++++- tests/test_date_parser.py | 31 ++++++++++ 4 files changed, 164 insertions(+), 22 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index 45900d18f..e4f4c76fa 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -3,6 +3,7 @@ from collections.abc import Callable, Iterable, Iterator from collections.abc import Set as AbstractSet from datetime import date, datetime, timedelta, timezone, tzinfo +from itertools import count from typing import TYPE_CHECKING, Any, TypeVar import regex as re @@ -319,6 +320,7 @@ def __init__( date_formats: Iterable[str] | None, settings: Settings | None = None, ignore_surrounding_text: bool = False, + alternatives: bool = False, ) -> None: assert settings is not None self._settings = settings @@ -331,6 +333,8 @@ def __init__( self.date_string = date_string self.date_formats = date_formats self._ignore_surrounding_text = ignore_surrounding_text + self._alternatives = alternatives + self._alternative = 0 self._translated_date: str | None = None self._translated_date_with_formatting: str | None = None self._parsers: dict[str, Callable[[], DateData | None]] = { @@ -350,13 +354,32 @@ def parse( date_formats: Iterable[str] | None = None, settings: Settings | None = None, ignore_surrounding_text: bool = False, + alternatives: bool = False, ) -> "DateData | None": instance = cls( - locale, date_string, date_formats, settings, ignore_surrounding_text + locale, + date_string, + date_formats, + settings, + ignore_surrounding_text, + alternatives, ) return instance._parse() def _parse(self) -> "DateData | None": + if not self._alternatives: + return self._parse_translation() + for self._alternative in count(1): + self._translated_date = self._translate(keep_formatting=False) + if self._translated_date is None: + return None + self._translated_date_with_formatting = None + date_data = self._parse_translation() + if date_data: + return date_data + return None + + def _parse_translation(self) -> "DateData | None": for parser_name in self._settings.PARSERS: date_data = self._parsers[parser_name]() if self._is_valid_date_data(date_data): @@ -445,24 +468,27 @@ def _try_given_formats(self) -> "DateData | None": settings=self._settings, ) + def _translate(self, keep_formatting: bool) -> str | None: + return self.locale._translate( + self.date_string, + keep_formatting=keep_formatting, + settings=self._settings, + ignore_surrounding_text=self._ignore_surrounding_text, + alternative=self._alternative, + ) + def _get_translated_date(self) -> str: if self._translated_date is None: - self._translated_date = self.locale.translate( - self.date_string, - keep_formatting=False, - settings=self._settings, - ignore_surrounding_text=self._ignore_surrounding_text, - ) + self._translated_date = self._translate(keep_formatting=False) + assert self._translated_date is not None return self._translated_date def _get_translated_date_with_formatting(self) -> str: if self._translated_date_with_formatting is None: - self._translated_date_with_formatting = self.locale.translate( - self.date_string, - keep_formatting=True, - settings=self._settings, - ignore_surrounding_text=self._ignore_surrounding_text, + self._translated_date_with_formatting = self._translate( + keep_formatting=True ) + assert self._translated_date_with_formatting is not None return self._translated_date_with_formatting def _is_valid_date_data(self, date_data: object) -> bool: @@ -707,24 +733,54 @@ def _parse_using_applicable_locales( date_formats: Iterable[str] | None, ignore_surrounding_text: bool = False, ) -> DateData | None: + locales = [] for locale in self._get_applicable_locales( date_string, ignore_surrounding_text=ignore_surrounding_text ): - parsed_date = _DateLocaleParser.parse( + locales.append(locale) + parsed_date = self._parse_using_locale( + locale, date_string, date_formats, ignore_surrounding_text + ) + if parsed_date: + return parsed_date + # Words with several meanings (e.g. Spanish "mar", Tuesday or March) + # get their other meanings only once no locale can parse the string + # with the default ones. + for locale in locales: + parsed_date = self._parse_using_locale( locale, date_string, date_formats, - settings=self._settings, - ignore_surrounding_text=ignore_surrounding_text, + ignore_surrounding_text, + alternatives=True, ) if parsed_date: - parsed_date["locale"] = locale.shortname - if self.try_previous_locales: - with self._lock: - self.previous_locales[locale] = None return parsed_date return None + def _parse_using_locale( + self, + locale: "Locale", + date_string: str, + date_formats: Iterable[str] | None, + ignore_surrounding_text: bool, + alternatives: bool = False, + ) -> DateData | None: + parsed_date = _DateLocaleParser.parse( + locale, + date_string, + date_formats, + settings=self._settings, + ignore_surrounding_text=ignore_surrounding_text, + alternatives=alternatives, + ) + if parsed_date: + parsed_date["locale"] = locale.shortname + if self.try_previous_locales: + with self._lock: + self.previous_locales[locale] = None + return parsed_date + def get_date_tuple(self, *args: Any, **kwargs: Any) -> tuple[Any, ...]: date_data = self.get_date_data(*args, **kwargs) fields = {k: v for k, v in date_data.__dict__.items() if k != "parts"} diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index 0572c2197..cdb55a314 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -110,10 +110,14 @@ def __init__( if "pertain" in locale_info: pertain = map(methodcaller("lower"), locale_info["pertain"]) dictionary.update(dict.fromkeys(pertain)) + meanings: dict[str, list[str]] = {} for word in KNOWN_WORD_TOKENS: if word in locale_info: - translations = map(methodcaller("lower"), locale_info[word]) + translations = list(map(methodcaller("lower"), locale_info[word])) dictionary.update(zip_longest(translations, [], fillvalue=word)) + for translation in translations: + meanings.setdefault(translation, []).append(word) + self._meanings = meanings # Some locales (mostly Romance languages) reuse the same abbreviation for a # weekday and a month (e.g. Italian "mar" is both "martedì" and "marzo"). @@ -183,6 +187,15 @@ def __getitem__(self, key: str) -> str | None: def __iter__(self) -> Iterator[str]: return chain(self._settings.SKIP_TOKENS, iter(self._dictionary)) + def _get_meanings(self, key: str) -> list[str]: + """Return every meaning of *key*, starting with the one that indexing + returns, if any.""" + default = self[key] + if default is None: + return [] + others = [m for m in self._meanings.get(key, ()) if m != default] + return [default, *others] + def are_tokens_valid(self, tokens: Iterable[str]) -> bool: """ Check if tokens are valid tokens for the locale. @@ -486,4 +499,11 @@ def _normalize(self) -> None: if key in (self.info.get("skip", []) + self.info.get("pertain", [])): new_dict[normalized] = self._dictionary[key] self._dictionary = new_dict + meanings: dict[str, list[str]] = {} + for key, key_meanings in self._meanings.items(): + normalized_meanings = meanings.setdefault(normalize_unicode(key), []) + normalized_meanings.extend( + m for m in key_meanings if m not in normalized_meanings + ) + self._meanings = meanings self._relative_strings = list(map(normalize_unicode, self._relative_strings)) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index e30316ff1..ae9832986 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -1,7 +1,7 @@ import copy import threading from collections.abc import Iterable, Iterator, Mapping, Sequence -from itertools import chain +from itertools import chain, islice, product from typing import TYPE_CHECKING, Any, TypeVar import regex as re @@ -18,6 +18,7 @@ _T = TypeVar("_T") NUMERAL_PATTERN = re.compile(r"(\d+)", re.U) +_MAX_TRANSLATIONS = 16 def _parse_bool(value: object) -> bool: @@ -154,7 +155,7 @@ def clean_dictionary( del dictionary[del_key] return dictionary - def translate( # noqa: PLR0912 + def translate( self, date_string: str, keep_formatting: bool = False, @@ -180,6 +181,29 @@ def translate( # noqa: PLR0912 :return: translated date string. """ + translation = self._translate( + date_string, + keep_formatting=keep_formatting, + settings=settings, + ignore_surrounding_text=ignore_surrounding_text, + ) + assert translation is not None + return translation + + def _translate( # noqa: PLR0912, PLR0915 + self, + date_string: str, + keep_formatting: bool = False, + settings: "Settings | None" = None, + ignore_surrounding_text: bool = False, + alternative: int = 0, + ) -> str | None: + """Return the translation of *date_string* that reads its words with + several meanings according to the combination of meanings with index + *alternative*, where 0 is the combination that :meth:`translate` uses, + or ``None`` if there is no such combination.""" + if alternative >= _MAX_TRANSLATIONS: + return None date_string = self._translate_numerals(date_string) assert settings is not None if settings.NORMALIZE: @@ -194,6 +218,7 @@ def translate( # noqa: PLR0912 relative_translations = self._get_relative_translations(settings=settings) + ambiguous_tokens: dict[int, list[str]] = {} # A token that could be either a weekday or a month abbreviation (see # Dictionary._weekday_month_conflicts) can only be the weekday if another, # unambiguous month is present elsewhere in the string - otherwise it keeps @@ -218,6 +243,16 @@ def translate( # noqa: PLR0912 elif word in dictionary: fallback = word if keep_formatting and not word.isalpha() else "" date_string_tokens[i] = dictionary[word] or fallback + meanings = dictionary._get_meanings(word) + if len(meanings) > 1: + ambiguous_tokens[i] = meanings + if alternative: + combinations = product(*ambiguous_tokens.values()) + combination = next(islice(combinations, alternative, None), None) + if combination is None: + return None + for i, meaning in zip(ambiguous_tokens, combination, strict=True): + date_string_tokens[i] = meaning if "in" in date_string_tokens: date_string_tokens = self._clear_future_words(date_string_tokens) diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index a005f8a6b..e6e60962e 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -2207,6 +2207,37 @@ def test_weekday_month_abbreviation_conflict_is_read_as_month( if expected_day is not None: self.assertEqual(expected_day, result.day) + @parameterized.expand( + [ + param("mar 5 mar 2019", "it", datetime(2019, 3, 5)), + param("mar, 07 giu 2022 08:56:47", "it", datetime(2022, 6, 7, 8, 56, 47)), + param("seg, 3 fev 2020", "pt", datetime(2020, 2, 3)), + param("luni, 3 mar 2020", "ro", datetime(2020, 3, 3)), + param("3월 5일 2020", "ko", datetime(2020, 3, 5)), + param("mar 2019", "es", datetime(2019, 3, 15)), + ] + ) + def test_word_with_several_meanings( + self, date_string: str, language: str, expected: datetime + ) -> None: + settings = {"RELATIVE_BASE": datetime(2020, 1, 15)} + self.assertEqual( + expected, parse(date_string, languages=[language], settings=settings) + ) + + def test_word_with_several_meanings_with_date_formats(self) -> None: + self.assertEqual( + datetime(2022, 6, 7, 8, 56, 47), + parse( + "mar, 07 giu 2022 08:56:47", + date_formats=["%a, %d %b %Y %H:%M:%S"], + languages=["it"], + ), + ) + + def test_word_with_too_many_meaning_combinations(self) -> None: + self.assertIsNone(parse("mar mar mar mar mar", languages=["it"])) + if __name__ == "__main__": unittest.main() From e64dd084e3dceeb4828ac8a09c6a691f1e662804 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:28:49 +0200 Subject: [PATCH 090/107] Find dates joined by words that search skips, like "and" (#1488) --- dateparser/search/search.py | 38 ++++++++++++++++++++++++++- tests/test_search.py | 51 +++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+), 1 deletion(-) diff --git a/dateparser/search/search.py b/dateparser/search/search.py index ecfb5ae48..2db342a5c 100644 --- a/dateparser/search/search.py +++ b/dateparser/search/search.py @@ -181,6 +181,42 @@ def split_by_relative_expression( ) return possible_splits + def split_around_skipped_words( + self, item: str, original: str, language: Locale, settings: Settings + ) -> list[list[list[str]]]: + """Split a chunk by spaces, ignoring the words its translation skips. + + Words like "and" or "of" are left out of the translation but not of + the original text, so splitting both by spaces does not line them up. + Each part of the original text spans from its first word that is not + skipped to its last one. + """ + words = original.split() + kept = [] + for index, word in enumerate(words): + translation = language.translate(word, settings=settings).split() + if len(translation) > 1: + return [] + if translation: + kept.append(index) + item_words = item.split() + if len(kept) == len(words) or len(kept) != len(item_words): + return [] + sizes = [1] if len(kept) <= 3 else [1, 2, 3] + possible_splits = [] + for size in sizes: + starts = range(0, len(kept), size) + possible_splits.append( + [ + [" ".join(item_words[i : i + size]) for i in starts], + [ + " ".join(words[kept[i] : kept[i : i + size][-1] + 1]) + for i in starts + ], + ] + ) + return possible_splits + def split_off_leading_number( self, parser: DateDataParser, item: str, original: str ) -> list[list[list[str]]]: @@ -215,7 +251,7 @@ def split_if_not_parsed( # splits keeps being split exactly the way it is split today. possible_splits = self.split_by_relative_expression( parser, item, original, language, settings - ) + ) or self.split_around_skipped_words(item, original, language, settings) return possible_splits def parse_item( diff --git a/tests/test_search.py b/tests/test_search.py index 1de047db9..74c5b7684 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -577,6 +577,57 @@ def test_search_and_parse( ) self.assertEqual(result, expected) + @parameterized.expand( + [ + param( + "en", + "between Friday and Monday", + [ + ("Friday", datetime.datetime(1999, 12, 31, 0, 0)), + ("Monday", datetime.datetime(1999, 12, 27, 0, 0)), + ], + ), + param( + "en", + "Sept 1st and Oct 10th", + [ + ("Sept 1st", datetime.datetime(2000, 9, 1, 0, 0)), + ("Oct 10th", datetime.datetime(2000, 10, 10, 0, 0)), + ], + ), + param( + "es", + "1 de junio de 1998 y 5 de julio de 1999", + [ + ("1 de junio de 1998", datetime.datetime(1998, 6, 1, 0, 0)), + ("5 de julio de 1999", datetime.datetime(1999, 7, 5, 0, 0)), + ], + ), + param( + "de", + "Freitag und Montag", + [ + ("Freitag", datetime.datetime(1999, 12, 31, 0, 0)), + ("Montag", datetime.datetime(1999, 12, 27, 0, 0)), + ], + ), + ] + ) + @apply_settings + def test_search_dates_joined_by_skipped_words( + self, + shortname: str, + string: str, + expected: list[tuple[str, datetime.datetime]], + settings: Settings | dict[str, Any] | None = None, + ) -> None: + assert isinstance(settings, Settings) + settings = settings.replace(RELATIVE_BASE=datetime.datetime(2000, 1, 1)) + result = self.exact_language_search.search_parse( + shortname, string, settings=settings + ) + self.assertEqual(result, expected) + @parameterized.expand( [ # English From 41ca9d01049db5e04a95035d2e5bf153d63b364c Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:39:22 +0200 Subject: [PATCH 091/107] =?UTF-8?q?Parse=20Egyptian=20and=20informal=20?= =?UTF-8?q?=D8=A9=E2=86=92=D9=87=20spellings=20of=20Arabic=20date=20words?= =?UTF-8?q?=20(#1493)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dateparser/data/date_translation_data/ar.py | 17 ++++++++++++----- .../date_translation_data/ar.yaml | 11 +++++++++++ tests/test_languages.py | 6 ++++++ 3 files changed, 29 insertions(+), 5 deletions(-) diff --git a/dateparser/data/date_translation_data/ar.py b/dateparser/data/date_translation_data/ar.py index ddb1a1d66..d2213813d 100644 --- a/dateparser/data/date_translation_data/ar.py +++ b/dateparser/data/date_translation_data/ar.py @@ -17,10 +17,14 @@ "مايو" ], "june": [ - "يونيو" + "يونيو", + "يونيه", + "يونية" ], "july": [ - "يوليو" + "يوليو", + "يوليه", + "يولية" ], "august": [ "أغسطس" @@ -51,7 +55,8 @@ "الخميس" ], "friday": [ - "الجمعة" + "الجمعة", + "الجمعه" ], "saturday": [ "السبت" @@ -71,7 +76,8 @@ "year": [ "السنة", "عام", - "سنة" + "سنة", + "السنه" ], "month": [ "الشهر", @@ -98,7 +104,8 @@ ], "second": [ "الثواني", - "ثانية" + "ثانية", + "ثانيه" ], "relative-type": { "0 day ago": [ diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml index c5c39284f..6996d30ff 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml @@ -6,12 +6,22 @@ sentence_splitter_group: 6 skip: ["الساعة", "في", "مساءً", "هـ"] +june: + - يونيه + - يونية +july: + - يوليه + - يولية + monday: - الإثنين +friday: + - الجمعه year: - عام - سنة + - السنه month: - شهر week: @@ -26,6 +36,7 @@ minute: - دقائق second: - ثانية + - ثانيه ago: - منذ diff --git a/tests/test_languages.py b/tests/test_languages.py index 334d054df..362aae146 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -159,6 +159,10 @@ def setUp(self) -> None: # Arabic param("ar", "6 يناير، 2015، الساعة 05:16 مساءً", "6 january 2015 05:16 pm"), param("ar", "7 يناير، 2015، الساعة 11:00 صباحاً", "7 january 2015 11:00 am"), + param("ar", "الجمعه 5 يونيه 2020", "friday 5 june 2020"), + param("ar", "6 يونية 2020", "6 june 2020"), + param("ar", "7 يوليه 2020", "7 july 2020"), + param("ar", "8 يولية 2020", "8 july 2020"), # Vietnamese param("vi", "Thứ Năm, ngày 8 tháng 1 năm 2015", "thursday 8 january 2015"), param( @@ -1256,6 +1260,8 @@ def test_translation( param("ar", "يومين", "2 day"), param("ar", "أمس", "1 day ago"), param("ar", "4 عام", "4 year"), + param("ar", "4 السنه", "4 year"), + param("ar", "منذ 3 ثانيه", "ago 3 second"), param("ar", "منذ 2 ساعات", "ago 2 hour"), param("ar", "منذ ساعتين", "ago 2 hour"), param("ar", "اليوم السابق", "1 day ago"), From dd49b2dd2701cafcec6aabb593508249c261e04d Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 15:39:42 +0200 Subject: [PATCH 092/107] Match date_formats month and weekday names in the given languages (#1486) --- dateparser/date.py | 101 +++++++++++++++++++++++++++++++++++++++++++++ tests/test_date.py | 22 ++++++++++ 2 files changed, 123 insertions(+) diff --git a/dateparser/date.py b/dateparser/date.py index e4f4c76fa..dfd38cc47 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -1,4 +1,6 @@ import collections +import functools +import itertools import threading from collections.abc import Callable, Iterable, Iterator from collections.abc import Set as AbstractSet @@ -312,6 +314,85 @@ def parse_with_formats( return DateData(date_obj=None, period=period) +_MONTHS = ( + "january", + "february", + "march", + "april", + "may", + "june", + "july", + "august", + "september", + "october", + "november", + "december", +) +_WEEKDAYS = ( + "monday", + "tuesday", + "wednesday", + "thursday", + "friday", + "saturday", + "sunday", +) + + +@functools.lru_cache(maxsize=None) +def _get_name_translations(locale, month_form, weekday_form): + """Return a pattern matching the month and weekday names of *locale*, and + a mapping of each lowercase name to the English names it can stand for. + + *month_form* and *weekday_form* are ``"full"``, ``"abbr"`` or ``None``, + the English form to translate each kind of name into, or ``None`` to leave + that kind of name untranslated. + """ + translations = collections.defaultdict(list) + for words, form in ((_MONTHS, month_form), (_WEEKDAYS, weekday_form)): + if form is None: + continue + for word in words: + english = word if form == "full" else word[:3] + for name in locale.info.get(word, ()): + name = name.lower() + if english not in translations[name]: + translations[name].append(english) + if not translations: + return None, None + names = sorted(translations, key=len, reverse=True) + pattern = re.compile( + r"(? Date: Wed, 30 Sep 2026 16:08:40 +0200 Subject: [PATCH 093/107] Take the current date from the configured time zone (#1427) --- dateparser/calendars/minguo.py | 2 +- dateparser/date.py | 7 +++--- dateparser/freshness_date_parser.py | 7 +++--- dateparser/parser.py | 28 +++++++++++----------- dateparser/utils/__init__.py | 12 ++++++++++ tests/test_date.py | 2 ++ tests/test_date_parser.py | 36 ++++++++++++++++++++++++----- tests/test_freshness_date_parser.py | 2 +- tests/test_minguo.py | 16 +++++++++---- tests/test_search.py | 10 ++++---- 10 files changed, 85 insertions(+), 37 deletions(-) diff --git a/dateparser/calendars/minguo.py b/dateparser/calendars/minguo.py index 4af062990..31c4b8e48 100644 --- a/dateparser/calendars/minguo.py +++ b/dateparser/calendars/minguo.py @@ -43,7 +43,7 @@ def parse( settings: Settings, tz: tzinfo | None = None, date_order: str | None = None, - ) -> tuple[datetime, str | None]: + ) -> tuple[datetime, str | None, tuple[str, ...]]: return super(non_gregorian_parser, cls).parse( datestring, settings, tz, date_order or "YMD" ) diff --git a/dateparser/date.py b/dateparser/date.py index dfd38cc47..dfad417d8 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -4,7 +4,7 @@ import threading from collections.abc import Callable, Iterable, Iterator from collections.abc import Set as AbstractSet -from datetime import date, datetime, timedelta, timezone, tzinfo +from datetime import date, datetime, timedelta, tzinfo from itertools import count from typing import TYPE_CHECKING, Any, TypeVar @@ -22,6 +22,7 @@ _get_localzone, _get_missing_parts, _get_parts, + _now, apply_timezone_from_settings, get_next_leap_year, get_previous_leap_year, @@ -296,9 +297,7 @@ def parse_with_formats( period = "month" date_obj = set_correct_day_from_settings(date_obj, settings) - now = settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( - tzinfo=None - ) + now = settings.RELATIVE_BASE or _now(settings) if "year" in _missing: date_obj = date_obj.replace(year=now.year) elif "%y" in date_format and "%Y" not in date_format: diff --git a/dateparser/freshness_date_parser.py b/dateparser/freshness_date_parser.py index ecf63e86c..0780bb89a 100644 --- a/dateparser/freshness_date_parser.py +++ b/dateparser/freshness_date_parser.py @@ -50,7 +50,7 @@ def _parse_time(self, date_string: str, settings: "Settings") -> time | None: def get_local_tz(self) -> tzinfo: return _get_localzone() - def parse( # noqa: PLR0912 + def parse( # noqa: PLR0912, PLR0915 self, date_string: str, settings: "Settings" ) -> tuple[datetime | None, str | None, tuple[str, ...]]: date_string = strip_braces(date_string) @@ -106,12 +106,13 @@ def apply_time(dateobj: datetime, timeobj: time | None) -> datetime: if date and day is not None: if period != "month": - return None, None + return None, None, () try: date = date.replace(day=day) except ValueError: - return None, None + return None, None, () period = "day" + parts += ("day",) if date: if period == "year": diff --git a/dateparser/parser.py b/dateparser/parser.py index 92a30dab3..a3bfcf11b 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -1,7 +1,7 @@ import calendar import contextlib from collections.abc import Callable, Iterable, Iterator -from datetime import datetime, time, timedelta, timezone, tzinfo +from datetime import datetime, time, timedelta, tzinfo from functools import partial from io import StringIO from typing import TYPE_CHECKING, Any, ClassVar, Literal, overload @@ -12,6 +12,7 @@ from dateparser.utils import ( _get_missing_parts, _get_parts, + _now, get_last_day_of_month, get_next_leap_year, get_previous_leap_year, @@ -293,8 +294,10 @@ def __init__( # noqa: PLR0912, PLR0915 tokens: Iterable[tuple[str, int]], settings: "Settings", date_order: str | None = None, + tz: tzinfo | None = None, ) -> None: self.settings = settings + self._tz = tz self._date_order = date_order or settings.DATE_ORDER self.tokens = [(t[0].strip(), t[1]) for t in list(tokens)] self.filtered_tokens = [ @@ -525,9 +528,7 @@ def _get_correct_leap_year(self, prefer_dates_from: str, current_year: int) -> i return next_leap_year if next_leap_year_is_closer else previous_leap_year def _set_relative_base(self) -> None: - self.now = self.settings.RELATIVE_BASE or datetime.now(tz=timezone.utc).replace( - tzinfo=None - ) + self.now = self.settings.RELATIVE_BASE or _now(self.settings, self._tz) def _get_datetime_obj_params(self) -> dict[str, int]: if not self.now: @@ -650,13 +651,14 @@ def _correct_for_time_frame( # noqa: PLR0912, PLR0915 hasattr(self, "_token_weekday"), ] ): - # Convert dateobj to utc time to compare with self.now - try: - tz = tz or get_timezone_from_tz_string(self.settings.TIMEZONE) - tz_offset = tz.utcoffset(dateobj) - assert tz_offset is not None - except (pytz.UnknownTimeZoneError, pytz.NonExistentTimeError): - tz_offset = timedelta(hours=0) + tz_offset = timedelta(hours=0) + if self.settings.RELATIVE_BASE: + # Convert dateobj to utc time to compare with RELATIVE_BASE + try: + tz = tz or get_timezone_from_tz_string(self.settings.TIMEZONE) + tz_offset = tz.utcoffset(dateobj) or tz_offset + except (pytz.UnknownTimeZoneError, pytz.NonExistentTimeError): + pass if ( "past" in self.settings.PREFER_DATES_FROM @@ -704,7 +706,7 @@ def parse( tokens = list(tokenizer(datestring).tokenize()) date_order = date_order or settings.DATE_ORDER try: - po = cls(tokens, settings, date_order=date_order) + po = cls(tokens, settings, date_order=date_order, tz=tz) dateobj = po._results() except ValueError as error: if ( @@ -716,7 +718,7 @@ def parse( # The numbers do not fit the date order set by the caller, so read # them with the day and month swapped, e.g. "2021-01-13" with YDM. swapped = date_order.translate(str.maketrans("DM", "MD")) - po = cls(tokens, settings, date_order=swapped) + po = cls(tokens, settings, date_order=swapped, tz=tz) dateobj = po._results() # correction for past, future if applicable diff --git a/dateparser/utils/__init__.py b/dateparser/utils/__init__.py index 7403171d6..f813437b5 100644 --- a/dateparser/utils/__init__.py +++ b/dateparser/utils/__init__.py @@ -8,6 +8,7 @@ from collections import OrderedDict from collections.abc import Callable, Mapping from datetime import datetime, tzinfo +from datetime import timezone as dt_timezone from typing import TYPE_CHECKING, Any, Literal, TypeVar import regex as re @@ -171,6 +172,17 @@ def apply_timezone(date_time: datetime, tz_string: str) -> datetime: return new_datetime +def _now(settings: "Settings", tz: tzinfo | None = None) -> datetime: + """Return the current time as a naive datetime in *tz*, or in the + ``TIMEZONE`` setting if *tz* is ``None``.""" + if tz is not None: + return datetime.now(tz).replace(tzinfo=None) + if "local" in settings.TIMEZONE.lower(): + return datetime.now() + utc_now = datetime.now(dt_timezone.utc) + return apply_timezone(utc_now, settings.TIMEZONE).replace(tzinfo=None) + + def apply_timezone_from_settings( date_obj: datetime, settings: "Settings | None" ) -> datetime: diff --git a/tests/test_date.py b/tests/test_date.py index 39bd7ebab..1d0905e22 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1165,6 +1165,7 @@ def today(cls) -> real_datetime.datetime: # type: ignore[override] self.add_patch(patch("dateparser.date.datetime", DateParserDateTime)) self.add_patch(patch("dateparser.parser.datetime", DateParserDateTime)) + self.add_patch(patch("dateparser.utils.datetime", DateParserDateTime)) def given_parser( self, restrict_to_languages: list[str] | None = None, **params: Any @@ -1588,6 +1589,7 @@ def test_timestamp_with_wrong_length(self, date_string: str) -> None: ("3 months ago", None, None, ("year", "month")), ("yesterday", None, None, YMD), ("tomorrow 4pm", None, None, (*YMD, "time")), + ("the 1st of last month", None, None, YMD), ("2 hours ago", None, None, (*YMD, "time")), ("foo", None, None, ()), ], diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index e6e60962e..1c80005b3 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1609,22 +1609,46 @@ def test_dates_with_no_day_or_month( def test_dates_with_no_day_or_month_use_same_current_date_for_month_and_day( self, ) -> None: - class ParserDateTime(datetime): - @classmethod - def now(cls, tz: tzinfo | None = None) -> datetime: # type: ignore[override] - return datetime(2026, 5, 31, 12, 0, tzinfo=tz) - class UtilsDateTime(datetime): @classmethod def now(cls, tz: tzinfo | None = None) -> datetime: # type: ignore[override] return datetime(2026, 6, 1, 12, 0, tzinfo=tz) with ( - patch("dateparser.parser.datetime", ParserDateTime), + patch("dateparser.parser._now", return_value=datetime(2026, 5, 31, 12)), patch("dateparser.utils.datetime", UtilsDateTime), ): self.assertEqual(parse("2014"), datetime(2014, 5, 31)) + @parameterized.expand( + [ + param("Monday", {}, datetime(2023, 11, 6)), + param("Tuesday", {}, datetime(2023, 10, 31)), + param("Tuesday", {"PREFER_DATES_FROM": "future"}, datetime(2023, 11, 7)), + param("Monday", {"PREFER_DATES_FROM": "past"}, datetime(2023, 10, 30)), + param("November 7", {"PREFER_DATES_FROM": "past"}, datetime(2022, 11, 7)), + param("9pm", {"PREFER_DATES_FROM": "past"}, datetime(2023, 11, 5, 21)), + ] + ) + def test_current_date_is_taken_from_timezone( + self, date_string: str, settings: dict[str, Any], expected: datetime + ) -> None: + class UtilsDateTime(datetime): + @classmethod + def now(cls, tz: tzinfo | None = None) -> datetime: # type: ignore[override] + return datetime(2023, 11, 7, 2, 15, tzinfo=timezone.utc).astimezone(tz) + + with patch("dateparser.utils.datetime", UtilsDateTime): + result = parse( + date_string, + settings={ + "TIMEZONE": "America/Chicago", + "RETURN_AS_TIMEZONE_AWARE": False, + **settings, + }, + ) + self.assertEqual(result, expected) + @parameterized.expand( [ param( diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index a0b662d37..c6a596ac4 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -32,7 +32,7 @@ def setUp(self) -> None: self.date = NotImplemented self.time = NotImplemented - settings.TIMEZONE = "utc" + self.add_patch(patch.object(settings, "TIMEZONE", "utc")) def now_with_timezone(self, tz: tzinfo | None) -> datetime: now = self.now diff --git a/tests/test_minguo.py b/tests/test_minguo.py index d81bd7338..60ae84c03 100644 --- a/tests/test_minguo.py +++ b/tests/test_minguo.py @@ -25,13 +25,21 @@ def test_parse(self, date_string: str, expected: datetime) -> None: @parameterized.expand( [ - param("101-02", datetime(2012, 2, 29), "month"), - param("110", datetime(2021, 3, 31), "year"), + param("101-02", datetime(2012, 2, 29), "month", ("year", "month")), + param("110", datetime(2021, 3, 31), "year", ("year",)), ] ) - def test_partial(self, date_string: str, expected: datetime, period: str) -> None: + def test_partial( + self, + date_string: str, + expected: datetime, + period: str, + parts: tuple[str, ...], + ) -> None: current = settings.replace(RELATIVE_BASE=datetime(2026, 3, 31)) - self.assertEqual(_minguo_parser.parse(date_string, current), (expected, period)) + self.assertEqual( + _minguo_parser.parse(date_string, current), (expected, period, parts) + ) @parameterized.expand( [ diff --git a/tests/test_search.py b/tests/test_search.py index 74c5b7684..e4296e903 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -12,7 +12,7 @@ from dateparser_data.settings import default_parsers from tests import BaseTestCase -today = datetime.datetime.now(tz=pytz.timezone("UTC")) +today = datetime.datetime.now() relative_base = datetime.datetime(2020, 2, 13, 20, 7, 6) @@ -663,7 +663,7 @@ def test_search_dates_joined_by_skipped_words( datetime.datetime( 2020, 5, - datetime.datetime.now(tz=datetime.timezone.utc).day, + today.day, 0, 0, ), @@ -673,7 +673,7 @@ def test_search_dates_joined_by_skipped_words( datetime.datetime( 2020, 7, - datetime.datetime.now(tz=datetime.timezone.utc).day, + today.day, 0, 0, ), @@ -683,7 +683,7 @@ def test_search_dates_joined_by_skipped_words( datetime.datetime( 2023, 7, - datetime.datetime.now(tz=datetime.timezone.utc).day, + today.day, 0, 0, ), @@ -693,7 +693,7 @@ def test_search_dates_joined_by_skipped_words( datetime.datetime( 2023, 1, - datetime.datetime.now(tz=datetime.timezone.utc).day, + today.day, 0, 0, tzinfo=pytz.utc, From cf728353087a7bb565798e611d47b497906ee29f Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 16:35:50 +0200 Subject: [PATCH 094/107] Parse AM/PM written before the time (#1469) --- dateparser/data/date_translation_data/zh.py | 4 ++-- dateparser/parser.py | 11 +++++++++++ .../date_translation_data/zh.yaml | 4 ++-- tests/test_date_parser.py | 5 +++++ tests/test_languages.py | 1 + 5 files changed, 21 insertions(+), 4 deletions(-) diff --git a/dateparser/data/date_translation_data/zh.py b/dateparser/data/date_translation_data/zh.py index 62b9d7caf..3f0cb77f5 100644 --- a/dateparser/data/date_translation_data/zh.py +++ b/dateparser/data/date_translation_data/zh.py @@ -249,10 +249,10 @@ "半小时前": "30分前" }, { - "(?:中午|下午|(?:晚上?))(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+)": "\\1:\\2 pm" + "(?:中午|下午|(?:晚上?))(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+(?::\\d++[.,]?\\d*+)?)": "\\1:\\2 pm" }, { - "(?:上午|早上|凌晨)(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+)": "\\1:\\2 am" + "(?:上午|早上|凌晨)(?:\\s*)(\\d++[.,]?\\d*+)(?:\\s*):(?:\\s+|:)?(\\d++[.,]?\\d*+(?::\\d++[.,]?\\d*+)?)": "\\1:\\2 am" }, { "中午": "12:00" diff --git a/dateparser/parser.py b/dateparser/parser.py index a3bfcf11b..2987ba675 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -303,6 +303,17 @@ def __init__( # noqa: PLR0912, PLR0915 self.filtered_tokens = [ (t[0], t[1], i) for i, t in enumerate(self.tokens) if t[1] <= 1 ] + # Move a meridian written before a time (e.g. Chinese 下午 02:26) after + # it, where the time parsing below looks for it. + for i in range(len(self.filtered_tokens) - 1): + current, following = self.filtered_tokens[i : i + 2] + preceding = self.filtered_tokens[i - 1][0] if i else "" + if ( + current[0] in ("am", "pm") + and ":" in following[0] + and ":" not in preceding + ): + self.filtered_tokens[i : i + 2] = [following, current] self.unset_tokens: list[tuple[str, int, str]] = [] diff --git a/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml b/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml index 75252c017..f5fb00f62 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml @@ -47,8 +47,8 @@ relative-type: simplifications: - 半小时前: 30分前 - - (?:中午|下午|(?:晚上?))(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*): \1:\2 pm - - (?:上午|早上|凌晨)(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*): \1:\2 am + - (?:中午|下午|(?:晚上?))(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*(?::\d+[.,]?\d*)?): \1:\2 pm + - (?:上午|早上|凌晨)(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*(?::\d+[.,]?\d*)?): \1:\2 am - 中午: '12:00' - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日(?:\s+)?(\d+[.,]?\d*)时(?:\s+)?(\d+[.,]?\d*)分: \1-\2-\3 \4:\5 - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d{1,2})(?:日)?(?:\s+)?(\d{1,2})(?:点|:)(\d{1,2}): \1-\2-\3 \4:\5 diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 1c80005b3..b6027b213 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -61,6 +61,7 @@ def setUp(self) -> None: param( "Wednesday, 22nd June, 2016, 12.16 pm.", datetime(2016, 6, 22, 12, 16) ), + param("2020/10/9 PM 2:26", datetime(2020, 10, 9, 14, 26)), # French dates param("11 Mai 2014", datetime(2014, 5, 11)), param("11 sept. 2014", datetime(2014, 9, 11)), @@ -195,6 +196,10 @@ def setUp(self) -> None: param("2016年6月29", datetime(2016, 6, 29, 0, 0)), param("2016年 2月 5日", datetime(2016, 2, 5, 0, 0)), param("2016年9月14日晚8:00", datetime(2016, 9, 14, 20, 0)), + param("2020/10/9 下午 02:26:26", datetime(2020, 10, 9, 14, 26, 26)), + param("2020/10/9 上午 02:26:26", datetime(2020, 10, 9, 2, 26, 26)), + # Korean dates + param("2020/10/9 오후 2:26", datetime(2020, 10, 9, 14, 26)), # Bulgarian param("25 ян 2016", datetime(2016, 1, 25, 0, 0)), param("23 декември 2013 15:10:01", datetime(2013, 12, 23, 15, 10, 1)), diff --git a/tests/test_languages.py b/tests/test_languages.py index 362aae146..0bb32486e 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -83,6 +83,7 @@ def setUp(self) -> None: param("zh", "周六 2013年04月08日", "saturday 2013-04-08"), param("zh", "下午3:30", "3:30 pm"), param("zh", "凌晨3:30", "3:30 am"), + param("zh", "下午 02:26:26", "02:26:26 pm"), param("zh", "中午", "12:00"), # French param("fr", "20 Février 2012", "20 february 2012"), From decca2302c86ffaf0c36e53bae98f388999d2ba7 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 16:36:11 +0200 Subject: [PATCH 095/107] =?UTF-8?q?Parse=20Chinese=20and=20Japanese=20date?= =?UTF-8?q?s=20with=20spaces=20around=20=E5=B9=B4,=20=E6=9C=88=20and=20?= =?UTF-8?q?=E6=97=A5=20(#1477)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- dateparser/data/date_translation_data/ja.py | 8 ++++---- dateparser/data/date_translation_data/zh.py | 6 +++--- .../date_translation_data/ja.yaml | 8 ++++---- .../date_translation_data/zh.yaml | 6 +++--- tests/test_date_parser.py | 3 +++ 5 files changed, 17 insertions(+), 14 deletions(-) diff --git a/dateparser/data/date_translation_data/ja.py b/dateparser/data/date_translation_data/ja.py index 40717f854..d6f8fff2d 100644 --- a/dateparser/data/date_translation_data/ja.py +++ b/dateparser/data/date_translation_data/ja.py @@ -269,19 +269,19 @@ ], "simplifications": [ { - "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日": "\\1-\\2-\\3" + "(\\d++[.,]?\\d*+)\\s*年\\s*(\\d++[.,]?\\d*+)\\s*月\\s*(\\d++[.,]?\\d*+)\\s*日": "\\1-\\2-\\3" }, { "(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日": "\\1-\\2" }, { - "(\\d++[.,]?\\d*+)時(?:\\s+)?(\\d++[.,]?\\d*+)分(?:\\s+)?(\\d++[.,]?\\d*+)秒": "\\1:\\2:\\3" + "(\\d++[.,]?\\d*+)\\s*時\\s*(\\d++[.,]?\\d*+)\\s*分\\s*(\\d++[.,]?\\d*+)\\s*秒": "\\1:\\2:\\3" }, { - "(\\d++[.,]?\\d*+)時(?:\\s+)?(\\d++[.,]?\\d*+)分": "\\1:\\2" + "(\\d++[.,]?\\d*+)\\s*時\\s*(\\d++[.,]?\\d*+)\\s*分": "\\1:\\2" }, { - "(\\d++[.,]?\\d*+)時$": "\\1:00" + "(\\d++[.,]?\\d*+)\\s*時$": "\\1:00" }, { "正午": "12:00" diff --git a/dateparser/data/date_translation_data/zh.py b/dateparser/data/date_translation_data/zh.py index 3f0cb77f5..a5966426f 100644 --- a/dateparser/data/date_translation_data/zh.py +++ b/dateparser/data/date_translation_data/zh.py @@ -258,13 +258,13 @@ "中午": "12:00" }, { - "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d++[.,]?\\d*+)日(?:\\s+)?(\\d++[.,]?\\d*+)时(?:\\s+)?(\\d++[.,]?\\d*+)分": "\\1-\\2-\\3 \\4:\\5" + "(\\d++[.,]?\\d*+)\\s*年\\s*(\\d++[.,]?\\d*+)\\s*月\\s*(\\d++[.,]?\\d*+)\\s*日\\s*(\\d++[.,]?\\d*+)\\s*时\\s*(\\d++[.,]?\\d*+)\\s*分": "\\1-\\2-\\3 \\4:\\5" }, { - "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d{1,2})(?:日)?(?:\\s+)?(\\d{1,2})(?:点|:)(\\d{1,2})": "\\1-\\2-\\3 \\4:\\5" + "(\\d++[.,]?\\d*+)\\s*年\\s*(\\d++[.,]?\\d*+)\\s*月\\s*(\\d{1,2})\\s*(?:日)?\\s*(\\d{1,2})\\s*(?:点|:)\\s*(\\d{1,2})": "\\1-\\2-\\3 \\4:\\5" }, { - "(\\d++[.,]?\\d*+)年(?:\\s+)?(\\d++[.,]?\\d*+)月(?:\\s+)?(\\d{1,2})(?:日)?": "\\1-\\2-\\3" + "(\\d++[.,]?\\d*+)\\s*年\\s*(\\d++[.,]?\\d*+)\\s*月\\s*(\\d{1,2})\\s*(?:日)?": "\\1-\\2-\\3" }, { "(\\d++[.,]?\\d*+)月(?=.*[前后])": "\\1 月" diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml index b8ecf50fa..3305b1815 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ja.yaml @@ -85,9 +85,9 @@ relative-type: in 1 year: - 翌年 simplifications: - - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日: \1-\2-\3 + - (\d+[.,]?\d*)\s*年\s*(\d+[.,]?\d*)\s*月\s*(\d+[.,]?\d*)\s*日: \1-\2-\3 - (\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日: \1-\2 - - (\d+[.,]?\d*)時(?:\s+)?(\d+[.,]?\d*)分(?:\s+)?(\d+[.,]?\d*)秒: \1:\2:\3 - - (\d+[.,]?\d*)時(?:\s+)?(\d+[.,]?\d*)分: \1:\2 - - (\d+[.,]?\d*)時$: \1:00 + - (\d+[.,]?\d*)\s*時\s*(\d+[.,]?\d*)\s*分\s*(\d+[.,]?\d*)\s*秒: \1:\2:\3 + - (\d+[.,]?\d*)\s*時\s*(\d+[.,]?\d*)\s*分: \1:\2 + - (\d+[.,]?\d*)\s*時$: \1:00 - 正午: '12:00' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml b/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml index f5fb00f62..ce9882d7b 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/zh.yaml @@ -50,7 +50,7 @@ simplifications: - (?:中午|下午|(?:晚上?))(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*(?::\d+[.,]?\d*)?): \1:\2 pm - (?:上午|早上|凌晨)(?:\s*)(\d+[.,]?\d*)(?:\s*):(?:\s+|:)?(\d+[.,]?\d*(?::\d+[.,]?\d*)?): \1:\2 am - 中午: '12:00' - - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d+[.,]?\d*)日(?:\s+)?(\d+[.,]?\d*)时(?:\s+)?(\d+[.,]?\d*)分: \1-\2-\3 \4:\5 - - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d{1,2})(?:日)?(?:\s+)?(\d{1,2})(?:点|:)(\d{1,2}): \1-\2-\3 \4:\5 - - (\d+[.,]?\d*)年(?:\s+)?(\d+[.,]?\d*)月(?:\s+)?(\d{1,2})(?:日)?: \1-\2-\3 + - (\d+[.,]?\d*)\s*年\s*(\d+[.,]?\d*)\s*月\s*(\d+[.,]?\d*)\s*日\s*(\d+[.,]?\d*)\s*时\s*(\d+[.,]?\d*)\s*分: \1-\2-\3 \4:\5 + - (\d+[.,]?\d*)\s*年\s*(\d+[.,]?\d*)\s*月\s*(\d{1,2})\s*(?:日)?\s*(\d{1,2})\s*(?:点|:)\s*(\d{1,2}): \1-\2-\3 \4:\5 + - (\d+[.,]?\d*)\s*年\s*(\d+[.,]?\d*)\s*月\s*(\d{1,2})\s*(?:日)?: \1-\2-\3 - (\d+[.,]?\d*)月(?=.*[前后]): \1 月 diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index b6027b213..c1e9abb00 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -180,6 +180,7 @@ def setUp(self) -> None: # Japanese dates param("2016年3月20日(日) 21時40分", datetime(2016, 3, 20, 21, 40)), param("2016年3月20日 21時40分", datetime(2016, 3, 20, 21, 40)), + param("2016 年 3 月 20 日 21 時 40 分", datetime(2016, 3, 20, 21, 40)), # Numeric dates param("06-17-2014", datetime(2014, 6, 17)), param("13/03/2014", datetime(2014, 3, 13)), @@ -195,6 +196,8 @@ def setUp(self) -> None: param("2016年6月2911:30", datetime(2016, 6, 29, 11, 30)), param("2016年6月29", datetime(2016, 6, 29, 0, 0)), param("2016年 2月 5日", datetime(2016, 2, 5, 0, 0)), + param("2019 年 10 月 30 日", datetime(2019, 10, 30, 0, 0)), + param("2016 年 6 月 30 日 9 时 30 分", datetime(2016, 6, 30, 9, 30)), param("2016年9月14日晚8:00", datetime(2016, 9, 14, 20, 0)), param("2020/10/9 下午 02:26:26", datetime(2020, 10, 9, 14, 26, 26)), param("2020/10/9 上午 02:26:26", datetime(2020, 10, 9, 2, 26, 26)), From 13da631b1cea23d1b7233973830563afa2d5da48 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 16:38:17 +0200 Subject: [PATCH 096/107] Read a lone number next to a year as the month under any DATE_ORDER (#1472) --- dateparser/parser.py | 15 +++++++++++++++ tests/test_date_parser.py | 23 +++++++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/dateparser/parser.py b/dateparser/parser.py index 2987ba675..ef97bf2f9 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -333,6 +333,21 @@ def __init__( # noqa: PLR0912, PLR0915 k: self.num_directives[k] for k in resolve_date_order(self._date_order, lst=True) } + numbers = sorted( + (t[0] for t in self.filtered_tokens if t[1] == 0 and t[0].isdigit()), + key=len, + ) + if ( + not any(t[1] == 1 for t in self.filtered_tokens) + and len(numbers) == 2 + and len(numbers[0]) <= 2 + and len(numbers[1]) == 4 + ): + # A year and a single other number (e.g. "05/2020"): the other + # number is the month whatever the date order. + self.ordered_num_directives = { + k: self.num_directives[k] for k in ("month", "day", "year") + } skip_index: list[int] = [] skip_component: str | None = None diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index c1e9abb00..c944f78f1 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1081,6 +1081,29 @@ def test_year_first_date_with_explicit_date_order( self.then_date_was_parsed_by_date_parser() self.then_date_obj_exactly_is(expected) + @parameterized.expand( + [ + param("05/2020", date_order="DMY", expected=datetime(2020, 5, 1)), + param("5-2020", date_order="YMD", expected=datetime(2020, 5, 1)), + param( + "05/2020 10:00", date_order="YDM", expected=datetime(2020, 5, 28, 10) + ), + param("13/2020", date_order="DMY", expected=datetime(2020, 9, 13)), + ] + ) + def test_month_and_year_with_explicit_date_order( + self, date_string, date_order, expected + ): + self.given_parser( + settings={ + "DATE_ORDER": date_order, + "PREFER_DAY_OF_MONTH": "first", + "RELATIVE_BASE": datetime(2020, 9, 28), + } + ) + self.when_date_is_parsed(date_string) + self.then_date_obj_exactly_is(expected) + @parameterized.expand( [ # Epoch timestamps. From 72060dccb8c9f53bfc06f6971bff255528212a7a Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 17:24:56 +0200 Subject: [PATCH 097/107] Find dates written right after a label and a colon in search_dates (#1496) --- dateparser/date.py | 43 ++++++++++++++++++++++------------ dateparser/languages/locale.py | 4 +++- tests/test_date.py | 4 ++-- tests/test_date_parser.py | 4 ++-- tests/test_search.py | 24 +++++++++++++++++++ 5 files changed, 59 insertions(+), 20 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index dfad417d8..3324f8da5 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -338,8 +338,10 @@ def parse_with_formats( ) -@functools.lru_cache(maxsize=None) -def _get_name_translations(locale, month_form, weekday_form): +@functools.cache +def _get_name_translations( + locale: "Locale", month_form: str | None, weekday_form: str | None +) -> tuple[re.Pattern[str], dict[str, list[str]]] | None: """Return a pattern matching the month and weekday names of *locale*, and a mapping of each lowercase name to the English names it can stand for. @@ -347,18 +349,20 @@ def _get_name_translations(locale, month_form, weekday_form): the English form to translate each kind of name into, or ``None`` to leave that kind of name untranslated. """ - translations = collections.defaultdict(list) + translations: collections.defaultdict[str, list[str]] = collections.defaultdict( + list + ) for words, form in ((_MONTHS, month_form), (_WEEKDAYS, weekday_form)): if form is None: continue for word in words: english = word if form == "full" else word[:3] - for name in locale.info.get(word, ()): - name = name.lower() + for localized in locale.info.get(word, ()): + name = localized.lower() if english not in translations[name]: translations[name].append(english) if not translations: - return None, None + return None names = sorted(translations, key=len, reverse=True) pattern = re.compile( r"(? Iterator[str]: """Yield the variants of *date_string* that result from replacing the month and weekday names of *locale* with the English names that the directives of *date_format* expect.""" @@ -377,19 +383,22 @@ def _translate_names(date_string, date_format, locale): weekday_form = ( "full" if "%A" in date_format else "abbr" if "%a" in date_format else None ) - pattern, translations = _get_name_translations(locale, month_form, weekday_form) - if pattern is None: + name_translations = _get_name_translations(locale, month_form, weekday_form) + if name_translations is None: return + pattern, translations = name_translations matches = pattern.findall(date_string) if not matches: return + pieces = pattern.split(date_string) # A name can stand for several English names, e.g. "mar" is both "martes" # and "marzo" in Spanish, so every combination is yielded. for combination in itertools.product( *(translations[match.lower()] for match in matches) ): - english_names = iter(combination) - yield pattern.sub(lambda _: next(english_names), date_string) + yield "".join( + itertools.chain.from_iterable(zip(pieces, (*combination, ""), strict=True)) + ) class _DateLocaleParser: @@ -793,9 +802,11 @@ def get_date_data( if res["date_obj"]: return res if date_formats: - res = self._parse_with_localized_formats(date_string, date_formats) - if res: - return res + localized_res = self._parse_with_localized_formats( + date_string, date_formats + ) + if localized_res: + return localized_res date_string = sanitize_date(date_string) @@ -811,7 +822,9 @@ def get_date_data( ) return parsed_date or DateData(date_obj=None, period="day", locale=None) - def _parse_with_localized_formats(self, date_string, date_formats): + def _parse_with_localized_formats( + self, date_string: str, date_formats: Iterable[str] + ) -> DateData | None: for locale in self._get_locale_loader().get_locales( languages=self.languages, locales=self.locales, diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index ae9832986..1fcc490d7 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -545,7 +545,9 @@ def _split_dict(self, dictionary: Dictionary) -> dict[str, str | None]: def _word_split(self, string: str, settings: "Settings | None") -> list[str]: if "no_word_spacing" in self.info: return self._split(string, keep_formatting=True, settings=settings) - return string.split() + # A colon right after a letter ends a label, as in + # "birthday:2020-07-08", while one after a digit belongs to a time. + return re.sub(r"(?<=[^\W\d_]:)(?=\w)", " ", string).split() def _split( self, diff --git a/tests/test_date.py b/tests/test_date.py index 1d0905e22..d0f3f8ec5 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -976,8 +976,8 @@ def test_parse_date_using_format( ] ) def test_parse_date_using_format_with_literal_text( - self, date_string, date_formats, expected_result - ): + self, date_string: str, date_formats: list[str], expected_result: datetime + ) -> None: self.given_parser( restrict_to_languages=["es"], settings={"PREFER_DAY_OF_MONTH": "first"} ) diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index c944f78f1..448b55227 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1092,8 +1092,8 @@ def test_year_first_date_with_explicit_date_order( ] ) def test_month_and_year_with_explicit_date_order( - self, date_string, date_order, expected - ): + self, date_string: str, date_order: str, expected: datetime + ) -> None: self.given_parser( settings={ "DATE_ORDER": date_order, diff --git a/tests/test_search.py b/tests/test_search.py index e4296e903..4e3e9f45e 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1343,6 +1343,30 @@ def test_search_dates_returning_detected_languages_if_requested( result = search_dates(text, add_detected_language=add_detected_language) self.assertEqual(result, expected) + @parameterized.expand( + [ + param( + text="birthday:2020-07-08", + expected=[("2020-07-08", datetime.datetime(2020, 7, 8, 0, 0))], + ), + param( + text="Date:July 8, 2020", + expected=[("July 8, 2020", datetime.datetime(2020, 7, 8, 0, 0))], + ), + param( + text="at:10:30 on 2020-07-08", + expected=[ + ("10:30 on 2020-07-08", datetime.datetime(2020, 7, 8, 10, 30)) + ], + ), + ] + ) + def test_search_dates_after_a_label_and_a_colon( + self, text: str, expected: list[tuple[str, datetime.datetime]] + ) -> None: + result = search_dates(text, languages=["en"]) + self.assertEqual(result, expected) + @parameterized.expand( [ param(text="19 марта 2001", languages="wrong type: str instead of list"), From 5b31fe4a23e265968c54a1fc541fcc03623a9aea Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 18:01:38 +0200 Subject: [PATCH 098/107] Parse Swedish ordinal day suffixes like "24:e" and "1:a" (#1484) --- dateparser/data/date_translation_data/sv.py | 3 +++ .../supplementary_language_data/date_translation_data/sv.yaml | 1 + tests/test_languages.py | 2 ++ 3 files changed, 6 insertions(+) diff --git a/dateparser/data/date_translation_data/sv.py b/dateparser/data/date_translation_data/sv.py index 657fba160..d0226249e 100644 --- a/dateparser/data/date_translation_data/sv.py +++ b/dateparser/data/date_translation_data/sv.py @@ -307,6 +307,9 @@ "från nu" ], "simplifications": [ + { + "(\\d+):[ae]\\b": "\\1" + }, { "en": "1" }, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml index 945174493..83ae7aed7 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/sv.yaml @@ -69,5 +69,6 @@ relative-type: 0 month ago: - denna månad simplifications: + - (\d+):[ae]\b: \1 - en: '1' - två: '2' diff --git a/tests/test_languages.py b/tests/test_languages.py index 0bb32486e..6908054c5 100644 --- a/tests/test_languages.py +++ b/tests/test_languages.py @@ -286,6 +286,8 @@ def setUp(self) -> None: # Swedish param("sv", "Sept 03 2014", "september 03 2014"), param("sv", "fredag, 03 september 2014", "friday 03 september 2014"), + param("sv", "den 24:e december 2020", " 24 december 2020"), + param("sv", "1:a januari 2021 10:00", "1 january 2021 10:00"), # af param("af", "5 Mei 2017", "5 may 2017"), param( From d305145b10a0a25fcfa9c90328f606774a9bb90f Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 19:32:01 +0200 Subject: [PATCH 099/107] Parse parts of the day with configurable times (#1473) --- dateparser/__init__.py | 2 + dateparser/_parts_of_day.py | 101 ++++++++++++++++++ dateparser/conf.py | 4 + dateparser/data/date_translation_data/en.py | 29 +++++ dateparser/data/date_translation_data/es.py | 10 ++ dateparser/data/date_translation_data/gl.py | 11 ++ dateparser/data/date_translation_data/pt.py | 9 ++ dateparser/date.py | 44 +++++++- dateparser/languages/dictionary.py | 7 +- dateparser/languages/validation.py | 5 + dateparser_data/settings.py | 3 + .../date_translation_data/en.yaml | 17 +++ .../date_translation_data/es.yaml | 6 ++ .../date_translation_data/gl.yaml | 9 ++ .../date_translation_data/pt.yaml | 7 ++ docs/settings.rst | 20 ++++ tests/test_data.py | 5 + tests/test_parts_of_day.py | 92 ++++++++++++++++ 18 files changed, 375 insertions(+), 6 deletions(-) create mode 100644 dateparser/_parts_of_day.py create mode 100644 tests/test_parts_of_day.py diff --git a/dateparser/__init__.py b/dateparser/__init__.py index 906d5ad6b..808a28d8f 100644 --- a/dateparser/__init__.py +++ b/dateparser/__init__.py @@ -4,6 +4,8 @@ from datetime import datetime from typing import Any +from ._parts_of_day import PartOfDay as PartOfDay +from ._parts_of_day import PartsOfDay as PartsOfDay from .conf import Settings, apply_settings from .date import DateDataParser as DateDataParser diff --git a/dateparser/_parts_of_day.py b/dateparser/_parts_of_day.py new file mode 100644 index 000000000..8f72d1d20 --- /dev/null +++ b/dateparser/_parts_of_day.py @@ -0,0 +1,101 @@ +from dataclasses import dataclass, fields +from datetime import time +from enum import Enum + +import regex as re + + +class PartOfDay(str, Enum): + """Part of the day that a date string refers to, e.g. ``"tonight"``. + + See :attr:`DateData.part_of_day `. + + .. versionadded:: VERSION + """ + + EARLY_MORNING = "early_morning" + """Between midnight and dawn, e.g. ``"in the small hours"`` or Spanish + ``"de madrugada"``.""" + + MORNING = "morning" + AFTERNOON = "afternoon" + EVENING = "evening" + NIGHT = "night" + + +@dataclass(frozen=True) +class PartsOfDay: + """Time of the day to use for each :class:`PartOfDay`, for the + ``PARTS_OF_DAY`` :ref:`setting `. + + .. versionadded:: VERSION + """ + + early_morning: time = time(3) + morning: time = time(9) + afternoon: time = time(15) + evening: time = time(18) + night: time = time(20) + + def __post_init__(self) -> None: + for field in fields(self): + value = getattr(self, field.name) + if not isinstance(value, time): + raise TypeError( + f"{type(self).__name__}.{field.name} must be a datetime.time, " + f"not {type(value).__name__}" + ) + + +_PART_OF_DAY_PATTERN = re.compile( + r"(?(?\d{1,2})(?P:\d{2})?\s*$" +) + + +def _meridiem(part: PartOfDay, hour: int) -> str: + if part in (PartOfDay.EARLY_MORNING, PartOfDay.MORNING): + return "am" + if part is PartOfDay.NIGHT and not 6 <= hour <= 11: + return "am" + return "pm" + + +def _replace_part_of_day( + translated: str, parts_of_day: PartsOfDay +) -> tuple[str, PartOfDay | None, bool]: + """Return *translated* with its part-of-day token replaced by a time, the + matching :class:`PartOfDay` (or ``None``), and whether that time came from + *parts_of_day*. + + A number right before the part of the day is an hour, e.g. ``"8 in the + evening"``, unless a month without a day precedes it, e.g. ``"January 8 in + the evening"``. A part of the day on its own is left in place, so that + parsing fails.""" + match = _PART_OF_DAY_PATTERN.search(translated) + if not match: + return translated, None, False + part = PartOfDay(match[1]) + before, after = translated[: match.start()], translated[match.end() :] + number = _TRAILING_NUMBER_PATTERN.search(before) + if number and not number["month"]: + hour = int(number["hour"]) + if hour > 12: + return translated, None, False + time_string = f"{hour}{number['minutes'] or ':00'} {_meridiem(part, hour)}" + return f"{before[: number.start()]}{time_string} {after}", part, False + rest = f"{before} {after}" + if not rest.strip(): + return translated, None, False + if _TIME_PATTERN.search(rest): + return rest, part, False + part_time: time = getattr(parts_of_day, part.value) + return f"{rest} {part_time:%H:%M:%S}", part, True diff --git a/dateparser/conf.py b/dateparser/conf.py index 5e309ac26..23fa1eb24 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -5,6 +5,7 @@ from types import MappingProxyType from typing import Any, Literal, ParamSpec, TypeVar +from dateparser._parts_of_day import PartsOfDay from dateparser.data.languages_info import language_order from .parser import date_order_chart @@ -37,6 +38,7 @@ class Settings: * `RETURN_TIME_SPAN` * `DEFAULT_START_OF_WEEK` * `DEFAULT_DAYS_IN_MONTH` + * `PARTS_OF_DAY` * `PARSERS` * `DEFAULT_LANGUAGES` * `USE_GIVEN_LANGUAGE_ORDER` @@ -67,6 +69,7 @@ class Settings: RETURN_TIME_SPAN: bool DEFAULT_START_OF_WEEK: str DEFAULT_DAYS_IN_MONTH: int + PARTS_OF_DAY: PartsOfDay PARSERS: list[str] DEFAULT_LANGUAGES: list[str] USE_GIVEN_LANGUAGE_ORDER: bool @@ -275,6 +278,7 @@ def check_settings(settings: Settings) -> None: "DEFAULT_DAYS_IN_MONTH": { "type": int, }, + "PARTS_OF_DAY": {"type": PartsOfDay}, } modified_settings = settings._mod_settings # check only modified settings diff --git a/dateparser/data/date_translation_data/en.py b/dateparser/data/date_translation_data/en.py index 046ea2575..017edb218 100644 --- a/dateparser/data/date_translation_data/en.py +++ b/dateparser/data/date_translation_data/en.py @@ -1131,6 +1131,23 @@ "decade", "decades" ], + "early_morning": [ + "early morning", + "small hours", + "wee hours" + ], + "morning": [ + "morning" + ], + "afternoon": [ + "afternoon" + ], + "evening": [ + "evening" + ], + "night": [ + "night" + ], "ago": [ "ago", "before" @@ -1156,6 +1173,18 @@ { "(?:12\\s+)?midnight": "00:00" }, + { + "tonight": "today night" + }, + { + "last night": "yesterday night" + }, + { + "this ((?:early )?morning|afternoon|evening|night)": "today \\1" + }, + { + "in the ((?:early )?morning|afternoon|evening|night|small hours|wee hours)": "\\1" + }, { "(\\d++[.,]?\\d*+)h(\\d++[.,]?\\d*+)": "\\1:\\2" }, diff --git a/dateparser/data/date_translation_data/es.py b/dateparser/data/date_translation_data/es.py index 4dcc42d4c..fb11efdc5 100644 --- a/dateparser/data/date_translation_data/es.py +++ b/dateparser/data/date_translation_data/es.py @@ -607,6 +607,10 @@ "del" ], "sentence_splitter_group": 2, + "early_morning": [ + "de madrugada", + "madrugada" + ], "ago": [ "hace" ], @@ -614,6 +618,12 @@ "en" ], "simplifications": [ + { + "esta madrugada": "hoy madrugada" + }, + { + "(?:de|por|en) la madrugada": "madrugada" + }, { "una": "1" }, diff --git a/dateparser/data/date_translation_data/gl.py b/dateparser/data/date_translation_data/gl.py index fbb00f999..4fec9f64e 100644 --- a/dateparser/data/date_translation_data/gl.py +++ b/dateparser/data/date_translation_data/gl.py @@ -247,6 +247,17 @@ ] }, "locale_specific": {}, + "early_morning": [ + "de madrugada", + "na madrugada", + "pola madrugada", + "madrugada" + ], + "simplifications": [ + { + "esta madrugada": "hoxe madrugada" + } + ], "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/pt.py b/dateparser/data/date_translation_data/pt.py index 43ca9b3b3..06f6eae56 100644 --- a/dateparser/data/date_translation_data/pt.py +++ b/dateparser/data/date_translation_data/pt.py @@ -994,6 +994,12 @@ "de" ], "sentence_splitter_group": 1, + "early_morning": [ + "de madrugada", + "na madrugada", + "pela madrugada", + "madrugada" + ], "ago": [ "atrás", "há" @@ -1002,6 +1008,9 @@ "em" ], "simplifications": [ + { + "esta madrugada": "hoje madrugada" + }, { "uma": "1" }, diff --git a/dateparser/date.py b/dateparser/date.py index 3324f8da5..104bd9e6e 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -6,11 +6,12 @@ from collections.abc import Set as AbstractSet from datetime import date, datetime, timedelta, tzinfo from itertools import count -from typing import TYPE_CHECKING, Any, TypeVar +from typing import TYPE_CHECKING, Any, TypeGuard, TypeVar import regex as re from dateutil.relativedelta import relativedelta +from dateparser._parts_of_day import PartOfDay, _replace_part_of_day from dateparser.conf import Settings, apply_settings, check_settings from dateparser.custom_language_detection.language_mapping import map_languages from dateparser.date_parser import date_parser @@ -426,6 +427,8 @@ def __init__( self._alternative = 0 self._translated_date: str | None = None self._translated_date_with_formatting: str | None = None + self._part_of_day: PartOfDay | None = None + self._part_of_day_sets_time = False self._parsers: dict[str, Callable[[], DateData | None]] = { "timestamp": self._try_timestamp, "negative-timestamp": self._try_negative_timestamp, @@ -459,7 +462,7 @@ def _parse(self) -> "DateData | None": if not self._alternatives: return self._parse_translation() for self._alternative in count(1): - self._translated_date = self._translate(keep_formatting=False) + self._set_translated_date() if self._translated_date is None: return None self._translated_date_with_formatting = None @@ -472,6 +475,13 @@ def _parse_translation(self) -> "DateData | None": for parser_name in self._settings.PARSERS: date_data = self._parsers[parser_name]() if self._is_valid_date_data(date_data): + if self._part_of_day: + date_data.part_of_day = self._part_of_day + if ( + self._part_of_day_sets_time + and self._settings.RETURN_TIME_AS_PERIOD + ): + date_data.period = "part_of_day" return date_data return None @@ -566,9 +576,20 @@ def _translate(self, keep_formatting: bool) -> str | None: alternative=self._alternative, ) + def _set_translated_date(self) -> None: + translated = self._translate(keep_formatting=False) + if translated is None: + self._translated_date = None + return + ( + self._translated_date, + self._part_of_day, + self._part_of_day_sets_time, + ) = _replace_part_of_day(translated, self._settings.PARTS_OF_DAY) + def _get_translated_date(self) -> str: if self._translated_date is None: - self._translated_date = self._translate(keep_formatting=False) + self._set_translated_date() assert self._translated_date is not None return self._translated_date @@ -580,7 +601,7 @@ def _get_translated_date_with_formatting(self) -> str: assert self._translated_date_with_formatting is not None return self._translated_date_with_formatting - def _is_valid_date_data(self, date_data: object) -> bool: + def _is_valid_date_data(self, date_data: object) -> TypeGuard["DateData"]: if not isinstance(date_data, DateData): return False if not date_data["date_obj"] or not date_data["period"]: @@ -596,6 +617,18 @@ class DateData: It can be accessed with square brackets like a dict object. """ + part_of_day: PartOfDay | None = None + """:class:`~dateparser.PartOfDay` that the date string refers to, e.g. + :attr:`~dateparser.PartOfDay.NIGHT` for ``"tonight"``, or ``None``. + + .. versionadded:: VERSION + + Its time comes from the ``PARTS_OF_DAY`` :ref:`setting `, unless + the date string also has a time, e.g. ``"tonight at 11pm"``. If it does + not, and the ``RETURN_TIME_AS_PERIOD`` setting is enabled, ``period`` is + ``"part_of_day"``. + """ + def __init__( self, *, @@ -761,7 +794,8 @@ def get_date_data( :raises: ValueError - Unknown Language - .. note:: *Period* values can be a 'day' (default), 'week', 'month', 'year', 'time'. + .. note:: *Period* values can be a 'day' (default), 'week', 'month', 'year', 'time', + 'part_of_day'. *Period* represents the granularity of date parsed from the given string. diff --git a/dateparser/languages/dictionary.py b/dateparser/languages/dictionary.py index cdb55a314..6b67781ca 100644 --- a/dateparser/languages/dictionary.py +++ b/dateparser/languages/dictionary.py @@ -15,7 +15,7 @@ _T = TypeVar("_T") PARSER_HARDCODED_TOKENS = [":", ".", " ", "-", "/"] -PARSER_KNOWN_TOKENS = ["am", "pm", "UTC", "GMT", "Z"] +PARSER_KNOWN_TOKENS = ["am", "pm", "UTC", "GMT", "Z", "early_morning"] ALWAYS_KEEP_TOKENS = ["+", *PARSER_HARDCODED_TOKENS] KNOWN_WORD_TOKENS = [ "monday", @@ -49,6 +49,11 @@ "in", "am", "pm", + "early_morning", + "morning", + "afternoon", + "evening", + "night", ] PARENTHESES_PATTERN = re.compile(r"[\(\)]") diff --git a/dateparser/languages/validation.py b/dateparser/languages/validation.py index be4f51833..daffb55b7 100644 --- a/dateparser/languages/validation.py +++ b/dateparser/languages/validation.py @@ -43,6 +43,11 @@ class LanguageValidator: "hour", "minute", "second", + "early_morning", + "morning", + "afternoon", + "evening", + "night", "sentence_splitter_group", ] diff --git a/dateparser_data/settings.py b/dateparser_data/settings.py index 89aad5a6e..9b8a9cb18 100644 --- a/dateparser_data/settings.py +++ b/dateparser_data/settings.py @@ -1,3 +1,5 @@ +from dateparser._parts_of_day import PartsOfDay + default_parsers = [ "timestamp", "relative-time", @@ -33,6 +35,7 @@ "DEFAULT_DAYS_IN_MONTH": 30, # Other settings "RETURN_TIME_AS_PERIOD": False, + "PARTS_OF_DAY": PartsOfDay(), "PARSERS": default_parsers, "IGNORE_SURROUNDING_TEXT": False, "CACHE_SIZE_LIMIT": 1000, diff --git a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml index 9d27cad93..624128e04 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/en.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/en.yaml @@ -54,6 +54,19 @@ second: - seconds - secs +early_morning: + - early morning + - small hours + - wee hours +morning: + - morning +afternoon: + - afternoon +evening: + - evening +night: + - night + ago: - ago - before @@ -90,6 +103,10 @@ simplifications: - a: '1' - (?:12\s+)?noon: '12:00' - (?:12\s+)?midnight: '00:00' + - tonight: today night + - last night: yesterday night + - this ((?:early )?morning|afternoon|evening|night): today \1 + - in the ((?:early )?morning|afternoon|evening|night|small hours|wee hours): \1 - (\d+[.,]?\d*)h(\d+[.,]?\d*): \1:\2 - from\s+now: in - less than 1 minute ago: 45 second ago diff --git a/dateparser_data/supplementary_language_data/date_translation_data/es.yaml b/dateparser_data/supplementary_language_data/date_translation_data/es.yaml index 3e2226d64..da79c96e6 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/es.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/es.yaml @@ -95,6 +95,10 @@ minute: second: - segundos +early_morning: + - de madrugada + - madrugada + ago: - hace in: @@ -105,5 +109,7 @@ relative-type: - anteayer simplifications: + - esta madrugada: hoy madrugada + - (?:de|por|en) la madrugada: madrugada - una: '1' - un: '1' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml index ba215dcb7..12f9d59d2 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/gl.yaml @@ -36,3 +36,12 @@ relative-type-regex: - en (\d+[.,]?\d*) m in \1 year: - en (\d+[.,]?\d*) a + +early_morning: + - de madrugada + - na madrugada + - pola madrugada + - madrugada + +simplifications: + - esta madrugada: hoxe madrugada diff --git a/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml b/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml index 547b5cee1..9157c9729 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/pt.yaml @@ -43,6 +43,12 @@ second: - segundos - s +early_morning: + - de madrugada + - na madrugada + - pela madrugada + - madrugada + ago: - atrás - há @@ -54,6 +60,7 @@ relative-type: - anteontem simplifications: + - esta madrugada: hoje madrugada - uma: '1' - um: '1' - alguns segundos: 44 segundos diff --git a/docs/settings.rst b/docs/settings.rst index ad13fc63f..cfdf265a2 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -284,6 +284,26 @@ Defaults to ``False``. >>> ddp.get_date_data('vr jan 24, 2014 12:49') DateData(date_obj=datetime.datetime(2014, 1, 24, 12, 49), period='time', locale='nl', parts=('year', 'month', 'day', 'time')) +``PARTS_OF_DAY``: a :class:`~dateparser.PartsOfDay` object that sets the time +to use for each part of the day, e.g. for ``tonight``. Defaults to +``PartsOfDay()``. + +.. versionadded:: VERSION + + >>> from datetime import time + >>> from dateparser import PartsOfDay + >>> ddp = DateDataParser(settings={'PARTS_OF_DAY': PartsOfDay(night=time(22)), 'RETURN_TIME_AS_PERIOD': True}) + >>> ddp.get_date_data('5 January 2026 at night') + DateData(date_obj=datetime.datetime(2026, 1, 5, 22, 0), period='part_of_day', locale='en', part_of_day=) + +.. autoclass:: dateparser.PartsOfDay + :members: + :undoc-members: + +.. autoclass:: dateparser.PartOfDay + :members: + :undoc-members: + ``PARSERS``: it is a list of names of parsers to try, allowing to customize which parsers are tried against the input date string, and in which order they are tried. diff --git a/tests/test_data.py b/tests/test_data.py index 4863b0dea..30127d11d 100644 --- a/tests/test_data.py +++ b/tests/test_data.py @@ -61,6 +61,11 @@ "second", "am", "pm", + "early_morning", + "morning", + "afternoon", + "evening", + "night", "relative-type", "relative-type-regex", "sentence_splitter_group", diff --git a/tests/test_parts_of_day.py b/tests/test_parts_of_day.py new file mode 100644 index 000000000..745a872c0 --- /dev/null +++ b/tests/test_parts_of_day.py @@ -0,0 +1,92 @@ +from datetime import datetime, time + +import pytest + +from dateparser import PartOfDay, PartsOfDay, parse +from dateparser.conf import SettingValidationError +from dateparser.date import DateDataParser +from dateparser.search import search_dates + +BASE = datetime(2026, 9, 28, 15, 0) + + +@pytest.mark.parametrize( + ("date_string", "languages", "expected"), + [ + ("tonight", ["en"], datetime(2026, 9, 28, 20, 0)), + ("last night", ["en"], datetime(2026, 9, 27, 20, 0)), + ("this morning", ["en"], datetime(2026, 9, 28, 9, 0)), + ("tomorrow in the afternoon", ["en"], datetime(2026, 9, 29, 15, 0)), + ("monday evening", ["en"], datetime(2026, 9, 28, 18, 0)), + ("yesterday in the small hours", ["en"], datetime(2026, 9, 27, 3, 0)), + ("Sunday, January 4, 2026 at night", ["en"], datetime(2026, 1, 4, 20, 0)), + ("tonight at 11pm", ["en"], datetime(2026, 9, 28, 23, 0)), + ("8 in the evening", ["en"], datetime(2026, 9, 28, 20, 0)), + ("tomorrow at 7:30 in the morning", ["en"], datetime(2026, 9, 29, 7, 30)), + ("12 at night", ["en"], datetime(2026, 9, 28, 0, 0)), + ("2 at night", ["en"], datetime(2026, 9, 28, 2, 0)), + ("January 8 in the evening", ["en"], datetime(2026, 1, 8, 18, 0)), + ("January 8 at 9 in the evening", ["en"], datetime(2026, 1, 8, 21, 0)), + ("2026-01-05 at night", ["en"], datetime(2026, 1, 5, 20, 0)), + ("3 de mayo a las 5 de la madrugada", ["es"], datetime(2026, 5, 3, 5, 0)), + ("esta madrugada", ["es"], datetime(2026, 9, 28, 3, 0)), + ("mañana de madrugada", ["es"], datetime(2026, 9, 29, 3, 0)), + ("ontem de madrugada", ["pt"], datetime(2026, 9, 27, 3, 0)), + ("onte pola madrugada", ["gl"], datetime(2026, 9, 27, 3, 0)), + ("night", ["en"], None), + ("17 in the afternoon", ["en"], None), + ], +) +def test_parse( + date_string: str, languages: list[str], expected: datetime | None +) -> None: + settings = {"RELATIVE_BASE": BASE} + assert parse(date_string, languages=languages, settings=settings) == expected + + +@pytest.mark.parametrize( + ("date_string", "return_time_as_period", "period"), + [ + ("tonight", True, "part_of_day"), + ("tonight", False, "day"), + ("tonight at 11pm", True, "time"), + ], +) +def test_date_data(date_string: str, return_time_as_period: bool, period: str) -> None: + parser = DateDataParser( + settings={"RELATIVE_BASE": BASE, "RETURN_TIME_AS_PERIOD": return_time_as_period} + ) + date_data = parser.get_date_data(date_string) + assert date_data.period == period + assert date_data.part_of_day is PartOfDay.NIGHT + + +def test_date_data_without_part_of_day() -> None: + date_data = DateDataParser().get_date_data("today") + assert date_data.part_of_day is None + assert "part_of_day" not in repr(date_data) + + +def test_setting() -> None: + settings = {"RELATIVE_BASE": BASE, "PARTS_OF_DAY": PartsOfDay(night=time(22, 30))} + assert parse("tonight", settings=settings) == datetime(2026, 9, 28, 22, 30) + + +def test_setting_validation() -> None: + with pytest.raises(SettingValidationError): + parse("tonight", settings={"PARTS_OF_DAY": {"night": time(22)}}) + with pytest.raises(TypeError): + PartsOfDay(night="22:00") # type: ignore[arg-type] + + +def test_search_dates() -> None: + assert search_dates( + "There is a party tonight. It was a dark night.", + languages=["en"], + settings={"RELATIVE_BASE": BASE}, + ) == [("tonight", datetime(2026, 9, 28, 20, 0))] + assert search_dates( + "Llegó a las 5 de la madrugada del 3 de mayo", + languages=["es"], + settings={"RELATIVE_BASE": BASE}, + ) == [("a las 5 de la madrugada del 3 de mayo", datetime(2026, 5, 3, 5, 0))] From 4574502d826082d5fec07da95332749c63e3ffa6 Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 19:35:22 +0200 Subject: [PATCH 100/107] Deprecate dateparser.timezone_parser.convert_to_local_tz (#1481) --- dateparser/timezone_parser.py | 7 +++++++ tests/test_timezone_parser.py | 7 +++++++ 2 files changed, 14 insertions(+) diff --git a/dateparser/timezone_parser.py b/dateparser/timezone_parser.py index 0598ac62d..0cdd83ea6 100644 --- a/dateparser/timezone_parser.py +++ b/dateparser/timezone_parser.py @@ -1,3 +1,4 @@ +import warnings from collections.abc import Iterator from datetime import datetime, timedelta, timezone, tzinfo from typing import Literal, TypedDict, overload @@ -124,6 +125,12 @@ def is_timezone_token(token: str) -> bool: def convert_to_local_tz( datetime_obj: datetime, datetime_tz_offset: timedelta ) -> datetime: + warnings.warn( + "dateparser.timezone_parser.convert_to_local_tz is deprecated and " + "will be removed in a future version.", + FutureWarning, + stacklevel=2, + ) return datetime_obj - datetime_tz_offset + local_tz_offset diff --git a/tests/test_timezone_parser.py b/tests/test_timezone_parser.py index a09e2664a..8a58ab468 100644 --- a/tests/test_timezone_parser.py +++ b/tests/test_timezone_parser.py @@ -12,6 +12,7 @@ from dateparser import parse from dateparser.timezone_parser import ( StaticTzInfo, + convert_to_local_tz, get_local_tz_offset, is_timezone_token, pop_tz_offset_from_string, @@ -512,3 +513,9 @@ def test_repeated_abbreviation_resolves_to_its_first_entry(self) -> None: self.checker.static_tz_abbreviations()["LMT"], self.offset_of("13 August 2026 10:00 LMT").total_seconds(), ) + + +class TestConvertToLocalTz(BaseTestCase): + def test_deprecated(self) -> None: + with self.assertWarns(FutureWarning): + convert_to_local_tz(datetime(2020, 1, 1), timedelta(0)) From 9073f253a7a07ff737c289e3e4236b0232e141ab Mon Sep 17 00:00:00 2001 From: Adrian Date: Wed, 30 Sep 2026 19:50:58 +0200 Subject: [PATCH 101/107] Parse Roman numeral years (#1482) --- dateparser/date.py | 43 +++++++++++++++++++++++++++------- dateparser/languages/locale.py | 4 +--- tests/test_date.py | 5 ++++ tests/test_date_parser.py | 6 +++++ tests/test_search.py | 24 ------------------- 5 files changed, 47 insertions(+), 35 deletions(-) diff --git a/dateparser/date.py b/dateparser/date.py index 104bd9e6e..39b4381eb 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -105,6 +105,20 @@ RE_SANITIZE_ON = re.compile(r"^.*?on:\s+(.*)") RE_SANITIZE_APOSTROPHE = re.compile("|".join(APOSTROPHE_LOOK_ALIKE_CHARS)) RE_SANITIZE_DASH = re.compile("|".join(DASH_LOOK_ALIKE_CHARS)) +# Uppercase Roman numerals from 1000 on, allowing the additive IIII, XXXX and +# CCCC of old prints. +_RE_ROMAN_YEAR = re.compile( + r"\bM{1,3}(?:CM|CD|D?C{0,4})(?:XC|XL|L?X{0,4})(?:IX|IV|V?I{0,4})\b" +) +_ROMAN_NUMERAL_VALUES = { + "M": 1000, + "D": 500, + "C": 100, + "L": 50, + "X": 10, + "V": 5, + "I": 1, +} RE_SEARCH_TIMESTAMP = re.compile(r"^(\d{10})(\d{3})?(\d{3})?(?![^.])") RE_SEARCH_NEGATIVE_TIMESTAMP = re.compile(r"^([-]\d{10})(\d{3})?(\d{3})?(?![^.])") @@ -195,6 +209,7 @@ def sanitize_date(date_string: str) -> str: ) # extra '.' and 'u' interferes with parsing relative fractional dates date_string = sanitize_spaces(date_string) date_string = RE_SANITIZE_PERIOD.sub("", date_string) + date_string = _RE_ROMAN_YEAR.sub(_roman_year_to_digits, date_string) date_string = RE_SANITIZE_DECIMAL_COMMA.sub(".", date_string) date_string = RE_SANITIZE_ON.sub(r"\1", date_string) date_string = RE_TRIM_COLONS.sub(r"\1", date_string) @@ -203,6 +218,20 @@ def sanitize_date(date_string: str) -> str: return date_string.strip() +def _roman_year_to_digits(match: re.Match[str]) -> str: + numeral = match[0] + # Too ambiguous with abbreviations like MD or MC. + if len(numeral) < 3: + return numeral + values = [_ROMAN_NUMERAL_VALUES[char] for char in numeral] + return str( + sum( + -value if value < next_value else value + for value, next_value in zip(values, [*values[1:], 0], strict=True) + ) + ) + + def get_date_from_timestamp( date_string: str, settings: Settings | None, negative: bool = False ) -> datetime | None: @@ -344,22 +373,20 @@ def _get_name_translations( locale: "Locale", month_form: str | None, weekday_form: str | None ) -> tuple[re.Pattern[str], dict[str, list[str]]] | None: """Return a pattern matching the month and weekday names of *locale*, and - a mapping of each lowercase name to the English names it can stand for. + a mapping of each lowercase name to the English names it can stand for, or + ``None`` if there are no such names. *month_form* and *weekday_form* are ``"full"``, ``"abbr"`` or ``None``, the English form to translate each kind of name into, or ``None`` to leave that kind of name untranslated. """ - translations: collections.defaultdict[str, list[str]] = collections.defaultdict( - list - ) + translations: dict[str, list[str]] = collections.defaultdict(list) for words, form in ((_MONTHS, month_form), (_WEEKDAYS, weekday_form)): if form is None: continue for word in words: english = word if form == "full" else word[:3] - for localized in locale.info.get(word, ()): - name = localized.lower() + for name in map(str.lower, locale.info.get(word, ())): if english not in translations[name]: translations[name].append(english) if not translations: @@ -391,14 +418,14 @@ def _translate_names( matches = pattern.findall(date_string) if not matches: return - pieces = pattern.split(date_string) + parts = pattern.split(date_string) # A name can stand for several English names, e.g. "mar" is both "martes" # and "marzo" in Spanish, so every combination is yielded. for combination in itertools.product( *(translations[match.lower()] for match in matches) ): yield "".join( - itertools.chain.from_iterable(zip(pieces, (*combination, ""), strict=True)) + part + name for part, name in zip(parts, (*combination, ""), strict=True) ) diff --git a/dateparser/languages/locale.py b/dateparser/languages/locale.py index 1fcc490d7..ae9832986 100644 --- a/dateparser/languages/locale.py +++ b/dateparser/languages/locale.py @@ -545,9 +545,7 @@ def _split_dict(self, dictionary: Dictionary) -> dict[str, str | None]: def _word_split(self, string: str, settings: "Settings | None") -> list[str]: if "no_word_spacing" in self.info: return self._split(string, keep_formatting=True, settings=settings) - # A colon right after a letter ends a label, as in - # "birthday:2020-07-08", while one after a digit belongs to a time. - return re.sub(r"(?<=[^\W\d_]:)(?=\w)", " ", string).split() + return string.split() def _split( self, diff --git a/tests/test_date.py b/tests/test_date.py index d0f3f8ec5..8b0aab35f 100644 --- a/tests/test_date.py +++ b/tests/test_date.py @@ -1379,6 +1379,11 @@ def test_remove_year_in_russian(self) -> None: self.assertEqual(date.sanitize_date("2005 г. 15:24"), "2005 15:24") self.assertEqual(date.sanitize_date("Авг."), "Авг") + def test_sanitize_date_roman_numeral_years(self) -> None: + self.assertEqual(date.sanitize_date("Anno MDCCXVII."), "Anno 1717") + for date_string in ("MD", "MIXED", "mdccxvii", "MDCLXXXIIX", "CMXCIX"): + self.assertEqual(date.sanitize_date(date_string), date_string) + def test_sanitize_date_decimal_comma(self) -> None: self.assertEqual(date.sanitize_date("06:38:49,946"), "06:38:49.946") self.assertEqual(date.sanitize_date("06:38:49,12 June"), "06:38:49,12 June") diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 448b55227..455cbab3b 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -1201,6 +1201,12 @@ def test_parse_timestamp_with_time_as_period( param("²⁹/⁰⁵/²⁰¹⁵", expected=datetime(2015, 5, 29), period="day"), param("₁₅/₀₂/₂₀₂₀", expected=datetime(2020, 2, 15), period="day"), param("₃₁ December", expected=datetime(2015, 12, 31), period="day"), + # Roman numeral years + param("MCMXCIX", expected=datetime(1999, 2, 15), period="year"), + param("M.DC.LXXIX.", expected=datetime(1679, 2, 15), period="year"), + param( + "April MCCCCLXXVIIII", expected=datetime(1479, 4, 15), period="month" + ), # Russian param("1000 год", expected=datetime(1000, 2, 15), period="year"), param("1001 год", expected=datetime(1001, 2, 15), period="year"), diff --git a/tests/test_search.py b/tests/test_search.py index 4e3e9f45e..e4296e903 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1343,30 +1343,6 @@ def test_search_dates_returning_detected_languages_if_requested( result = search_dates(text, add_detected_language=add_detected_language) self.assertEqual(result, expected) - @parameterized.expand( - [ - param( - text="birthday:2020-07-08", - expected=[("2020-07-08", datetime.datetime(2020, 7, 8, 0, 0))], - ), - param( - text="Date:July 8, 2020", - expected=[("July 8, 2020", datetime.datetime(2020, 7, 8, 0, 0))], - ), - param( - text="at:10:30 on 2020-07-08", - expected=[ - ("10:30 on 2020-07-08", datetime.datetime(2020, 7, 8, 10, 30)) - ], - ), - ] - ) - def test_search_dates_after_a_label_and_a_colon( - self, text: str, expected: list[tuple[str, datetime.datetime]] - ) -> None: - result = search_dates(text, languages=["en"]) - self.assertEqual(result, expected) - @parameterized.expand( [ param(text="19 марта 2001", languages="wrong type: str instead of list"), From 260fe0c6513ea8a2977652621342e20f162b6cb9 Mon Sep 17 00:00:00 2001 From: Adrian Date: Fri, 2 Oct 2026 16:30:10 +0200 Subject: [PATCH 102/107] Close spam PRs automatically (#1533) --- .github/workflows/close-spam-prs.yml | 295 +++++++++++++++++++++++++++ 1 file changed, 295 insertions(+) create mode 100644 .github/workflows/close-spam-prs.yml diff --git a/.github/workflows/close-spam-prs.yml b/.github/workflows/close-spam-prs.yml new file mode 100644 index 000000000..5b1168111 --- /dev/null +++ b/.github/workflows/close-spam-prs.yml @@ -0,0 +1,295 @@ +name: Close spam PRs +# Closes as spam pull requests whose author's public activity suggests that an +# LLM is writing them without supervision, and records the evidence in the +# workflow run summary so that reviewing the decision does not require reading +# a user profile. Reopening and removing the label is all it takes to overrule +# it. +# +# Four independent signals, any of which is enough to close. Each one abstains +# when the data it needs is unavailable, so a missing signal never counts +# against an author: +# +# - Rejection burst: pull requests of theirs closed unmerged elsewhere within +# the last month. Volume of rejections in absolute terms separates spraying +# from ordinary contribution far better than a merge ratio does, since +# ratios reward authors who accumulate merges in trivial repositories. +# - Spray breadth: unrelated repositories they open pull requests against +# within one week. Breadth catches an agent on its first day, before any of +# its pull requests have been closed, and it comes from the event feed, so it +# also covers authors that the search API refuses to return. +# - Assistant voice: their recent comments across GitHub read as assistant +# output rather than as a developer talking, by section headings, bullet +# lists, em dash density or stock acknowledgement phrases. +# - Agent branch: the branch name carries an agent prefix. +# +# The signals build up over time: the author's other pull requests get closed +# elsewhere, and the spray reaches more repositories after this one. So besides +# scoring each pull request when it is opened, the same scoring runs every few +# hours over the pull requests opened within the last few days. That pass +# leaves alone any pull request that a maintainer has commented on, reviewed +# or reopened, so a human decision is never overturned. +# +# Authors that the organisations behind this repository already trust are left +# alone before any of that runs: public members of those organisations, and +# authors with a track record of pull requests merged into their repositories. +# Trust from a merge record rather than from a list of names keeps the exemption +# in step with who is actually contributing. +# +# Deliberately not used: account age, fork age, follower count, total pull +# request count and cross-repository merge ratio. All of them were measured +# against hand-labelled pull requests and either failed to separate or, in the +# case of the merge ratio, inverted on held-out data. +# +# The workflow only reads pull request and public activity metadata through the +# API, it never checks out or runs pull request code, so pull_request_target is +# safe here. +on: # zizmor: ignore[dangerous-triggers] + pull_request_target: + types: [opened] + schedule: + - cron: '0 */6 * * *' + workflow_dispatch: +permissions: + contents: read + pull-requests: write +jobs: + close-spam-pr: + name: Close PRs if the author's activity suggests unsupervised LLM use + runs-on: ubuntu-latest + steps: + - name: Score the authors and close the PRs + uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + script: | + const LABEL = 'spam'; + const RETRIES = 5; + const RETRY_WAIT_MS = 60000; + const REJECTION_WINDOW_DAYS = 30; + const RECHECK_WINDOW_DAYS = 3; + const MIN_REJECTIONS = 1; + const MIN_COMMENTS = 2; + const MAX_REPOS_PER_WEEK = 2; + const VOICE = { structure: 0.10, emDashPerKChar: 0.30, acknowledgement: 0.40 }; + const EVENT_PAGES = 3; + const TRUSTED_ORGS = ['scrapy', 'scrapy-plugins', 'scrapinghub', 'zytedata']; + const MIN_TRUSTED_MERGES = 10; + const AGENT_BRANCH = /^(agent|codex|claude|cursor|devin|copilot|jules|bot)[\/_-]/i; + + const { owner, repo } = context.repo; + const now = new Date(); + const daysAgo = date => (now - new Date(date)) / 86400000; + + // Rate and abuse limits reset on the order of a minute, so waiting + // is enough; other errors are not worth retrying. + const retriable = new Set([403, 429, 500, 502, 503, 504]); + const sleep = ms => new Promise(resolve => setTimeout(resolve, ms)); + async function withRetries(description, call) { + for (let attempt = 1; ; attempt++) { + try { + return await call(); + } catch (error) { + if (!retriable.has(error.status) || attempt > RETRIES) throw error; + const reset = Number(error.response?.headers?.['x-ratelimit-reset']) * 1000 - Date.now(); + const after = Number(error.response?.headers?.['retry-after']) * 1000; + const wait = Math.min(Math.max(after || reset || RETRY_WAIT_MS, RETRY_WAIT_MS), 15 * RETRY_WAIT_MS); + core.info(`${description} failed with ${error.status}, retrying in ${Math.round(wait / 1000)}s (attempt ${attempt}/${RETRIES}).`); + await sleep(wait); + } + } + } + // Accounts excluded from search, deleted users and the like leave a + // signal unmeasurable rather than negative. + const orNull = promise => promise.catch(error => { + if ([404, 410, 422].includes(error.status)) return null; + throw error; + }); + + async function score(pr) { + const author = pr.user.login; + + // author_association only reports membership of the organisation + // that owns this repository, and only when it is public, so trust + // in the author is established here instead. + const trustedOrg = (await Promise.all(TRUSTED_ORGS.map(org => + orNull(withRetries(`Checking public membership of ${org}`, () => + github.rest.orgs.checkPublicMembershipForUser({ org, username: author }), + )).then(response => response && org), + ))).find(Boolean); + if (trustedOrg) { + core.info(`Skipping PR #${pr.number} by ${author} (public member of ${trustedOrg}).`); + return; + } + // Repeating a qualifier narrows the search instead of widening it, + // hence the explicit disjunction. + const trustedMerges = await orNull(withRetries('Counting merged PRs in trusted organisations', () => + github.rest.search.issuesAndPullRequests({ + q: `author:${author} type:pr is:merged` + + ` (${TRUSTED_ORGS.map(org => `org:${org}`).join(' OR ')})`, + advanced_search: 'true', per_page: 1, + }).then(response => response.data.total_count), + )); + if (trustedMerges >= MIN_TRUSTED_MERGES) { + core.info(`Skipping PR #${pr.number} by ${author}` + + ` (${trustedMerges} PR(s) merged into ${TRUSTED_ORGS.join(', ')}).`); + return; + } + + // Signal 1: pull requests closed unmerged elsewhere, recently. + const search = await orNull(withRetries('Searching for PRs by the author', () => + github.rest.search.issuesAndPullRequests({ + q: `author:${author} type:pr`, advanced_search: 'true', + sort: 'created', order: 'desc', per_page: 100, + }).then(response => response.data), + )); + let rejections = null; + if (search) { + rejections = search.items.filter(item => { + const itemOwner = item.repository_url.split('/repos/')[1].split('/')[0].toLowerCase(); + return itemOwner !== author.toLowerCase() + && item.state === 'closed' && !item.pull_request?.merged_at + && daysAgo(item.created_at) <= REJECTION_WINDOW_DAYS; + }).map(item => item.html_url); + } + + // Signal 2: how their recent comments across GitHub read. + const events = []; + for (let page = 1; page <= EVENT_PAGES; page++) { + const batch = await orNull(withRetries(`Reading public events page ${page}`, () => + github.rest.activity.listPublicEventsForUser({ + username: author, per_page: 100, page, + }).then(response => response.data), + )); + if (!batch?.length) break; + events.push(...batch); + if (batch.length < 100) break; + } + const comments = events + .filter(event => ['IssueCommentEvent', 'PullRequestReviewCommentEvent'].includes(event.type)) + .map(event => event.payload?.comment?.body) + .filter(Boolean); + + // Signal 3: how many unrelated projects they open pull requests + // against in a single week. Breadth rather than volume: a focused + // contributor sends many pull requests to few repositories, while + // an unattended agent sprays a few across many. Taken from the + // event feed, which unlike search covers authors that search + // refuses to return. + const weeks = {}; + for (const event of events) { + if (event.type !== 'PullRequestEvent' || event.payload?.action !== 'opened') continue; + const name = event.repo?.name; + if (!name || name.toLowerCase().startsWith(`${author.toLowerCase()}/`)) continue; + const week = Math.floor(new Date(event.created_at) / (7 * 86400000)); + (weeks[week] ??= new Set()).add(name); + } + const breadth = events.length + ? Math.max(0, ...Object.values(weeks).map(repos => repos.size)) + : null; + const STRUCTURE = [/^\s*#{2,3}\s/m, /^\s*[-*]\s.+\n\s*[-*]\s/m, /\*\*[^*]+\*\*/, /```/]; + const ACKNOWLEDGEMENT = [ + /thanks for (the )?(review|feedback|pointing|catching|flagging|clarif)/i, + /you'?re (absolutely )?right/i, /great catch/i, /that makes sense/i, + /i'?ll (continue|investigate|update|submit|look into|make sure)/i, + /let me know (if|whether)/i, /happy to (update|adjust|revise|change)/i, + /i understand that/i, /thanks for your time/i, /just following up/i, + /hope (this|that) helps/i, /please let me know/i, /i'?ve (updated|addressed|fixed)/i, + ]; + let voice = null; + if (comments.length >= MIN_COMMENTS) { + const chars = comments.reduce((total, body) => total + body.length, 0); + const rate = patterns => comments.filter(body => patterns.some(re => re.test(body))).length / comments.length; + voice = { + comments: comments.length, + structure: rate(STRUCTURE), + acknowledgement: rate(ACKNOWLEDGEMENT), + emDashPerKChar: 1000 * comments.reduce((total, body) => total + (body.match(/—/g) || []).length, 0) / chars, + }; + } + + const reasons = []; + if (rejections && rejections.length >= MIN_REJECTIONS) { + reasons.push(`${rejections.length} PR(s) of theirs closed unmerged elsewhere in the last` + + ` ${REJECTION_WINDOW_DAYS} days: ${rejections.slice(0, 10).join(' ')}`); + } + if (voice && (voice.structure > VOICE.structure + || voice.emDashPerKChar > VOICE.emDashPerKChar + || voice.acknowledgement > VOICE.acknowledgement)) { + reasons.push(`comment style over ${voice.comments} recent comments:` + + ` ${(100 * voice.structure).toFixed(0)}% structured,` + + ` ${(100 * voice.acknowledgement).toFixed(0)}% stock acknowledgements,` + + ` ${voice.emDashPerKChar.toFixed(2)} em dashes per 1000 characters`); + } + if (breadth !== null && breadth > MAX_REPOS_PER_WEEK) { + reasons.push(`opened pull requests against ${breadth} unrelated repositories within a week`); + } + if (AGENT_BRANCH.test(pr.head?.ref || '')) { + reasons.push(`branch name carries an agent prefix: ${pr.head.ref}`); + } + + await core.summary + .addHeading(`PR #${pr.number} by ${author}`, 3) + .addList([ + rejections === null + ? 'recent rejections elsewhere: unmeasurable, the author cannot be searched' + : `recent rejections elsewhere: ${rejections.length}`, + voice === null + ? `comment style: unmeasurable, fewer than ${MIN_COMMENTS} recent comments found` + : `comment style: ${(100 * voice.structure).toFixed(0)}% structured,` + + ` ${(100 * voice.acknowledgement).toFixed(0)}% stock acknowledgements,` + + ` ${voice.emDashPerKChar.toFixed(2)} em dashes per 1000 characters` + + ` over ${voice.comments} comments`, + breadth === null + ? 'repositories per week: unmeasurable, no public events found' + : `repositories per week, at most: ${breadth}`, + `branch: ${pr.head?.ref ?? 'unknown'}`, + `verdict: ${reasons.length ? `closed as ${LABEL}` : 'left open'}`, + ]) + .addRaw(reasons.length ? `\n${reasons.map(reason => `- ${reason}`).join('\n')}\n` : '') + .write(); + + if (!reasons.length) { + core.info(`Leaving PR #${pr.number} open.`); + return; + } + await withRetries('Adding the label', () => + github.rest.issues.addLabels({ owner, repo, issue_number: pr.number, labels: [LABEL] }), + ); + await withRetries('Closing the PR', () => + github.rest.pulls.update({ owner, repo, pull_number: pr.number, state: 'closed' }), + ); + core.info(`Closed PR #${pr.number} as ${LABEL}: ${reasons.join(' | ')}`); + } + + // A maintainer who has commented on, reviewed or reopened a pull + // request has already made the call. + async function attended(pr) { + const timeline = await withRetries(`Reading the timeline of PR #${pr.number}`, () => + github.paginate(github.rest.issues.listEventsForTimeline, { + owner, repo, issue_number: pr.number, per_page: 100, + }), + ); + return timeline.some(event => event.event === 'reopened' + || (['commented', 'reviewed'].includes(event.event) + && event.user?.login !== pr.user.login && event.user?.type !== 'Bot')); + } + + const opened = context.payload.pull_request; + const prs = opened ? [opened] : (await withRetries('Listing open PRs', () => + github.paginate(github.rest.pulls.list, { + owner, repo, state: 'open', sort: 'created', direction: 'desc', per_page: 100, + }), + )).filter(pr => daysAgo(pr.created_at) <= RECHECK_WINDOW_DAYS); + core.info(`Scoring ${prs.length} PR(s).`); + for (const pr of prs) { + if (pr.user.type === 'Bot' + || ['MEMBER', 'OWNER', 'COLLABORATOR'].includes(pr.author_association)) { + core.info(`Skipping PR #${pr.number} by ${pr.user.login} (${pr.user.type}, ${pr.author_association}).`); + continue; + } + if (!opened && await attended(pr)) { + core.info(`Skipping PR #${pr.number} by ${pr.user.login} (a maintainer has already looked at it).`); + continue; + } + await score(pr); + } From b7d0e8bcfa772b61ade0e8535c3e8a15d2590688 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Fri, 2 Oct 2026 16:48:29 +0200 Subject: [PATCH 103/107] Add a STRICT_DATE_ORDER setting to enforce the year position or the whole DATE_ORDER (#868) (#1443) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add a STRICT_DATE_ORDER setting so that an invalid day is not read as the year (#868) DATE_ORDER is a preference: any number that is not a valid day or month is read as a two-digit year, so "32 DEC 10" with DATE_ORDER="DMY" is 2032-12-10. With the new setting, which defaults to False, a two-digit year is read only where DATE_ORDER puts the year, and such a date string gives None instead. The rejection is final: no other locale may guess another reading, and the no-spaces parser, which would read the same numbers in a date order again, is skipped. The other parsers of the locale still get their turn. Co-Authored-By: Claude Fable 5.1 * Make STRICT_DATE_ORDER a string that can also enforce the day and month The setting is now "none" (the default), "year" or "all", so that it can name all three behaviours: DATE_ORDER as a preference, the position of a two-digit year enforced, or the whole order enforced. With "all", a day and a month that do not fit are no longer swapped, neither in the token loop nor through the retry with the swapped order: "13/12/10" with DATE_ORDER="MDY" is None. A four-digit year is still read wherever it is, and a date that starts with one is still read as year, month and day. With "all", a date string that cannot be read in DATE_ORDER at all is final too, so that no other locale reads it differently: with auto-detected languages, "10年20月00日" with DMY would otherwise come back from zh as a relative date, 10 years and 20 months ago. Co-Authored-By: Claude Fable 5.1 * Make STRICT_DATE_ORDER="year" reject a misplaced year in both directions A two-digit year is now read only where DATE_ORDER puts the year: the day and month read before it must be the ones the order puts before it. Until now only a day or month that the order puts before the year, but is read after it, was rejected, so "32 DEC 10" with DMY was None but "10 DEC 32" with MYD was still 2032-12-10, and "year" did nothing at all for YMD and YDM, where no part comes before the year. This also rejects #519's last-resort "4-99" with YMD, which is acceptable for an opt-in setting. DMY and MDY are not affected, since nothing comes after the year in them. The day and month swap is now also tested under DYM and MYD, where the year is between them and the swap changes which of them is read before it. Co-Authored-By: Claude Sonnet 5.5 * Raise SettingValidationError when STRICT_DATE_ORDER has no DATE_ORDER to enforce "year" and "all" only enforce a DATE_ORDER that the caller sets, since the default one is a preference, so without one they silently did nothing. Raise a SettingValidationError from check_settings instead, which only looks at the settings the caller passed, so the rebuilt settings of search_dates, which forget those, cannot trigger it. "none" does not need a DATE_ORDER. The cases that pinned "no effect without DATE_ORDER" are replaced by tests of the error, of "none", and of search_dates and a reused parser, which keep working. Co-Authored-By: Claude Sonnet 5.5 * Shorten the STRICT_DATE_ORDER docs to the year rule and the two caveats "year" now reads as one rule: a two-digit year is read only from the position DATE_ORDER gives the year. Of the details after the examples, only two matter to users, that "year" and "all" need DATE_ORDER, and that '95年12月10日' with MDY is rejected. The rest, such as that a rejection is final across locales, which parsers still run, and that a month name or a missing part is not checked, is in the code comments. Co-Authored-By: Claude Sonnet 5.5 * Drop the right day when a month name follows a day range 05f2737 records in auto_order that the end of a day range is dropped when a month name follows it, but it always deleted the entry after the month. In a day-first order, as in "12-12 June 2021" with DMY or "5-5 juin 2021" in French, the day comes before the month, so the deletion raised IndexError, parse_alpha swallowed it and the month name was not read: the date was None even without STRICT_DATE_ORDER, unlike master. Remove the day entry itself instead. Co-Authored-By: Claude Opus 5.5 * Test that a two-digit year is still the last resort under STRICT_DATE_ORDER Moving "4-99" with YMD and "10 DEC 32" with MYD to the rejected cases left no test of #519's two-digit year fallback under STRICT_DATE_ORDER, and left its comment on "10年20月00日", which goes through the day and month swap instead. Also say what the search_dates test checks: that it does not raise. Co-Authored-By: Claude Opus 5.5 * Say in the STRICT_DATE_ORDER docs which parts are checked Without it, "read a two-digit year only from the position DATE_ORDER gives the year" suggests that "32 DEC" with DMY is rejected too, but a month name and a missing part are not checked, and a four-digit year is read wherever it is. Co-Authored-By: Claude Opus 5.5 * Drop issue numbers from two comments and fix the STRICT_DATE_ORDER examples Quote the values of the setting in the docs, since they are strings, and drop the None lines from its examples, since the REPL prints nothing for None. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Fable 5.1 --- dateparser/conf.py | 12 ++ dateparser/date.py | 44 ++++-- dateparser/parser.py | 140 +++++++++++++++-- dateparser_data/settings.py | 1 + docs/settings.rst | 16 ++ stubs/parameterized/__init__.pyi | 2 + tests/test_date_parser.py | 250 +++++++++++++++++++++++++++++++ tests/test_settings.py | 67 +++++++++ 8 files changed, 513 insertions(+), 19 deletions(-) diff --git a/dateparser/conf.py b/dateparser/conf.py index 23fa1eb24..29180f2fe 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -22,6 +22,7 @@ class Settings: * `DATE_ORDER` * `PREFER_LOCALE_DATE_ORDER` + * `STRICT_DATE_ORDER` * `TIMEZONE` * `TO_TIMEZONE` * `RETURN_AS_TIMEZONE_AWARE` @@ -53,6 +54,7 @@ class Settings: registry_key: str DATE_ORDER: str PREFER_LOCALE_DATE_ORDER: bool + STRICT_DATE_ORDER: str TIMEZONE: str TO_TIMEZONE: str | Literal[False] RETURN_AS_TIMEZONE_AWARE: bool | Literal["default"] @@ -261,6 +263,7 @@ def check_settings(settings: Settings) -> None: }, "FUZZY": {"type": bool}, "PREFER_LOCALE_DATE_ORDER": {"type": bool}, + "STRICT_DATE_ORDER": {"values": ("none", "year", "all"), "type": str}, "DEFAULT_LANGUAGES": {"type": list, "extra_check": _check_default_languages}, "USE_GIVEN_LANGUAGE_ORDER": {"type": bool}, "LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD": { @@ -315,3 +318,12 @@ def check_settings(settings: Settings) -> None: extra_check = setting_props.get("extra_check") if extra_check: extra_check(setting_name, setting_value) + + # STRICT_DATE_ORDER enforces the DATE_ORDER that the caller sets. The default + # one is only a preference, so without it there is nothing to enforce. + strict_date_order = modified_settings.get("STRICT_DATE_ORDER", "none") + if strict_date_order != "none" and "DATE_ORDER" not in modified_settings: + raise SettingValidationError( + f'"STRICT_DATE_ORDER": "{strict_date_order}" requires the "DATE_ORDER" ' + "setting" + ) diff --git a/dateparser/date.py b/dateparser/date.py index 39b4381eb..fdfa8ec39 100644 --- a/dateparser/date.py +++ b/dateparser/date.py @@ -17,7 +17,7 @@ from dateparser.date_parser import date_parser from dateparser.freshness_date_parser import freshness_date_parser from dateparser.languages.loader import LocaleDataLoader -from dateparser.parser import _parse_absolute, _parse_nospaces +from dateparser.parser import _parse_absolute, _parse_nospaces, _StrictDateOrderError from dateparser.timezone_parser import pop_tz_offset_from_string from dateparser.utils import ( _get_localzone, @@ -499,8 +499,18 @@ def _parse(self) -> "DateData | None": return None def _parse_translation(self) -> "DateData | None": + rejected: _StrictDateOrderError | None = None for parser_name in self._settings.PARSERS: - date_data = self._parsers[parser_name]() + if rejected is not None and parser_name == "no-spaces-time": + # It would read the same numbers in a date order again. + continue + try: + date_data = self._parsers[parser_name]() + except _StrictDateOrderError as error: + # STRICT_DATE_ORDER rejected the reading of this parser. The + # other parsers may still read the date string. + rejected = error + continue if self._is_valid_date_data(date_data): if self._part_of_day: date_data.part_of_day = self._part_of_day @@ -510,6 +520,8 @@ def _parse_translation(self) -> "DateData | None": ): date_data.period = "part_of_day" return date_data + if rejected is not None: + raise rejected return None def _try_timestamp_parser(self, negative: bool = False) -> "DateData": @@ -580,6 +592,10 @@ def _try_parser( date_order=order, ) return DateData(date_obj=date_obj, period=period, parts=parts) + except _StrictDateOrderError: + # Only raised with an explicit DATE_ORDER, which leaves a single + # candidate order. + raise except ValueError: continue return None @@ -871,16 +887,24 @@ def get_date_data( date_string = sanitize_date(date_string) - parsed_date = self._parse_using_applicable_locales(date_string, date_formats) - if not parsed_date and self._settings.IGNORE_SURROUNDING_TEXT: - # The whole string could not be parsed as a date. Retry, ignoring - # unrecognized words at the edges of the string, so that a date - # wrapped in harmless extra text is still parsed (issue #518), - # e.g. "Actualisé le 17 avril 2019". Strings that can be parsed as - # a whole never reach this fallback, so they are unaffected. + try: parsed_date = self._parse_using_applicable_locales( - date_string, date_formats, ignore_surrounding_text=True + date_string, date_formats ) + if not parsed_date and self._settings.IGNORE_SURROUNDING_TEXT: + # The whole string could not be parsed as a date. Retry, + # ignoring unrecognized words at the edges of the string, so + # that a date wrapped in harmless extra text is still parsed + # (issue #518), e.g. "Actualisé le 17 avril 2019". Strings that + # can be parsed as a whole never reach this fallback, so they + # are unaffected. + parsed_date = self._parse_using_applicable_locales( + date_string, date_formats, ignore_surrounding_text=True + ) + except _StrictDateOrderError: + # STRICT_DATE_ORDER rejected a reading of the date string, which + # is final: no other locale may guess another reading of it. + parsed_date = None return parsed_date or DateData(date_obj=None, period="day", locale=None) def _parse_with_localized_formats( diff --git a/dateparser/parser.py b/dateparser/parser.py index ef97bf2f9..d123cb2af 100644 --- a/dateparser/parser.py +++ b/dateparser/parser.py @@ -81,6 +81,63 @@ def resolve_date_order(order: str, lst: bool | None = None) -> str | list[str]: return chart_list[order] if lst else date_order_chart[order] +class _StrictDateOrderError(ValueError): + """The date string does not fit DATE_ORDER as STRICT_DATE_ORDER requires: + a number was read as a part that the order does not put at its position, + or with "all", a number could not be read in that order at all. + The other parsers of the locale may still read the date string, but no + other locale should guess a reading of it.""" + + +_PART_OF_DIRECTIVE = {"%d": "day", "%m": "month", "%y": "year", "%Y": "year"} + + +def _strict_date_order(settings: "Settings") -> str: + """Return the STRICT_DATE_ORDER value in effect, which is "none" unless the + caller set DATE_ORDER.""" + if "DATE_ORDER" in settings._mod_settings: + return settings.STRICT_DATE_ORDER + return "none" + + +def _check_strict_date_order( + parts: list[str], four_digit_year: bool, date_order: str, strict: str +) -> None: + """Raise _StrictDateOrderError if *parts*, the parts of the date that were + read from numbers, in the order they were read, are not where DATE_ORDER + puts them, as far as *strict*, the STRICT_DATE_ORDER value, requires. A + month name and a missing part are not in *parts*, so they are not checked: + "32 DEC" with DMY is still December 2032.""" + if strict == "none": + return + order = resolve_date_order(date_order, lst=True) + if strict == "year": + # Any number that is not a valid day or month is read as a two-digit + # year, so check that it is where DATE_ORDER puts the year: in + # "32 DEC 10" with DMY, 32 is an invalid day, not the year 2032. Of the + # parts read, those before the year must be exactly those that the order + # puts before it, whichever way they are misplaced: "10 DEC 32" with MYD + # reads the day before the year. A four-digit year cannot be anything + # else. + if four_digit_year or "year" not in parts: + return + before_year = order[: order.index("year")] + if set(parts[: parts.index("year")]) != set(before_year).intersection(parts): + raise _StrictDateOrderError(f"The year is not where {date_order} puts it") + return + # "all": the day and month must be where DATE_ORDER puts them too, so they + # are not swapped when they do not fit. + if four_digit_year: + # A four-digit year is read wherever it is, and a date that starts + # with one is read as year, month and day unless DATE_ORDER starts + # with the year. + if parts[:1] == ["year"] and not date_order.startswith("Y"): + order = ["month", "day"] + parts = [part for part in parts if part != "year"] + if parts != [part for part in order if part in parts]: + raise _StrictDateOrderError(f"The date parts are not in {date_order} order") + + def _parse_absolute( datestring: str, settings: "Settings", @@ -237,21 +294,36 @@ def parse( if dt is not None: return dt nsp = cls() - ambiguous_date: tuple[datetime, str, tuple[str, ...]] | None = None + found: tuple[tuple[datetime, str, tuple[str, ...]], str] | None = None + ambiguous: tuple[tuple[datetime, str, tuple[str, ...]], str] | None = None for token, _ in tokens.tokenize(): for fmt in nsp.date_formats[order]: with contextlib.suppress(Exception): dt = strptime(token, fmt), cls._get_period(fmt), _get_parts(fmt) if len(str(dt[0].year)) < 4: - ambiguous_date = dt + ambiguous = dt, fmt continue missing = _get_missing_parts(fmt) _check_strict_parsing(missing, settings) - return dt - if ambiguous_date: - return ambiguous_date - raise ValueError(f"Unable to parse date from: {datestring}") + found = dt, fmt + if found: + break + if found: + break + found = found or ambiguous + if found is None: + raise ValueError(f"Unable to parse date from: {datestring}") + dt, fmt = found + # The formats are only sorted by DATE_ORDER, so the one that matched + # may read the numbers in another order. + _check_strict_date_order( + [_PART_OF_DIRECTIVE[directive] for directive in re.findall("%[dmyY]", fmt)], + four_digit_year="%Y" in fmt, + date_order=date_order, + strict=_strict_date_order(settings), + ) + return dt def _get_missing_error(missing: Iterable[str]) -> str: @@ -299,6 +371,7 @@ def __init__( # noqa: PLR0912, PLR0915 self.settings = settings self._tz = tz self._date_order = date_order or settings.DATE_ORDER + self._strict = _strict_date_order(settings) self.tokens = [(t[0].strip(), t[1]) for t in list(tokens)] self.filtered_tokens = [ (t[0], t[1], i) for i, t in enumerate(self.tokens) if t[1] <= 1 @@ -444,6 +517,19 @@ def __init__( # noqa: PLR0912, PLR0915 self._token_day and self._is_range(self._token_day[0], unset_token[0]) ) ] + if unset_tokens and self._strict == "all": + # A four-digit year displaced a number that was read as the year, + # so that number was not where DATE_ORDER puts the year. + raise _StrictDateOrderError( + f"{unset_tokens[0][0]} is not where {self._date_order} puts it" + ) + _check_strict_date_order( + self.auto_order, + four_digit_year=self._token_year is not None + and len(self._token_year[0]) == 4, + date_order=self._date_order, + strict=self._strict, + ) if len(unset_tokens) > len(unknown): raise ValueError("Too many numbers in date string") params: dict[str, int] = {} @@ -489,6 +575,38 @@ def _has_month_name(cls, tokens: Iterable[tuple[str, int]]) -> bool: pass return False + def _month_number_becomes_day(self) -> None: + """Record in auto_order that the number read as the month is the day, + now that a month name was found, and that the other end of the range, + which was read as the day, is dropped. That end comes after the month + in "12-14 June" with MDY, but before it in "12-12 June" with DMY.""" + if self.day: + self.auto_order.remove("day") + self.auto_order[self.auto_order.index("month")] = "day" + + def _unparsed_number_error(self, token: str) -> ValueError: + """Return the error for a number that fits none of the parts of the date + that are left in the order.""" + if self._strict == "all" and self._is_date_part(token): + # The number is a date part, but not where DATE_ORDER puts it, so + # the date string cannot be read in that order: no other locale + # may read it either, e.g. as a relative date. + return _StrictDateOrderError( + f"{token} is not where {self._date_order} puts it" + ) + return ValueError(f"Unable to parse: {token}") + + def _is_date_part(self, token: str) -> bool: + """Return whether *token* can be read as a day, month or year.""" + for directives in self.num_directives.values(): + for directive in directives: + try: + self._get_date_obj(token, directive) + except ValueError: + continue + return True + return False + def _get_period(self) -> str: if self.settings.RETURN_TIME_AS_PERIOD and getattr(self, "time", None): return "time" @@ -737,6 +855,11 @@ def parse( except ValueError as error: if ( "DATE_ORDER" not in settings._mod_settings + # The swap would replace a reading that STRICT_DATE_ORDER + # rejected with a date that the default never gives, and + # "all" forbids the swap altogether. + or isinstance(error, _StrictDateOrderError) + or settings.STRICT_DATE_ORDER == "all" or str(error).startswith("Fields missing") or cls._has_month_name(tokens) ): @@ -823,7 +946,7 @@ def try_directives( return set_and_return(token, token_type, component, do) except ValueError: pass - raise ValueError(f"Unable to parse: {token}") + raise self._unparsed_number_error(token) order = list(self.ordered_num_directives) components_after_year = order[order.index("year") + 1 :] @@ -871,8 +994,7 @@ def parse_alpha( # requires the day to be free, or to be the end of # a range that starts at that number, e.g. 14 in # “12-14 June”. - index = self.auto_order.index("month") - self.auto_order[index] = "day" + self._month_number_becomes_day() self._token_day = self._token_month self._token_month = token, token_type return [ diff --git a/dateparser_data/settings.py b/dateparser_data/settings.py index 9b8a9cb18..bc2480295 100644 --- a/dateparser_data/settings.py +++ b/dateparser_data/settings.py @@ -11,6 +11,7 @@ # Date order "DATE_ORDER": "MDY", "PREFER_LOCALE_DATE_ORDER": True, + "STRICT_DATE_ORDER": "none", # Timezone related "TIMEZONE": "local", "TO_TIMEZONE": False, diff --git a/docs/settings.rst b/docs/settings.rst index cfdf265a2..166db0972 100644 --- a/docs/settings.rst +++ b/docs/settings.rst @@ -37,6 +37,22 @@ Date Order >>> parse('le 02-03-2016', settings={'DATE_ORDER': 'MDY', 'PREFER_LOCALE_DATE_ORDER': False}) datetime.datetime(2016, 2, 3, 0, 0) # MDY worked! +``STRICT_DATE_ORDER``: defaults to ``'none'``. ``DATE_ORDER`` is a preference: a number that does not fit where the order puts it is read as another part of the date. ``13`` is not a valid month, so it is read as the day where ``MDY`` puts the month, and any number that is not a valid day or month is a valid two-digit year, so ``32`` becomes the year 2032: + + >>> parse('13/12/10', settings={'DATE_ORDER': 'MDY'}) + datetime.datetime(2010, 12, 13, 0, 0) + >>> parse('32 DEC 10', settings={'DATE_ORDER': 'DMY'}) + datetime.datetime(2032, 12, 10, 0, 0) + +Set it to ``'year'`` to read a two-digit year only from the position ``DATE_ORDER`` gives the year, or to ``'all'`` to read the day, month and year only in the order ``DATE_ORDER`` gives. A date string that does not fit then gives ``None``: + + >>> parse('32 DEC 10', settings={'DATE_ORDER': 'DMY', 'STRICT_DATE_ORDER': 'year'}) + >>> parse('13/12/10', settings={'DATE_ORDER': 'MDY', 'STRICT_DATE_ORDER': 'year'}) + datetime.datetime(2010, 12, 13, 0, 0) + >>> parse('13/12/10', settings={'DATE_ORDER': 'MDY', 'STRICT_DATE_ORDER': 'all'}) + +``'year'`` and ``'all'`` raise a ``SettingValidationError`` unless ``DATE_ORDER`` is given too. Only the parts read from numbers are checked, and a four-digit year is read wherever it is, so ``'32 DEC'`` with ``DMY`` is still December 2032. Some dates that are read correctly without the setting are rejected, such as ``'95年12月10日'`` with ``MDY``: once translated, it is ``95-12-10``, with nothing left to mark the year. + Timezone Related Configurations +++++++++++++++++++++++++++++++ diff --git a/stubs/parameterized/__init__.pyi b/stubs/parameterized/__init__.pyi index cfd1164bc..ce6ca6eb3 100644 --- a/stubs/parameterized/__init__.pyi +++ b/stubs/parameterized/__init__.pyi @@ -4,6 +4,8 @@ from typing import Any, TypeVar _F = TypeVar("_F", bound=Callable[..., Any]) class param: + args: tuple[Any, ...] + kwargs: dict[str, Any] def __init__(self, *args: Any, **kwargs: Any) -> None: ... class parameterized: diff --git a/tests/test_date_parser.py b/tests/test_date_parser.py index 455cbab3b..496fffc82 100644 --- a/tests/test_date_parser.py +++ b/tests/test_date_parser.py @@ -249,6 +249,8 @@ def setUp(self) -> None: param("12.-14. Juni 2021", datetime(2021, 6, 12, 0, 0)), param("12.-14.06.2021", datetime(2021, 6, 12, 0, 0)), param("12-14 июня 2021", datetime(2021, 6, 12, 0, 0)), + param("12-12 июня 2021", datetime(2021, 6, 12, 0, 0)), + param("5-5 juin 2021", datetime(2021, 6, 5, 0, 0)), param("12 - 14 czerwca 2021", datetime(2021, 6, 12, 0, 0)), ] ) @@ -2299,6 +2301,254 @@ def test_word_with_several_meanings_with_date_formats(self) -> None: def test_word_with_too_many_meaning_combinations(self) -> None: self.assertIsNone(parse("mar mar mar mar mar", languages=["it"])) + @parameterized.expand( + [ + param("32 DEC 10", datetime(2032, 12, 10), order="DMY"), + param("32/12/10", datetime(2032, 10, 12), order="DMY"), + param("12/13/10", datetime(2013, 10, 12), order="DMY"), + param("20 09 29", datetime(2020, 9, 29), order="MYD"), + param("95年12月10日", datetime(1995, 12, 10), order="MDY"), + # A day and a month in each other's place are swapped. + param("13/12/10", datetime(2010, 12, 13), order="MDY"), + param("01/13/21", datetime(2021, 1, 13), order="DMY"), + ] + ) + def test_date_order_is_a_preference_by_default( + self, date_string: str, expected: datetime, order: str + ) -> None: + """Test that without STRICT_DATE_ORDER, a number that does not fit where + DATE_ORDER puts it is read as another part of the date (Issue #868).""" + settings = {"DATE_ORDER": order, "RELATIVE_BASE": datetime(2019, 6, 24)} + self.assertEqual(expected, parse(date_string, settings=settings)) + + @parameterized.expand( + [ + param(*case.args, strict=strict, **case.kwargs) + for strict in ("year", "all") + for case in [ + param(date_string="32 DEC 10", order="DMY"), + param(date_string="00 DEC 10", order="DMY"), + param(date_string="32/12/10", order="DMY"), + param(date_string="32 DEC 10 10:30", order="DMY"), + param(date_string="32 décembre 10", order="DMY"), + param(date_string="DEC 32 10", order="MDY"), + param(date_string="10/32/12", order="MDY"), + param(date_string="40 12", order="DYM"), + # A day or month that the order puts after the year must not be + # read before it either. + param(date_string="10 DEC 32", order="MYD"), + param(date_string="DEC 10 95", order="YMD"), + # The year is the last resort here (#519), but YMD wants it first. + param(date_string="4-99", order="YMD"), + # The same goes for an invalid month, and the day and month are + # not swapped instead: that reading would not be the one + # without the setting. + param(date_string="12/13/10", order="DMY"), + # Translation leaves no marker of the year: "95-12-10". + param(date_string="95年12月10日", order="MDY"), + # Other locales must not read it differently: "ru" translates + # "20 09 29" to "29 29" and would find 2029-06-29. + param(date_string="20 09 29", order="MYD"), + # Nor must the no-spaces parser, which would find 1900-01-01 + # 10:03 in the first, and read 00 as the year in the second. + param( + date_string="10:30 PM 32/12/10", + order="DMY", + settings={"PARSERS": ["absolute-time", "no-spaces-time"]}, + ), + param( + date_string="001210", + order="DMY", + settings={"PARSERS": ["absolute-time", "no-spaces-time"]}, + ), + ] + ] + ) + def test_strict_date_order_rejects_misplaced_year( + self, + date_string: str, + order: str, + strict: str, + settings: dict[str, Any] | None = None, + ) -> None: + """Test that with STRICT_DATE_ORDER, a number that is invalid where + DATE_ORDER puts it is not read as a two-digit year instead, whether only + the year or the whole order is enforced (Issue #868).""" + settings = { + "DATE_ORDER": order, + "STRICT_DATE_ORDER": strict, + "RELATIVE_BASE": datetime(2019, 6, 24), + **(settings or {}), + } + self.assertIsNone(parse(date_string, settings=settings)) + + @parameterized.expand( + [ + param(*case.args, strict=strict, **case.kwargs) + for strict in ("year", "all") + for case in [ + param("31 DEC 10", datetime(2010, 12, 31), order="DMY"), + param("10 DEC 32", datetime(2032, 12, 10), order="DMY"), + # A year after the month is where DMY expects it. + param("DEC 32", datetime(2032, 12, 24), order="DMY"), + # A missing part is not checked. + param("DEC 95", datetime(1995, 12, 24), order="MDY"), + param("12/95", datetime(1995, 12, 24), order="MDY"), + param("13/2020", datetime(2020, 6, 13), order="MDY"), + # A two-digit year is still the last resort (#519). + param("DEC 95", datetime(1995, 12, 24), order="YMD"), + param("5 Dec 99", datetime(1999, 12, 5), order="DYM"), + # A four-digit year cannot be anything else. + param("2010 DEC 10", datetime(2010, 12, 10), order="DMY"), + param("12/2017/10", datetime(2017, 10, 12), order="DMY"), + param("DEC 2017 06", datetime(2017, 12, 6), order="DMY"), + # A date that starts with a four-digit year is read as year, + # month and day (#1419). + param("2017-06-22", datetime(2017, 6, 22), order="DMY"), + param("2017 06 DEC", datetime(2017, 12, 6), order="DMY"), + # A lone number next to a four-digit year is the month (#1472). + param("05/2020", datetime(2020, 5, 24), order="YMD"), + # The end of a range is dropped. + param("12-14 June 2021", datetime(2021, 6, 12), order="MDY"), + param("June 12-14, 2021", datetime(2021, 6, 12), order="MDY"), + param("12-12 June 2021", datetime(2021, 6, 12), order="DMY"), + # YMD asks for the year first, and MYD between month and day. + param("32 DEC 10", datetime(2032, 12, 10), order="YMD"), + param("95 DEC 10", datetime(1995, 12, 10), order="YMD"), + param("95年12月10日", datetime(1995, 12, 10), order="YMD"), + param("DEC 32 10", datetime(2032, 12, 10), order="MYD"), + # A month name is not checked: "12月" is translated to + # "december". + param("95年12月", datetime(1995, 12, 24), order="DMY"), + param("12 13 December", datetime(2013, 12, 12), order="DMY"), + # A word that another language reads as a date part does not + # stop that language: "ago" is August in Spanish. + param("12 ago 2019", datetime(2019, 8, 12), order="DMY"), + # Nor does a word with several meanings stop its other + # meanings: "mar" is Tuesday or March in Spanish. + param( + "mar 13 mar 2010", + datetime(2010, 3, 13), + order="DMY", + languages=["es"], + ), + # Nor does a number that is no date part at all stop the + # no-spaces parser. + param( + "20101231", + datetime(2010, 12, 31), + order="YMD", + settings={"PARSERS": ["absolute-time", "no-spaces-time"]}, + ), + ] + ] + ) + def test_strict_date_order_keeps_valid_dates( + self, + date_string: str, + expected: datetime, + strict: str, + order: str, + languages: list[str] | None = None, + settings: dict[str, Any] | None = None, + ) -> None: + """Test that STRICT_DATE_ORDER does not change dates whose parts are + where DATE_ORDER puts them, or that have no ambiguous number (Issue + #868).""" + settings = { + "DATE_ORDER": order, + "STRICT_DATE_ORDER": strict, + "RELATIVE_BASE": datetime(2019, 6, 24), + **(settings or {}), + } + self.assertEqual( + expected, parse(date_string, languages=languages, settings=settings) + ) + + @parameterized.expand( + [ + param("13/12/10", datetime(2010, 12, 13), order="MDY"), + param("13/12", datetime(2019, 12, 13), order="MDY"), + # Through the retry with the day and month swapped (#1180). + param("01/13/21", datetime(2021, 1, 13), order="DMY"), + param("06/2017/22", datetime(2017, 6, 22), order="DMY"), + # DYM and MYD put the year between the day and the month, so the + # swap changes which of them is read before it. + param("05 95 13", datetime(1995, 5, 13), order="DYM"), + param("13 95 12", datetime(1995, 12, 13), order="MYD"), + param("2017-06-22", datetime(2017, 6, 22), order="YDM"), + # After a four-digit year, the month and day may be swapped too. + param("2017-22-06", datetime(2017, 6, 22), order="DMY"), + # A four-digit year may displace a number read as the year. + param("31 DEC 2010", datetime(2010, 12, 31), order="MYD"), + param("14 12 2021", datetime(2021, 12, 14), order="MYD"), + param("22 2017 06", datetime(2017, 6, 22), order="YDM"), + param("05 2017 12", datetime(2017, 5, 12), order="YDM"), + # A CJK date goes through the same swap retry. + param("10年20月00日", datetime(2000, 10, 20), order="DMY"), + ] + ) + def test_strict_date_order_year_keeps_day_month_swaps( + self, date_string: str, expected: datetime, order: str + ) -> None: + """Test that STRICT_DATE_ORDER="year" enforces the position of the year + only, so a day and a month in each other's place are still swapped + (Issue #868).""" + settings = { + "DATE_ORDER": order, + "STRICT_DATE_ORDER": "year", + "RELATIVE_BASE": datetime(2019, 6, 24), + } + self.assertEqual(expected, parse(date_string, settings=settings)) + + @parameterized.expand( + [ + param(date_string="13/12/10", order="MDY"), + param(date_string="13/12", order="MDY"), + param(date_string="01/13/21", order="DMY"), + param(date_string="06/2017/22", order="DMY"), + param(date_string="05 95 13", order="DYM"), + param(date_string="13 95 12", order="MYD"), + param(date_string="2017-06-22", order="YDM"), + param(date_string="2017-22-06", order="DMY"), + param(date_string="31 DEC 2010", order="MYD"), + param(date_string="14 12 2021", order="MYD"), + param(date_string="22 2017 06", order="YDM"), + param(date_string="05 2017 12", order="YDM"), + # Other locales must not read it either: "zh" would read it as a + # relative date, 10 years and 20 months ago. + param(date_string="10年20月00日", order="DMY"), + ] + ) + def test_strict_date_order_all_rejects_day_month_swaps( + self, date_string: str, order: str + ) -> None: + """Test that STRICT_DATE_ORDER="all" also keeps the day and month where + DATE_ORDER puts them, instead of swapping them when they do not fit + (Issue #868).""" + settings = { + "DATE_ORDER": order, + "STRICT_DATE_ORDER": "all", + "RELATIVE_BASE": datetime(2019, 6, 24), + } + self.assertIsNone(parse(date_string, settings=settings)) + + @parameterized.expand([param(strict="year"), param(strict="all")]) + def test_strict_date_order_does_not_stop_other_parsers(self, strict: str) -> None: + """Test that a reading rejected by STRICT_DATE_ORDER does not keep the + other parsers of the locale from reading the date string (Issue #868).""" + settings = { + "DATE_ORDER": "DMY", + "STRICT_DATE_ORDER": strict, + "PARSERS": ["absolute-time", "relative-time"], + "RELATIVE_BASE": datetime(2019, 6, 24), + } + # The absolute parser would read it as 2032-06-10. + self.assertEqual( + datetime(2019, 6, 22, 15, 50), + parse("32 hours 10 minutes", settings=settings), + ) + if __name__ == "__main__": unittest.main() diff --git a/tests/test_settings.py b/tests/test_settings.py index af82f4ef7..8828f133a 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -6,6 +6,7 @@ from dateparser import DateDataParser, parse from dateparser.conf import Settings, SettingValidationError, apply_settings, settings +from dateparser.search import search_dates from tests import BaseTestCase @@ -210,6 +211,7 @@ def test_check_settings_wrong_setting_name(self) -> None: param("STRICT_PARSING", "true", "", True), param("RETURN_TIME_AS_PERIOD", "false", "", True), param("PREFER_LOCALE_DATE_ORDER", "true", "", False), + param("STRICT_DATE_ORDER", True, "full", "none"), param("NORMALIZE", "true", "", True), param("FUZZY", "true", "", False), param("PREFER_LOCALE_DATE_ORDER", "false", "", True), @@ -283,6 +285,71 @@ def test_check_settings_extra_check_default_languages(self) -> None: DateDataParser(settings={"DEFAULT_LANGUAGES": ["abcd"]}) +class StrictDateOrderSettingsTest(BaseTestCase): + """STRICT_DATE_ORDER enforces the DATE_ORDER that the caller sets, so it + needs one.""" + + @parameterized.expand([param("year"), param("all")]) + def test_strict_date_order_requires_date_order(self, strict: str) -> None: + with self.assertRaisesRegex( + SettingValidationError, + rf'"STRICT_DATE_ORDER": "{strict}" requires the "DATE_ORDER" setting', + ): + DateDataParser(settings={"STRICT_DATE_ORDER": strict}) + + # parse() builds the parser too, whatever the date string. + with self.assertRaises(SettingValidationError): + parse("12/10/95", settings={"STRICT_DATE_ORDER": strict}) + + # The default DATE_ORDER is a preference, but one that the caller sets + # is enforced, even if it is the default one. + assert DateDataParser( + settings={"STRICT_DATE_ORDER": strict, "DATE_ORDER": "MDY"} + ) + + def test_strict_date_order_none_does_not_require_date_order(self) -> None: + assert DateDataParser(settings={"STRICT_DATE_ORDER": "none"}) + self.assertEqual( + datetime(1995, 12, 10), + parse("12/10/95", settings={"STRICT_DATE_ORDER": "none"}), + ) + + @parameterized.expand([param("year"), param("all")]) + def test_strict_date_order_stays_in_force_when_a_parser_is_reused( + self, strict: str + ) -> None: + parser = DateDataParser( + settings={"DATE_ORDER": "DMY", "STRICT_DATE_ORDER": strict} + ) + for _ in range(2): + self.assertIsNone(parser.get_date_data("32 DEC 10")["date_obj"]) + self.assertEqual( + datetime(2010, 12, 31), parser.get_date_data("31 DEC 10")["date_obj"] + ) + + @parameterized.expand([param("year"), param("all")]) + def test_search_dates_does_not_check_the_rebuilt_settings( + self, strict: str + ) -> None: + """Test that search_dates does not raise SettingValidationError for the + settings that it rebuilds for the dates after the first one, which + forget which settings the caller set.""" + text = "Opened 25/12/2020, closed 31/12/2020." + self.assertEqual( + [ + ("25/12/2020", datetime(2020, 12, 25)), + ("31/12/2020", datetime(2020, 12, 31)), + ], + search_dates( + text, + languages=["en"], + settings={"DATE_ORDER": "DMY", "STRICT_DATE_ORDER": strict}, + ), + ) + with self.assertRaises(SettingValidationError): + search_dates(text, languages=["en"], settings={"STRICT_DATE_ORDER": strict}) + + @pytest.mark.parametrize( ("date_string", "expected_result"), [ From fed9cf94e9d8a1128b396f01ca66f4a303f03ee4 Mon Sep 17 00:00:00 2001 From: Serhii A Date: Mon, 5 Oct 2026 11:40:59 +0200 Subject: [PATCH 104/107] Apply an explicit DATE_ORDER to every date that search_dates finds (#1535) --- dateparser/conf.py | 5 + tests/test_search.py | 322 +++++++++++++++++++++++++++++++++++++++++ tests/test_settings.py | 26 +++- 3 files changed, 352 insertions(+), 1 deletion(-) diff --git a/dateparser/conf.py b/dateparser/conf.py index 29180f2fe..4c0a04889 100644 --- a/dateparser/conf.py +++ b/dateparser/conf.py @@ -117,6 +117,11 @@ def replace( kwds.setdefault(x, getattr(self, x)) kwds["_default"] = False + # Keep track of the settings that the caller set, or replacing another + # one, like RELATIVE_BASE, makes an explicit DATE_ORDER give way to the + # order of the locale. + if mod_settings is None: + mod_settings = self._mod_settings if mod_settings: kwds["_mod_settings"] = mod_settings diff --git a/tests/test_search.py b/tests/test_search.py index e4296e903..a422e6847 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -1616,6 +1616,328 @@ def test_search_dates_time_span_disabled_by_default(self) -> None: ) self.assertIsNone(result) + def test_search_dates_keeps_an_explicit_date_order_after_the_first_date( + self, + ) -> None: + result = search_dates( + "op 30-05-2027. Deze op 01-11-2026", + languages=["nl"], + settings={"DATE_ORDER": "DMY", "STRICT_PARSING": True}, + ) + self.assertEqual( + result, + [ + ("30-05-2027", datetime.datetime(2027, 5, 30, 0, 0)), + ("01-11-2026", datetime.datetime(2026, 11, 1, 0, 0)), + ], + ) + + @parameterized.expand( + [ + # Every language but vi and hu is searched in its English + # translation, so the dates after the first one were read as MDY + param( + "nl", + "Besteld op 25-12-2020, verzonden op 02-01-2021 en geleverd op 05-01-2021.", + "DMY", + [ + ("25-12-2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02-01-2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05-01-2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "de", + "Bestellt 25.12.2020, versandt 02.01.2021, geliefert 05.01.2021.", + "DMY", + [ + ("25.12.2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02.01.2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05.01.2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "fr", + "Commandé 25/12/2020, expédié 02/01/2021, livré 05/01/2021.", + "DMY", + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05/01/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "ru", + "Заказ 25.12.2020, отправка 02.01.2021, доставка 05.01.2021.", + "DMY", + [ + ("25.12.2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02.01.2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05.01.2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "en", + "Ordered 25/12/2020, shipped 02/01/2021, delivered 05/01/2021.", + "DMY", + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05/01/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + # vi and hu are searched in their own locale, whose order is DMY + # and YMD respectively + param( + "vi", + "Đặt hàng 12/25/2020, giao hàng 01/02/2021, nhận hàng 01/05/2021.", + "MDY", + [ + ("12/25/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("01/02/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("01/05/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "hu", + "Rendelés 12/25/2020, szállítás 01/02/2021, kézbesítés 01/05/2021.", + "MDY", + [ + ("12/25/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("01/02/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("01/05/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "en", + "Ordered 12/25/2020, shipped 01/02/2021, delivered 01/05/2021.", + "MDY", + [ + ("12/25/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("01/02/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("01/05/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + # With a four-digit year first, any order reads the year first, so + # only a two-digit year tells YMD apart + param( + "en", + "Ordered 20-12-25, shipped 21-01-02, delivered 21-01-05.", + "YMD", + [ + ("20-12-25", datetime.datetime(2020, 12, 25, 0, 0)), + ("21-01-02", datetime.datetime(2021, 1, 2, 0, 0)), + ("21-01-05", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "es", + "Pedido 20/12/25, enviado 21/01/02, entregado 21/01/05.", + "YMD", + [ + ("20/12/25", datetime.datetime(2020, 12, 25, 0, 0)), + ("21/01/02", datetime.datetime(2021, 1, 2, 0, 0)), + ("21/01/05", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "vi", + "Đặt hàng 20/12/25, giao hàng 21/01/02, nhận hàng 21/01/05.", + "YMD", + [ + ("20/12/25", datetime.datetime(2020, 12, 25, 0, 0)), + ("21/01/02", datetime.datetime(2021, 1, 2, 0, 0)), + ("21/01/05", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + ] + ) + def test_search_dates_reads_every_date_in_an_explicit_date_order( + self, + language: str, + text: str, + date_order: str, + expected: list[tuple[str, datetime.datetime]], + ) -> None: + for strict_parsing in (False, True): + with self.subTest(strict_parsing=strict_parsing): + result = search_dates( + text, + languages=[language], + settings={ + "DATE_ORDER": date_order, + "STRICT_PARSING": strict_parsing, + }, + ) + self.assertEqual(result, expected) + + @parameterized.expand( + [ + param( + "en", + "Ordered 12/25/2020, shipped 01/02/2021, delivered 01/05/2021.", + [ + ("12/25/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("01/02/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("01/05/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "vi", + "Đặt hàng 25/12/2020, giao hàng 02/01/2021, nhận hàng 05/01/2021.", + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("05/01/2021", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + param( + "hu", + "Rendelés 20.12.25, szállítás 21.01.02, kézbesítés 21.01.05.", + [ + ("20.12.25", datetime.datetime(2020, 12, 25, 0, 0)), + ("21.01.02", datetime.datetime(2021, 1, 2, 0, 0)), + ("21.01.05", datetime.datetime(2021, 1, 5, 0, 0)), + ], + ), + ] + ) + def test_search_dates_reads_every_date_in_the_locale_date_order_by_default( + self, + language: str, + text: str, + expected: list[tuple[str, datetime.datetime]], + ) -> None: + # Setting something else must not make the default DATE_ORDER count as + # one set by the caller for the dates after the first one. + for settings in ( + None, + {"STRICT_PARSING": True}, + {"PREFER_DAY_OF_MONTH": "first"}, + ): + with self.subTest(settings=settings): + result = search_dates(text, languages=[language], settings=settings) + self.assertEqual(result, expected) + + @parameterized.expand( + [ + # The second date has no year, so it is the year of the first date + # or the next one, as PREFER_DATES_FROM prefers + param( + "en", + "Ordered 25/12/2020, delivered 02/01.", + {"PREFER_DATES_FROM": "future"}, + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01", datetime.datetime(2021, 1, 2, 0, 0)), + ], + ), + param( + "en", + "Ordered 25/12/2020, delivered 02/01.", + {"PREFER_DATES_FROM": "past"}, + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01", datetime.datetime(2020, 1, 2, 0, 0)), + ], + ), + # A relative date counts from the date found before it + param( + "en", + "Ordered 25/12/2020. Paid 02/01/2021. Shipped in 3 days. " + "Delivered 10/01/2021.", + {}, + [ + ("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02/01/2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("in 3 days", datetime.datetime(2021, 1, 5, 0, 0)), + ("10/01/2021", datetime.datetime(2021, 1, 10, 0, 0)), + ], + ), + param( + "ru", + "Заказ 25.12.2020. Оплата 02.01.2021. Через 3 дня отправка. " + "Доставка 10.01.2021.", + {}, + [ + ("25.12.2020", datetime.datetime(2020, 12, 25, 0, 0)), + ("02.01.2021", datetime.datetime(2021, 1, 2, 0, 0)), + ("Через 3 дня", datetime.datetime(2021, 1, 5, 0, 0)), + ("10.01.2021", datetime.datetime(2021, 1, 10, 0, 0)), + ], + ), + param( + "nl", + "op 30-05-2027 om 10:00. Deze op 01-11-2026 om 09:30", + {"TIMEZONE": "Europe/Amsterdam", "TO_TIMEZONE": "UTC"}, + [ + ("30-05-2027 om 10:00", datetime.datetime(2027, 5, 30, 8, 0)), + ("01-11-2026 om 09:30", datetime.datetime(2026, 11, 1, 8, 30)), + ], + ), + param( + "nl", + "op 30-05-2027 om 10:00. Deze op 01-11-2026 om 09:30", + {"TIMEZONE": "Europe/Amsterdam", "RETURN_AS_TIMEZONE_AWARE": True}, + [ + ( + "30-05-2027 om 10:00", + datetime.datetime( + 2027, + 5, + 30, + 10, + 0, + tzinfo=datetime.timezone(timedelta(hours=2)), + ), + ), + ( + "01-11-2026 om 09:30", + datetime.datetime( + 2026, + 11, + 1, + 9, + 30, + tzinfo=datetime.timezone(timedelta(hours=1)), + ), + ), + ], + ), + ] + ) + def test_search_dates_keeps_the_other_settings_after_the_first_date( + self, + language: str, + text: str, + settings: dict[str, Any], + expected: list[tuple[str, datetime.datetime]], + ) -> None: + result = search_dates( + text, languages=[language], settings={"DATE_ORDER": "DMY", **settings} + ) + self.assertEqual(result, expected) + + @parameterized.expand( + [ + # 25 cannot be the month, and "all" does not swap it with the day + param("all", "Opened 25/12/2020, closed 12/25/2021."), + # 32 cannot be the day, so it is the year, which DMY puts last + param("year", "Opened 25/12/2020, closed 32/12/10."), + ] + ) + def test_search_dates_keeps_strict_date_order_after_the_first_date( + self, strict: str, text: str + ) -> None: + result = search_dates( + text, + languages=["en"], + settings={"DATE_ORDER": "DMY", "STRICT_DATE_ORDER": strict}, + ) + self.assertEqual( + result, [("25/12/2020", datetime.datetime(2020, 12, 25, 0, 0))] + ) + class TestNgramSearch(BaseTestCase): def setUp(self) -> None: diff --git a/tests/test_settings.py b/tests/test_settings.py index 8828f133a..0109483fc 100644 --- a/tests/test_settings.py +++ b/tests/test_settings.py @@ -159,6 +159,30 @@ def test_apply_settings_should_return_default_settings_when_called_with_no_setti self.assertNotEqual(settings_once, self.default_settings) self.assertEqual(settings_twice, self.default_settings) + def test_replace_keeps_the_settings_that_the_caller_set(self) -> None: + test_func = apply_settings(test_function) + caller_settings = test_func(settings={"DATE_ORDER": "DMY"}) + assert isinstance(caller_settings, Settings) + replaced = caller_settings.replace(RELATIVE_BASE=datetime(2020, 12, 25)) + # A DATE_ORDER that the caller set wins over the MDY order of the locale. + parser = DateDataParser(languages=["en"], settings=replaced) + self.assertEqual( + datetime(2021, 1, 2), parser.get_date_data("02/01/2021")["date_obj"] + ) + + def test_replace_does_not_count_the_settings_it_copies_as_set_by_the_caller( + self, + ) -> None: + test_func = apply_settings(test_function) + caller_settings = test_func(settings={"PREFER_DATES_FROM": "past"}) + assert isinstance(caller_settings, Settings) + replaced = caller_settings.replace(RELATIVE_BASE=datetime(2020, 12, 25)) + # The default DATE_ORDER, MDY, gives way to the DMY order of the locale. + parser = DateDataParser(languages=["de"], settings=replaced) + self.assertEqual( + datetime(2021, 1, 2), parser.get_date_data("02.01.2021")["date_obj"] + ) + class InvalidSettingsTest(BaseTestCase): def setUp(self) -> None: @@ -333,7 +357,7 @@ def test_search_dates_does_not_check_the_rebuilt_settings( ) -> None: """Test that search_dates does not raise SettingValidationError for the settings that it rebuilds for the dates after the first one, which - forget which settings the caller set.""" + remember which settings the caller set.""" text = "Opened 25/12/2020, closed 31/12/2020." self.assertEqual( [ From 710600b5d7bc902e51603f97e246b8ab9e51f4bd Mon Sep 17 00:00:00 2001 From: "jose.maud" Date: Tue, 6 Oct 2026 18:04:51 -0300 Subject: [PATCH 105/107] =?UTF-8?q?Parse=20Czech=20relative=20dates=20with?= =?UTF-8?q?out=20the=20numeral=201,=20like=20"p=C5=99ed=20t=C3=BDden"=20(#?= =?UTF-8?q?351)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 --- dateparser/data/date_translation_data/cs.py | 11 ++++++++++- .../date_translation_data/cs.yaml | 6 +++++- tests/test_freshness_date_parser.py | 5 +++++ 3 files changed, 20 insertions(+), 2 deletions(-) diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index 8c5cd1f88..3a91d666d 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -525,7 +525,16 @@ "(?<=(za|před)\\s)rok(em)\\b": "1 rok" }, { - "(?<=(za|před)\\s)den(em)\\b": "1 den" + "(?<=(za|před)\\s)(?:denem|dnem|den)\\b": "1 den" + }, + { + "(?<=před\\s)týden\\b": "1 týden" + }, + { + "(?<=před\\s)měsíc\\b": "1 měsíc" + }, + { + "(?<=před\\s)rok\\b": "1 rok" }, { "(?<=za\\s)týden\\b": "1 týden" diff --git a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml index 7697d5567..1fe0cb4cd 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml @@ -193,7 +193,11 @@ simplifications: - '(?<=(za|před)\s)týdn(em)\b': '1 týden' - '(?<=(za|před)\s)měsíc(em)\b': '1 měsíc' - '(?<=(za|před)\s)rok(em)\b': '1 rok' - - '(?<=(za|před)\s)den(em)\b': '1 den' + - '(?<=(za|před)\s)(?:denem|dnem|den)\b': '1 den' + # The numeral "1" is optional: "před týden" means "před 1 týden" + - '(?<=před\s)týden\b': '1 týden' + - '(?<=před\s)měsíc\b': '1 měsíc' + - '(?<=před\s)rok\b': '1 rok' # Accusative forms used with "za" (e.g. "za týden" = "in a week") - '(?<=za\s)týden\b': '1 týden' - '(?<=za\s)měsíc\b': '1 měsíc' diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index c6a596ac4..de85bbe3d 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -712,6 +712,11 @@ def test_relative_past_dates_with_time_as_period( ago={"minutes": 2, "seconds": 45}, period="day", ), + param("před týden", ago={"weeks": 1}, period="week"), + param("před měsíc", ago={"months": 1}, period="month"), + param("před rok", ago={"years": 1}, period="year"), + param("před den", ago={"days": 1}, period="day"), + param("před dnem", ago={"days": 1}, period="day"), # cy param("5 wythnos yn ôl", ago={"weeks": 5}, period="week"), param( From a62139f46f777989b5a8d959dee03ba333b201ab Mon Sep 17 00:00:00 2001 From: "jose.maud" Date: Tue, 6 Oct 2026 18:11:08 -0300 Subject: [PATCH 106/107] =?UTF-8?q?Parse=20Czech=20accusative=20minute=20a?= =?UTF-8?q?nd=20second=20forms,=20like=20"p=C5=99ed=20minutu"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 --- dateparser/data/date_translation_data/cs.py | 6 ++++++ .../date_translation_data/cs.yaml | 6 ++++++ tests/test_freshness_date_parser.py | 3 +++ 3 files changed, 15 insertions(+) diff --git a/dateparser/data/date_translation_data/cs.py b/dateparser/data/date_translation_data/cs.py index 3a91d666d..2fa63b701 100644 --- a/dateparser/data/date_translation_data/cs.py +++ b/dateparser/data/date_translation_data/cs.py @@ -168,6 +168,8 @@ "min", "minuta", "minut", + "minutu", + "minutou", "minutami", "minuty", "minutama" @@ -177,8 +179,12 @@ "sekunda", "sekundy", "sekund", + "sekundu", + "sekundou", "sekundami", "vteřina", + "vteřinu", + "vteřinou", "vteřin", "vteřiny", "vteřinami" diff --git a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml index 1fe0cb4cd..645607161 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/cs.yaml @@ -79,14 +79,20 @@ hour: - hodinama minute: - minut + - minutu + - minutou - minutami - minuty - minutama second: - sekundy - sekund + - sekundu + - sekundou - sekundami - vteřina + - vteřinu + - vteřinou - vteřin - vteřiny - vteřinami diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index de85bbe3d..e85812dea 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -717,6 +717,9 @@ def test_relative_past_dates_with_time_as_period( param("před rok", ago={"years": 1}, period="year"), param("před den", ago={"days": 1}, period="day"), param("před dnem", ago={"days": 1}, period="day"), + param("před hodinu", ago={"hours": 1}, period="day"), + param("před minutu", ago={"minutes": 1}, period="day"), + param("před sekundu", ago={"seconds": 1}, period="day"), # cy param("5 wythnos yn ôl", ago={"weeks": 5}, period="week"), param( From 4a794c913bbc7ecc256422802ea8420b1ca00ba8 Mon Sep 17 00:00:00 2001 From: "jose.maud" Date: Tue, 6 Oct 2026 18:30:02 -0300 Subject: [PATCH 107/107] Parse relative dates without the numeral 1 in more languages (#351) Add simplifications so a bare unit after the "ago" word or before the "ago" suffix means "1 unit": Arabic, Belarusian, Bulgarian, Croatian, Finnish, Hebrew, Latvian, Lithuanian, Macedonian, Polish, Slovenian and Ukrainian. Co-Authored-By: Claude Sonnet 5.5 --- dateparser/data/date_translation_data/ar.py | 23 +++++++++++++++++ dateparser/data/date_translation_data/be.py | 12 +++++++++ dateparser/data/date_translation_data/bg.py | 3 +++ dateparser/data/date_translation_data/fi.py | 15 +++++++++++ dateparser/data/date_translation_data/he.py | 18 +++++++++++++ dateparser/data/date_translation_data/hr.py | 21 ++++++++++++++++ dateparser/data/date_translation_data/lt.py | 23 +++++++++++++++++ dateparser/data/date_translation_data/lv.py | 23 +++++++++++++++++ dateparser/data/date_translation_data/mk.py | 20 +++++++++++++++ dateparser/data/date_translation_data/pl.py | 21 ++++++++++++++++ dateparser/data/date_translation_data/sl.py | 23 +++++++++++++++++ dateparser/data/date_translation_data/uk.py | 12 +++++++++ .../date_translation_data/ar.yaml | 10 ++++++++ .../date_translation_data/be.yaml | 6 +++++ .../date_translation_data/bg.yaml | 3 +++ .../date_translation_data/fi.yaml | 7 ++++++ .../date_translation_data/he.yaml | 8 ++++++ .../date_translation_data/hr.yaml | 9 +++++++ .../date_translation_data/lt.yaml | 9 +++++++ .../date_translation_data/lv.yaml | 9 +++++++ .../date_translation_data/mk.yaml | 9 +++++++ .../date_translation_data/pl.yaml | 9 +++++++ .../date_translation_data/sl.yaml | 9 +++++++ .../date_translation_data/uk.yaml | 6 +++++ tests/test_freshness_date_parser.py | 25 +++++++++++++++++++ 25 files changed, 333 insertions(+) create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/lt.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/lv.yaml create mode 100644 dateparser_data/supplementary_language_data/date_translation_data/sl.yaml diff --git a/dateparser/data/date_translation_data/ar.py b/dateparser/data/date_translation_data/ar.py index d2213813d..640a965e7 100644 --- a/dateparser/data/date_translation_data/ar.py +++ b/dateparser/data/date_translation_data/ar.py @@ -578,5 +578,28 @@ ], "in": [ "خلال" + ], + "simplifications": [ + { + "(?<=(قبل|منذ)\\s+)أسبوع\\b": "1 أسبوع" + }, + { + "(?<=(قبل|منذ)\\s+)شهر\\b": "1 شهر" + }, + { + "(?<=(قبل|منذ)\\s+)سنة\\b": "1 سنة" + }, + { + "(?<=(قبل|منذ)\\s+)يوم\\b": "1 يوم" + }, + { + "(?<=(قبل|منذ)\\s+)ساعة\\b": "1 ساعة" + }, + { + "(?<=(قبل|منذ)\\s+)دقيقة\\b": "1 دقيقة" + }, + { + "(?<=(قبل|منذ)\\s+)ثانية\\b": "1 ثانية" + } ] } diff --git a/dateparser/data/date_translation_data/be.py b/dateparser/data/date_translation_data/be.py index 2706fccd6..54a135698 100644 --- a/dateparser/data/date_translation_data/be.py +++ b/dateparser/data/date_translation_data/be.py @@ -344,6 +344,18 @@ }, { "(\\d++[.,]?\\d*+)\\s*гадзін\\s(\\d++[.,]?\\d*+)\\s*хвілін": "\\1:\\2" + }, + { + "(?<=[^\\d]\\s+|^)тыдзень(?=\\s+таму)": "1 тыдзень" + }, + { + "(?<=[^\\d]\\s+|^)месяц(?=\\s+таму)": "1 месяц" + }, + { + "(?<=[^\\d]\\s+|^)год(?=\\s+таму)": "1 год" + }, + { + "(?<=[^\\d]\\s+|^)дзень(?=\\s+таму)": "1 дзень" } ] } diff --git a/dateparser/data/date_translation_data/bg.py b/dateparser/data/date_translation_data/bg.py index 5fad8d1a0..a03a92fe7 100644 --- a/dateparser/data/date_translation_data/bg.py +++ b/dateparser/data/date_translation_data/bg.py @@ -343,6 +343,9 @@ }, { "три": "3" + }, + { + "(?<=преди\\s+)месец\\b": "1 месец" } ] } diff --git a/dateparser/data/date_translation_data/fi.py b/dateparser/data/date_translation_data/fi.py index b068e2267..0ad5f611b 100644 --- a/dateparser/data/date_translation_data/fi.py +++ b/dateparser/data/date_translation_data/fi.py @@ -342,6 +342,21 @@ "simplifications": [ { "(\\d++[.,]?\\d*+) (sekunnin|sekuntin|minuutin|tunnin|päivän|viikon|kuukauden|vuoden) (päästä|kuluttua)": "\\3 \\1 \\2" + }, + { + "(?<=[^\\d]\\s+|^)viikko(?=\\s+sitten)": "1 viikko" + }, + { + "(?<=[^\\d]\\s+|^)kuukausi(?=\\s+sitten)": "1 kuukausi" + }, + { + "(?<=[^\\d]\\s+|^)vuosi(?=\\s+sitten)": "1 vuosi" + }, + { + "(?<=[^\\d]\\s+|^)päivä(?=\\s+sitten)": "1 päivä" + }, + { + "(?<=[^\\d]\\s+|^)tunti(?=\\s+sitten)": "1 tunti" } ] } diff --git a/dateparser/data/date_translation_data/he.py b/dateparser/data/date_translation_data/he.py index 0168175d8..ff4d188a2 100644 --- a/dateparser/data/date_translation_data/he.py +++ b/dateparser/data/date_translation_data/he.py @@ -370,6 +370,24 @@ }, { "בערב": "pm" + }, + { + "(?<=לפני\\s+)שבוע\\b": "1 שבוע" + }, + { + "(?<=לפני\\s+)חודש\\b": "1 חודש" + }, + { + "(?<=לפני\\s+)שנה\\b": "1 שנה" + }, + { + "(?<=לפני\\s+)יום\\b": "1 יום" + }, + { + "(?<=לפני\\s+)שעה\\b": "1 שעה" + }, + { + "(?<=לפני\\s+)דקה\\b": "1 דקה" } ] } diff --git a/dateparser/data/date_translation_data/hr.py b/dateparser/data/date_translation_data/hr.py index 75304991c..b94d909fa 100644 --- a/dateparser/data/date_translation_data/hr.py +++ b/dateparser/data/date_translation_data/hr.py @@ -360,6 +360,27 @@ }, { "ponoć": "00:00" + }, + { + "(?<=prije\\s+)tjedan(\\s+dana)?": "1 tjedan" + }, + { + "(?<=prije\\s+)mjesec(\\s+dana)?": "1 mjesec" + }, + { + "(?<=prije\\s+)godinu(\\s+dana)?": "1 godinu" + }, + { + "(?<=prije\\s+)sat(\\s+vremena)?": "1 sat" + }, + { + "(?<=prije\\s+)dan\\b": "1 dan" + }, + { + "(?<=prije\\s+)minutu": "1 minutu" + }, + { + "(?<=prije\\s+)sekundu": "1 sekundu" } ], "skip": [ diff --git a/dateparser/data/date_translation_data/lt.py b/dateparser/data/date_translation_data/lt.py index ad3ef1b21..e5a959b76 100644 --- a/dateparser/data/date_translation_data/lt.py +++ b/dateparser/data/date_translation_data/lt.py @@ -247,6 +247,29 @@ ] }, "locale_specific": {}, + "simplifications": [ + { + "(?<=prieš\\s+)savaitę\\b": "1 savaitę" + }, + { + "(?<=prieš\\s+)mėnesį\\b": "1 mėnesį" + }, + { + "(?<=prieš\\s+)metus\\b": "1 metus" + }, + { + "(?<=prieš\\s+)dieną\\b": "1 dieną" + }, + { + "(?<=prieš\\s+)valandą\\b": "1 valandą" + }, + { + "(?<=prieš\\s+)minutę\\b": "1 minutę" + }, + { + "(?<=prieš\\s+)sekundę\\b": "1 sekundę" + } + ], "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/lv.py b/dateparser/data/date_translation_data/lv.py index ca0a20436..ed1a47fe5 100644 --- a/dateparser/data/date_translation_data/lv.py +++ b/dateparser/data/date_translation_data/lv.py @@ -249,6 +249,29 @@ ] }, "locale_specific": {}, + "simplifications": [ + { + "(?<=pirms\\s+)nedēļas\\b": "1 nedēļas" + }, + { + "(?<=pirms\\s+)mēneša\\b": "1 mēneša" + }, + { + "(?<=pirms\\s+)gada\\b": "1 gada" + }, + { + "(?<=pirms\\s+)dienas\\b": "1 dienas" + }, + { + "(?<=pirms\\s+)stundas\\b": "1 stundas" + }, + { + "(?<=pirms\\s+)minūtes\\b": "1 minūtes" + }, + { + "(?<=pirms\\s+)sekundes\\b": "1 sekundes" + } + ], "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/mk.py b/dateparser/data/date_translation_data/mk.py index 9ed46c548..744d997fe 100644 --- a/dateparser/data/date_translation_data/mk.py +++ b/dateparser/data/date_translation_data/mk.py @@ -232,6 +232,26 @@ ] }, "locale_specific": {}, + "simplifications": [ + { + "(?<=пред\\s+)седмица\\b": "1 седмица" + }, + { + "(?<=пред\\s+)месец\\b": "1 месец" + }, + { + "(?<=пред\\s+)година\\b": "1 година" + }, + { + "(?<=пред\\s+)ден\\b": "1 ден" + }, + { + "(?<=пред\\s+)час\\b": "1 час" + }, + { + "(?<=пред\\s+)минута\\b": "1 минута" + } + ], "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/pl.py b/dateparser/data/date_translation_data/pl.py index 4ce6bcb5d..614c5e784 100644 --- a/dateparser/data/date_translation_data/pl.py +++ b/dateparser/data/date_translation_data/pl.py @@ -422,6 +422,27 @@ }, { "pojutrze": "za 2 dnia" + }, + { + "(?<=[^\\d]\\s+|^)tydzień(?=\\s+temu)": "1 tydzień" + }, + { + "(?<=[^\\d]\\s+|^)miesiąc(?=\\s+temu)": "1 miesiąc" + }, + { + "(?<=[^\\d]\\s+|^)rok(?=\\s+temu)": "1 rok" + }, + { + "(?<=[^\\d]\\s+|^)dzień(?=\\s+temu)": "1 dzień" + }, + { + "(?<=[^\\d]\\s+|^)godzinę(?=\\s+temu)": "1 godzinę" + }, + { + "(?<=[^\\d]\\s+|^)minutę(?=\\s+temu)": "1 minutę" + }, + { + "(?<=[^\\d]\\s+|^)sekundę(?=\\s+temu)": "1 sekundę" } ] } diff --git a/dateparser/data/date_translation_data/sl.py b/dateparser/data/date_translation_data/sl.py index 6320af78f..6100baaae 100644 --- a/dateparser/data/date_translation_data/sl.py +++ b/dateparser/data/date_translation_data/sl.py @@ -238,6 +238,29 @@ ] }, "locale_specific": {}, + "simplifications": [ + { + "(?<=pred\\s+)tednom\\b": "1 tednom" + }, + { + "(?<=pred\\s+)mesecem\\b": "1 mesecem" + }, + { + "(?<=pred\\s+)letom\\b": "1 letom" + }, + { + "(?<=pred\\s+)dnevom\\b": "1 dnevom" + }, + { + "(?<=pred\\s+)uro\\b": "1 uro" + }, + { + "(?<=pred\\s+)minuto\\b": "1 minuto" + }, + { + "(?<=pred\\s+)sekundo\\b": "1 sekundo" + } + ], "skip": [ " ", "'", diff --git a/dateparser/data/date_translation_data/uk.py b/dateparser/data/date_translation_data/uk.py index 4958ccbaa..b29a94332 100644 --- a/dateparser/data/date_translation_data/uk.py +++ b/dateparser/data/date_translation_data/uk.py @@ -514,6 +514,18 @@ }, { "за чверть": "15 хвилин" + }, + { + "(?<=[^\\d]\\s+|^)тиждень(?=\\s+тому)": "1 тиждень" + }, + { + "(?<=[^\\d]\\s+|^)місяць(?=\\s+тому)": "1 місяць" + }, + { + "(?<=[^\\d]\\s+|^)рік(?=\\s+тому)": "1 рік" + }, + { + "(?<=[^\\d]\\s+|^)день(?=\\s+тому)": "1 день" } ] } diff --git a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml index 6996d30ff..aa5442b98 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/ar.yaml @@ -57,3 +57,13 @@ relative-type: - ساعتين 1 hour ago: - ساعة واحدة + +simplifications: + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=(قبل|منذ)\s+)أسبوع\b': '1 أسبوع' + - '(?<=(قبل|منذ)\s+)شهر\b': '1 شهر' + - '(?<=(قبل|منذ)\s+)سنة\b': '1 سنة' + - '(?<=(قبل|منذ)\s+)يوم\b': '1 يوم' + - '(?<=(قبل|منذ)\s+)ساعة\b': '1 ساعة' + - '(?<=(قبل|منذ)\s+)دقيقة\b': '1 دقيقة' + - '(?<=(قبل|منذ)\s+)ثانية\b': '1 ثانية' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/be.yaml b/dateparser_data/supplementary_language_data/date_translation_data/be.yaml index c2e1fca27..3becfda2c 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/be.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/be.yaml @@ -95,3 +95,9 @@ simplifications: - некалькі секунд: 44 секунды - некалькі хвілін: 2 хвіліны - (\d+[.,]?\d*)\s*гадзін\s(\d+[.,]?\d*)\s*хвілін: \1:\2 + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=[^\d]\s+|^)тыдзень(?=\s+таму)': '1 тыдзень' + - '(?<=[^\d]\s+|^)месяц(?=\s+таму)': '1 месяц' + - '(?<=[^\d]\s+|^)год(?=\s+таму)': '1 год' + - '(?<=[^\d]\s+|^)дзень(?=\s+таму)': '1 дзень' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml b/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml index 0e8775658..3f84ae506 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/bg.yaml @@ -80,3 +80,6 @@ simplifications: - един: '1' - два: '2' - три: '3' + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=преди\s+)месец\b': '1 месец' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml b/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml index 377aeef97..c39d777cd 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/fi.yaml @@ -76,3 +76,10 @@ relative-type: simplifications: - (\d+[.,]?\d*) (sekunnin|sekuntin|minuutin|tunnin|päivän|viikon|kuukauden|vuoden) (päästä|kuluttua): \3 \1 \2 + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=[^\d]\s+|^)viikko(?=\s+sitten)': '1 viikko' + - '(?<=[^\d]\s+|^)kuukausi(?=\s+sitten)': '1 kuukausi' + - '(?<=[^\d]\s+|^)vuosi(?=\s+sitten)': '1 vuosi' + - '(?<=[^\d]\s+|^)päivä(?=\s+sitten)': '1 päivä' + - '(?<=[^\d]\s+|^)tunti(?=\s+sitten)': '1 tunti' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/he.yaml b/dateparser_data/supplementary_language_data/date_translation_data/he.yaml index fab67828f..ce96acfb9 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/he.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/he.yaml @@ -126,3 +126,11 @@ simplifications: - אחה"צ: pm - לפנות ערב: pm - בערב: pm + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=לפני\s+)שבוע\b': '1 שבוע' + - '(?<=לפני\s+)חודש\b': '1 חודש' + - '(?<=לפני\s+)שנה\b': '1 שנה' + - '(?<=לפני\s+)יום\b': '1 יום' + - '(?<=לפני\s+)שעה\b': '1 שעה' + - '(?<=לפני\s+)דקה\b': '1 דקה' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/hr.yaml b/dateparser_data/supplementary_language_data/date_translation_data/hr.yaml index 1749baffd..97cee4390 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/hr.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/hr.yaml @@ -143,3 +143,12 @@ relative-type-regex: simplifications: - podne: '12:00' - ponoć: '00:00' + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=prije\s+)tjedan(\s+dana)?': '1 tjedan' + - '(?<=prije\s+)mjesec(\s+dana)?': '1 mjesec' + - '(?<=prije\s+)godinu(\s+dana)?': '1 godinu' + - '(?<=prije\s+)sat(\s+vremena)?': '1 sat' + - '(?<=prije\s+)dan\b': '1 dan' + - '(?<=prije\s+)minutu': '1 minutu' + - '(?<=prije\s+)sekundu': '1 sekundu' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/lt.yaml b/dateparser_data/supplementary_language_data/date_translation_data/lt.yaml new file mode 100644 index 000000000..c77401aae --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/lt.yaml @@ -0,0 +1,9 @@ +simplifications: + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=prieš\s+)savaitę\b': '1 savaitę' + - '(?<=prieš\s+)mėnesį\b': '1 mėnesį' + - '(?<=prieš\s+)metus\b': '1 metus' + - '(?<=prieš\s+)dieną\b': '1 dieną' + - '(?<=prieš\s+)valandą\b': '1 valandą' + - '(?<=prieš\s+)minutę\b': '1 minutę' + - '(?<=prieš\s+)sekundę\b': '1 sekundę' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/lv.yaml b/dateparser_data/supplementary_language_data/date_translation_data/lv.yaml new file mode 100644 index 000000000..195cab331 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/lv.yaml @@ -0,0 +1,9 @@ +simplifications: + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=pirms\s+)nedēļas\b': '1 nedēļas' + - '(?<=pirms\s+)mēneša\b': '1 mēneša' + - '(?<=pirms\s+)gada\b': '1 gada' + - '(?<=pirms\s+)dienas\b': '1 dienas' + - '(?<=pirms\s+)stundas\b': '1 stundas' + - '(?<=pirms\s+)minūtes\b': '1 minūtes' + - '(?<=pirms\s+)sekundes\b': '1 sekundes' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml b/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml index bb4ecc8a8..a7f82b3e0 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/mk.yaml @@ -13,3 +13,12 @@ relative-type: - минатата година in 1 year: - следната година + +simplifications: + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=пред\s+)седмица\b': '1 седмица' + - '(?<=пред\s+)месец\b': '1 месец' + - '(?<=пред\s+)година\b': '1 година' + - '(?<=пред\s+)ден\b': '1 ден' + - '(?<=пред\s+)час\b': '1 час' + - '(?<=пред\s+)минута\b': '1 минута' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml index e0aaa0830..a83262207 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/pl.yaml @@ -166,3 +166,12 @@ simplifications: - przedwczoraj: 2 dnia temu - jutro: za 1 dnia - pojutrze: za 2 dnia + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=[^\d]\s+|^)tydzień(?=\s+temu)': '1 tydzień' + - '(?<=[^\d]\s+|^)miesiąc(?=\s+temu)': '1 miesiąc' + - '(?<=[^\d]\s+|^)rok(?=\s+temu)': '1 rok' + - '(?<=[^\d]\s+|^)dzień(?=\s+temu)': '1 dzień' + - '(?<=[^\d]\s+|^)godzinę(?=\s+temu)': '1 godzinę' + - '(?<=[^\d]\s+|^)minutę(?=\s+temu)': '1 minutę' + - '(?<=[^\d]\s+|^)sekundę(?=\s+temu)': '1 sekundę' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/sl.yaml b/dateparser_data/supplementary_language_data/date_translation_data/sl.yaml new file mode 100644 index 000000000..c6c74df34 --- /dev/null +++ b/dateparser_data/supplementary_language_data/date_translation_data/sl.yaml @@ -0,0 +1,9 @@ +simplifications: + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=pred\s+)tednom\b': '1 tednom' + - '(?<=pred\s+)mesecem\b': '1 mesecem' + - '(?<=pred\s+)letom\b': '1 letom' + - '(?<=pred\s+)dnevom\b': '1 dnevom' + - '(?<=pred\s+)uro\b': '1 uro' + - '(?<=pred\s+)minuto\b': '1 minuto' + - '(?<=pred\s+)sekundo\b': '1 sekundo' diff --git a/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml b/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml index ae68cc782..f4bfe2b55 100644 --- a/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml +++ b/dateparser_data/supplementary_language_data/date_translation_data/uk.yaml @@ -203,3 +203,9 @@ simplifications: - кілька хвилин: 2 хвилини - опів на: 30 хвилин - за чверть: 15 хвилин + + # The numeral "1" is optional: a bare unit means "1 unit" ago + - '(?<=[^\d]\s+|^)тиждень(?=\s+тому)': '1 тиждень' + - '(?<=[^\d]\s+|^)місяць(?=\s+тому)': '1 місяць' + - '(?<=[^\d]\s+|^)рік(?=\s+тому)': '1 рік' + - '(?<=[^\d]\s+|^)день(?=\s+тому)': '1 день' diff --git a/tests/test_freshness_date_parser.py b/tests/test_freshness_date_parser.py index e85812dea..58629945d 100644 --- a/tests/test_freshness_date_parser.py +++ b/tests/test_freshness_date_parser.py @@ -720,6 +720,31 @@ def test_relative_past_dates_with_time_as_period( param("před hodinu", ago={"hours": 1}, period="day"), param("před minutu", ago={"minutes": 1}, period="day"), param("před sekundu", ago={"seconds": 1}, period="day"), + param("قبل أسبوع", ago={"weeks": 1}, period="week"), # ar + param("قبل ساعة", ago={"hours": 1}, period="day"), # ar + param("тыдзень таму", ago={"weeks": 1}, period="week"), # be + param("год таму", ago={"years": 1}, period="year"), # be + param("преди месец", ago={"months": 1}, period="month"), # bg + param("viikko sitten", ago={"weeks": 1}, period="week"), # fi + param("tunti sitten", ago={"hours": 1}, period="day"), # fi + param("לפני שבוע", ago={"weeks": 1}, period="week"), # he + param("לפני שעה", ago={"hours": 1}, period="day"), # he + param("prije tjedan dana", ago={"weeks": 1}, period="week"), # hr + param("prije mjesec dana", ago={"months": 1}, period="month"), # hr + param("prije sat vremena", ago={"hours": 1}, period="day"), # hr + param("prieš savaitę", ago={"weeks": 1}, period="week"), # lt + param("prieš metus", ago={"years": 1}, period="year"), # lt + param("pirms nedēļas", ago={"weeks": 1}, period="week"), # lv + param("pirms gada", ago={"years": 1}, period="year"), # lv + param("пред седмица", ago={"weeks": 1}, period="week"), # mk + param("пред месец", ago={"months": 1}, period="month"), # mk + param("tydzień temu", ago={"weeks": 1}, period="week"), # pl + param("miesiąc temu", ago={"months": 1}, period="month"), # pl + param("godzinę temu", ago={"hours": 1}, period="day"), # pl + param("pred tednom", ago={"weeks": 1}, period="week"), # sl + param("pred uro", ago={"hours": 1}, period="day"), # sl + param("тиждень тому", ago={"weeks": 1}, period="week"), # uk + param("рік тому", ago={"years": 1}, period="year"), # uk # cy param("5 wythnos yn ôl", ago={"weeks": 5}, period="week"), param(

-
-
- Dateparser - -
-