dateparser 1.2.2__tar.gz → 1.3.0__tar.gz

{dateparser-1.2.2 → dateparser-1.3.0}/HISTORY.rst

@@ -3,6 +3,31 @@
 History
 =======
 
+1.3.0 (2026-02-04)
+------------------
+
+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)
 ------------------
 

{dateparser-1.2.2 → dateparser-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dateparser
-Version: 1.2.2
+Version: 1.3.0
 Summary: Date parsing library designed to parse dates from HTML pages
 Home-page: https://github.com/scrapinghub/dateparser
 Author: Scrapinghub
@@ -13,13 +13,13 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 License-File: LICENSE
 License-File: AUTHORS.rst
 Requires-Dist: python-dateutil>=2.7.0
@@ -31,7 +31,7 @@ Requires-Dist: convertdate>=2.2.1; extra == "calendars"
 Requires-Dist: hijridate; extra == "calendars"
 Provides-Extra: fasttext
 Requires-Dist: fasttext>=0.9.1; extra == "fasttext"
-Requires-Dist: numpy<2,>=1.19.3; extra == "fasttext"
+Requires-Dist: numpy<2,>=1.22.0; extra == "fasttext"
 Provides-Extra: langdetect
 Requires-Dist: langdetect>=1.0.0; extra == "langdetect"
 Dynamic: author
@@ -261,6 +261,17 @@ You can extract dates from longer strings of text. They are returned as list of
    
    :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 `settings` section as well as the `using-datedataparser` section.
@@ -319,6 +330,31 @@ To be able to use them you need to install the `calendar` extra by typing:
 History
 =======
 
+1.3.0 (2026-02-04)
+------------------
+
+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)
 ------------------
 

{dateparser-1.2.2 → dateparser-1.3.0}/README.rst

@@ -58,6 +58,7 @@ Key Features
 -  `Search
    dates <https://dateparser.readthedocs.io/en/latest/introduction.html#search-for-dates-in-longer-chunks-of-text>`__
    in longer texts.
+-  Time span detection for expressions like "past month", "last week".
 
 Online demo
 -----------
@@ -156,7 +157,7 @@ are executed, you can do so through the
 Installation
 ------------
 
-Dateparser supports Python >= 3.9. You can install it by doing:
+Dateparser supports Python 3.10+. You can install it by doing:
 
 ::
 

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.2.2"
+__version__ = "1.3.0"
 
 from .conf import apply_settings
 from .date import DateDataParser

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/conf.py

@@ -27,6 +27,9 @@ class Settings:
     * `SKIP_TOKENS`
     * `NORMALIZE`
     * `RETURN_TIME_AS_PERIOD`
+    * `RETURN_TIME_SPAN`
+    * `DEFAULT_START_OF_WEEK`
+    * `DEFAULT_DAYS_IN_MONTH`
     * `PARSERS`
     * `DEFAULT_LANGUAGES`
     * `LANGUAGE_DETECTION_CONFIDENCE_THRESHOLD`
@@ -229,6 +232,14 @@ def check_settings(settings):
         "CACHE_SIZE_LIMIT": {
             "type": int,
         },
+        "RETURN_TIME_SPAN": {"type": bool},
+        "DEFAULT_START_OF_WEEK": {
+            "values": ("monday", "sunday"),
+            "type": str,
+        },
+        "DEFAULT_DAYS_IN_MONTH": {
+            "type": int,
+        },
     }
 
     modified_settings = settings._mod_settings  # check only modified settings

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/data/date_translation_data/en.py

@@ -51,32 +51,39 @@ info = {
     ],
     "monday": [
         "mon",
-        "monday"
+        "monday",
+        "mo"
     ],
     "tuesday": [
         "tue",
         "tuesday",
+        "tu",
         "Tues"
     ],
     "wednesday": [
         "wed",
-        "wednesday"
+        "wednesday",
+        "we"
     ],
     "thursday": [
         "thu",
-        "thursday"
+        "thursday",
+        "th"
     ],
     "friday": [
         "fri",
-        "friday"
+        "friday",
+        "fr"
     ],
     "saturday": [
         "sat",
-        "saturday"
+        "saturday",
+        "sa"
     ],
     "sunday": [
         "sun",
-        "sunday"
+        "sunday",
+        "su"
     ],
     "am": [
         "am"
@@ -258,6 +265,8 @@ info = {
         "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 \\1 year": [

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/data/date_translation_data/fi.py

@@ -316,6 +316,7 @@ info = {
     "locale_specific": {},
     "skip": [
         ":n",
+        "klo",
         " ",
         "'",
         ",",

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/data/date_translation_data/ru.py

@@ -340,73 +340,91 @@ info = {
     ],
     "simplifications": [
         {
-            "од(на|ну|ни|ной|ин)": "1"
+            "од(ин|на|ну|ни|ной|ною|но|ного|ному|ним|нем)": "1"
         },
         {
-            "дв(а|е|ое|ух)": "2"
+            "перв(ой|ого|ому|ым|ом|ая|ую|ое|ые|ых|ыми)": "1"
         },
         {
-            "пар[ауы]": "2"
+            "дв(а|е|ух|ум|умя|ое)": "2"
         },
         {
-            "три": "3"
+            "пар(а|ы|е|у|ой|ою|ам|ами|ах)": "2"
         },
         {
-            "четыре": "4"
+            "втор(ой|ого|ому|ым|ом|ая|ую|ое|ые|ых|ыми)": "2"
         },
         {
-            "пять": "5"
+            "тр(и|ёх|ем|ём|емя|етье)": "3"
         },
         {
-            "шесть": "6"
+            "трети(й|его|ему|им|ем|я|ей|ею|ую|е|и|их|ими)": "3"
         },
         {
-            "семь": "7"
+            "четыр(е|ёх|ем|ём|ьмя)": "4"
         },
         {
-            "восемь": "8"
+            "четвёрт(ый|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "4"
         },
         {
-            "девять": "9"
+            "четверт(ый|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "4"
         },
         {
-            "десять": "10"
+            "пят(ь|и|ью)": "5"
         },
         {
-            "одиннадцать": "11"
+            "пят(ый|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "5"
         },
         {
-            "двенадцать": "12"
+            "шест(ь|и|ью)": "6"
         },
         {
-            "пятнадцать": "15"
+            "шест(ый|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "6"
         },
         {
-            "двадцать": "20"
+            "сем(ь|и|ью)": "7"
         },
         {
-            "тридцать": "30"
+            "седьм(ой|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "7"
         },
         {
-            "сорок": "40"
+            "восьм(и|ью|ьею)|восем(ь|ью)": "8"
         },
         {
-            "пятьдесят": "50"
+            "восьм(ой|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "8"
         },
         {
-            "несколько секунд": "44 секунды"
+            "девят(ь|и|ью)": "9"
         },
         {
-            "полчаса": "30 минут"
+            "девят(ый|ого|ому|ым|ом|ая|ой|ою|ую|ое|ые|ых|ыми)": "9"
         },
         {
-            "полгода": "6 месяцев"
+            "десять": "10"
         },
         {
-            "полтора часа": "90 минут"
+            "одиннадцать": "11"
         },
         {
-            "полтора года": "18 месяцев"
+            "двенадцать": "12"
+        },
+        {
+            "пятнадцать": "15"
+        },
+        {
+            "двадцат(ь|ое)": "20"
+        },
+        {
+            "тридцат(ь|ое)": "30"
+        },
+        {
+            "соро(к|ка|ковое)": "40"
+        },
+        {
+            "пятьдесят": "50"
+        },
+        {
+            "пятидесятое": "50"
         },
         {
             "((?<=(через|спустя|в течение)\\s+)секунд[уы]|(?<=[^\\d]\\s+|^)секунду(?=(\\s+назад)))": "1 секунду"
@@ -426,12 +444,27 @@ info = {
         {
             "((?<=(через|спустя|в течение)\\s+)недел[юи]|(?<=[^\\d]\\s+|^)неделю(?=(\\s+назад)))": "1 неделю"
         },
+        {
+            "полгода": "6 месяцев"
+        },
         {
             "((?<=(через|спустя|в течение)\\s+)месяца?|(?<=[^\\d]\\s+|^)месяц(?=(\\s+назад)))": "1 месяц"
         },
         {
             "((?<=(через|спустя|в течение)\\s+)года?|(?<=[^\\d]\\s+|^)год(?=(\\s+назад)))": "1 год"
         },
+        {
+            "полтора года": "18 месяцев"
+        },
+        {
+            "полчаса": "30 минут"
+        },
+        {
+            "несколько секунд": "44 секунды"
+        },
+        {
+            "полтора часа": "90 минут"
+        },
         {
             "(\\d{3,}1)\\s*год\\s*$": "\\1"
         },

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/date.py

@@ -19,6 +19,7 @@ from dateparser.utils import (
     set_correct_day_from_settings,
     set_correct_month_from_settings,
 )
+from dateparser.utils.strptime import strptime as patched_strptime
 
 APOSTROPHE_LOOK_ALIKE_CHARS = [
     "\N{RIGHT SINGLE QUOTATION MARK}",  # '\u2019'
@@ -182,7 +183,7 @@ def parse_with_formats(date_string, date_formats, settings):
     period = "day"
     for date_format in date_formats:
         try:
-            date_obj = datetime.strptime(date_string, date_format)
+            date_obj = patched_strptime(date_string, date_format)
         except ValueError:
             continue
         else:

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/freshness_date_parser.py

@@ -10,7 +10,7 @@ from .parser import time_parser
 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 @@ class FreshnessDateDataParser:
         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 @@ class FreshnessDateDataParser:
                 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 @@ class FreshnessDateDataParser:
             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

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/languages/dictionary.py

@@ -201,14 +201,25 @@ class Dictionary:
                 curr_split = (
                     [known] if self._should_capture(known, keep_formatting) else []
                 )
+
                 if unparsed and self._should_capture(unparsed, keep_formatting):
                     curr_split = (
                         self._split_by_numerals(unparsed, keep_formatting) + curr_split
                     )
+
                 if unknown:
                     string = unknown if string != unknown else ""
 
-            splitted.extend(curr_split)
+            for token in curr_split:
+                if (
+                    splitted
+                    and splitted[-1].isdigit()
+                    and token in {"st", "nd", "rd", "th"}
+                ):
+                    continue
+
+                splitted.append(token)
+
         return splitted
 
     def _split_by_numerals(self, string, keep_formatting):

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/languages/locale.py

@@ -144,7 +144,6 @@ class Locale:
                     date_string_tokens[i] = dictionary[word] or fallback
         if "in" in date_string_tokens:
             date_string_tokens = self._clear_future_words(date_string_tokens)
-
         return self._join(
             list(filter(bool, date_string_tokens)),
             separator="" if keep_formatting else " ",
@@ -426,11 +425,39 @@ class Locale:
     def _simplify(self, date_string, settings=None):
         date_string = date_string.lower()
         simplifications = self._get_simplifications(settings=settings)
+
+        if self.info.get("name") == "ru":
+            date_string = self._process_russian_compound_ordinals(
+                date_string, simplifications
+            )
+        else:
+            date_string = self._apply_simplifications(date_string, simplifications)
+
+        return date_string
+
+    def _apply_simplifications(self, date_string, simplifications):
         for simplification in simplifications:
             pattern, replacement = list(simplification.items())[0]
             date_string = pattern.sub(replacement, date_string).lower()
         return date_string
 
+    def _process_russian_compound_ordinals(self, date_string, simplifications):
+        """Process Russian compound ordinals mathematically (двадцать + первое = 21)."""
+        date_string = self._apply_simplifications(date_string, simplifications)
+
+        def replace_number_pairs(match):
+            first_num = int(match.group(1))
+            second_num = int(match.group(2))
+            result = first_num + second_num
+            if 1 <= result <= 31 and first_num in [20, 30] and 1 <= second_num <= 9:
+                return str(result)
+            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
+
     def _get_simplifications(self, settings=None):
         no_word_spacing = eval(self.info.get("no_word_spacing", "False"))
         if settings.NORMALIZE:

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/search/search.py

@@ -1,4 +1,5 @@
 from collections.abc import Set
+from datetime import datetime
 
 import regex as re
 
@@ -7,6 +8,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.text_detection import FullTextLanguageDetector
+from dateparser.utils.time_spans import detect_time_span, generate_time_span
 
 RELATIVE_REG = re.compile("(ago|in|from now|tomorrow|today|yesterday)")
 
@@ -185,8 +187,23 @@ class _ExactLanguageSearch:
             translated=translated,
             settings=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))
+
         parser._settings = Settings()
-        return list(zip(substrings, [i[0]["date_obj"] for i in parsed]))
+        return results
 
 
 class DateSearchWithDetection:

{dateparser-1.2.2 → dateparser-1.3.0}/dateparser/utils/strptime.py

@@ -90,7 +90,34 @@ def patch_strptime():
 __strptime = patch_strptime()
 
 
-def strptime(date_string, format):
+def _prepare_format(date_string: str, og_format: str) -> tuple[str, str]:
+    # 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
+
+    def repl(m: re.Match[str]) -> str:
+        format_char = m[1]
+        if format_char in ("Y", "y", "G"):
+            nonlocal year_in_format
+            year_in_format = True
+        elif format_char in ("d",):
+            nonlocal day_of_month_in_format
+            day_of_month_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
+
+
+def strptime(date_string: str, format: str) -> datetime:
+    date_string, format = _prepare_format(date_string, format)
     obj = datetime(*__strptime(date_string, format)[:-3])
 
     if "%f" in format: