dateparser 1.2.1__py3-none-any.whl

dateparser/__init__.py

@@ -0,0 +1,82 @@
+__version__ = "1.2.1"
+
+from .conf import apply_settings
+from .date import 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,
+):
+    """Parse date and time from given date string.
+
+    :param date_string:
+        A string representing date and/or time in a recognizably valid format.
+    :type date_string: str
+
+    :param date_formats:
+        A list of format strings using directives as given
+        `here <https://docs.python.org/2/library/datetime.html#strftime-and-strptime-behavior>`_.
+        The parser applies formats one by one, taking into account the detected languages/locales.
+    :type date_formats: list
+
+    :param languages:
+        A list of language codes, e.g. ['en', 'es', 'zh-Hant'].
+        If locales are not given, languages and region are used to construct locales for translation.
+    :type languages: list
+
+    :param locales:
+        A list of locale codes, e.g. ['fr-PF', 'qu-EC', 'af-NA'].
+        The parser uses only these locales to translate date string.
+    :type locales: list
+
+    :param region:
+        A region code, e.g. 'IN', '001', 'NE'.
+        If locales are not given, languages and region are used to construct locales for translation.
+    :type region: str
+
+    :param settings:
+        Configure customized behavior using settings defined in :mod:`dateparser.conf.Settings`.
+    :type settings: dict
+
+    :param detect_languages_function:
+        A function for language detection that takes as input a string (the `date_string`) and
+        a `confidence_threshold`, and returns a list of detected language codes.
+        Note: this function is only used if ``languages`` and ``locales`` are not provided.
+    :type detect_languages_function: function
+
+    :return: Returns :class:`datetime <datetime.datetime>` representing parsed date if successful, else returns None
+    :rtype: :class:`datetime <datetime.datetime>`.
+    :raises:
+        ``ValueError``: Unknown Language, ``TypeError``: Languages argument must be a list,
+        ``SettingValidationError``: A provided setting is not valid.
+    """
+    parser = _default_parser
+
+    if (
+        languages
+        or locales
+        or region
+        or detect_languages_function
+        or not settings._default
+    ):
+        parser = DateDataParser(
+            languages=languages,
+            locales=locales,
+            region=region,
+            settings=settings,
+            detect_languages_function=detect_languages_function,
+        )
+
+    data = parser.get_date_data(date_string, date_formats)
+
+    if data:
+        return data["date_obj"]

dateparser/calendars/__init__.py

@@ -0,0 +1,144 @@
+from datetime import datetime
+
+from dateparser.conf import settings
+from dateparser.date import DateData
+from dateparser.parser import _parser
+
+
+class CalendarBase:
+    """Base setup class for non-Gregorian calendar system.
+
+    :param source:
+        Date string passed to calendar parser.
+    :type source: str
+    """
+
+    parser = NotImplemented
+
+    def __init__(self, source):
+        self.source = source
+
+    def get_date(self):
+        try:
+            date_obj, period = self.parser.parse(self.source, settings)
+            return DateData(date_obj=date_obj, period=period)
+        except ValueError:
+            pass
+
+
+class non_gregorian_parser(_parser):
+    calendar_converter = NotImplemented
+    default_year = NotImplemented
+    default_month = NotImplemented
+    default_day = NotImplemented
+    non_gregorian_date_cls = NotImplemented
+
+    _digits = None
+    _months = None
+    _weekdays = None
+    _number_letters = None
+
+    @classmethod
+    def _replace_time_conventions(cls, source):
+        return source
+
+    @classmethod
+    def _replace_digits(cls, source):
+        return source
+
+    @classmethod
+    def _replace_months(cls, source):
+        return source
+
+    @classmethod
+    def _replace_weekdays(cls, source):
+        return source
+
+    @classmethod
+    def _replace_time(cls, source):
+        return source
+
+    @classmethod
+    def _replace_days(cls, source):
+        return source
+
+    @classmethod
+    def to_latin(cls, source):
+        result = source
+        result = cls._replace_months(result)
+        result = cls._replace_weekdays(result)
+        result = cls._replace_digits(result)
+        result = cls._replace_days(result)
+        result = cls._replace_time(result)
+        result = cls._replace_time_conventions(result)
+
+        result = result.strip()
+
+        return result
+
+    def handle_two_digit_year(self, year):
+        raise ValueError
+
+    def _get_datetime_obj(self, **params):
+        day = params["day"]
+        year = params["year"]
+        month = params["month"]
+        if not (0 < day <= self.calendar_converter.month_length(year, month)) and not (
+            self._token_day or hasattr(self, "_token_weekday")
+        ):
+            day = self.calendar_converter.month_length(year, month)
+        year, month, day = self.calendar_converter.to_gregorian(
+            year=year, month=month, day=day
+        )
+        c_params = params.copy()
+        c_params.update(dict(year=year, month=month, day=day))
+        return datetime(**c_params)
+
+    def _get_datetime_obj_params(self):
+        if not self.now:
+            self._set_relative_base()
+        now_year, now_month, now_day = self.calendar_converter.from_gregorian(
+            self.now.year, self.now.month, self.now.day
+        )
+        params = {
+            "day": self.day or now_day,
+            "month": self.month or now_month,
+            "year": self.year or now_year,
+            "hour": 0,
+            "minute": 0,
+            "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
+        token_len = len(token)
+        is_digit = token.isdigit()
+        if directive == "%A" and self._weekdays and token.title() in self._weekdays:
+            pass
+        elif (
+            directive == "%m" and token_len <= 2 and is_digit and 1 <= int(token) <= 12
+        ):
+            month = int(token)
+        elif directive == "%B" and self._months and token in self._months:
+            month = list(self._months.keys()).index(token) + 1
+        elif (
+            directive == "%d"
+            and token_len <= 2
+            and is_digit
+            and 0 < int(token) <= self.calendar_converter.month_length(year, month)
+        ):
+            day = int(token)
+        elif directive == "%Y" and token_len == 4 and is_digit:
+            year = int(token)
+        elif directive == "%Y" and token_len == 2 and is_digit:
+            year = self.handle_two_digit_year(int(token))
+        else:
+            raise ValueError
+        return self.non_gregorian_date_cls(year, month, day)
+
+    @classmethod
+    def parse(cls, datestring, settings):
+        datestring = cls.to_latin(datestring)
+        return super().parse(datestring, settings)

dateparser/calendars/hijri.py

@@ -0,0 +1,6 @@
+from dateparser.calendars import CalendarBase
+from dateparser.calendars.hijri_parser import hijri_parser
+
+
+class HijriCalendar(CalendarBase):
+    parser = hijri_parser

dateparser/calendars/hijri_parser.py

@@ -0,0 +1,60 @@
+from hijridate import Gregorian, Hijri
+
+from dateparser.calendars import non_gregorian_parser
+
+
+class hijri:
+    @classmethod
+    def to_gregorian(cls, year=None, month=None, day=None):
+        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):
+        h = Gregorian(year, month, day).to_hijri()
+        return h.datetuple()
+
+    @classmethod
+    def month_length(cls, year, month):
+        h = Hijri(year=year, month=month, day=1)
+        return h.month_length()
+
+
+class HijriDate:
+    def __init__(self, year, month, day):
+        self.year = year
+        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
+    default_year = 1389
+    default_month = 1
+    default_day = 1
+    non_gregorian_date_cls = HijriDate
+
+    _time_conventions = {
+        "am": ["صباحاً"],
+        "pm": ["مساءً"],
+    }
+
+    @classmethod
+    def _replace_time_conventions(cls, source):
+        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):
+        if year >= 90:
+            return year + 1300
+        else:
+            return year + 1400

dateparser/calendars/jalali.py

@@ -0,0 +1,9 @@
+from dateparser.calendars.jalali_parser import jalali_parser
+
+from . import CalendarBase
+
+
+class JalaliCalendar(CalendarBase):
+    """Calendar class for Jalali calendar."""
+
+    parser = jalali_parser

dateparser/calendars/jalali_parser.py

@@ -0,0 +1,184 @@
+import re
+from collections import OrderedDict
+from functools import reduce
+
+from convertdate import persian
+
+from dateparser.calendars import non_gregorian_parser
+
+
+class PersianDate:
+    def __init__(self, year, month, day):
+        self.year = year
+        self.month = month
+        self.day = day
+
+    def weekday(self):
+        for week in persian.monthcalendar(self.year, self.month):
+            for idx, day in enumerate(week):
+                if day == self.day:
+                    return idx
+
+
+class jalali_parser(non_gregorian_parser):
+    calendar_converter = persian
+    default_year = 1348
+    default_month = 1
+    default_day = 1
+    non_gregorian_date_cls = PersianDate
+
+    _digits = {
+        "۰": 0,
+        "۱": 1,
+        "۲": 2,
+        "۳": 3,
+        "۴": 4,
+        "۵": 5,
+        "۶": 6,
+        "۷": 7,
+        "۸": 8,
+        "۹": 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", ["روز شنبه", "شنبه"]),
+        ]
+    )
+
+    _number_letters = {
+        0: ["صفر"],
+        1: ["یک", "اول"],
+        2: ["دو"],
+        3: ["سه", "سو"],
+        4: ["چهار"],
+        5: ["پنج"],
+        6: ["شش"],
+        7: ["هفت"],
+        8: ["هشت"],
+        9: ["نه"],
+        10: ["ده"],
+        11: ["یازده"],
+        12: ["دوازده"],
+        13: ["سیزده"],
+        14: ["چهارده"],
+        15: ["پانزده"],
+        16: ["شانزده"],
+        17: ["هفده"],
+        18: ["هجده"],
+        19: ["نوزده"],
+        20: ["بیست"],
+        21: ["بیست و یک"],
+        22: ["بیست و دو", "بیست ثانیه"],
+        23: ["بیست و سه", "بیست و سو"],
+        24: ["بیست و چهار"],
+        25: ["بیست و پنج"],
+        26: ["بیست و شش"],
+        27: ["بیست و هفت"],
+        28: ["بیست و هشت"],
+        29: ["بیست و نه"],
+        30: ["سی"],
+        31: ["سی و یک"],
+    }
+
+    @classmethod
+    def _replace_digits(cls, source):
+        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):
+        result = source
+        for pers, latin in reduce(
+            lambda a, b: a + b,
+            [
+                [(value, month) for value in repl[-1]]
+                for month, repl in cls._months.items()
+            ],
+        ):
+            result = result.replace(pers, latin)
+        return result
+
+    @classmethod
+    def _replace_weekdays(cls, source):
+        result = source
+        for pers, latin in reduce(
+            lambda a, b: a + b,
+            [
+                [(value, weekday) for value in repl]
+                for weekday, repl in cls._weekdays.items()
+            ],
+        ):
+            result = result.replace(pers, latin)
+        return result
+
+    @classmethod
+    def _replace_time(cls, source):
+        def only_numbers(match_obj):
+            matched_string = match_obj.group()
+            return re.sub(r"\D", " ", matched_string)
+
+        hour_pattern = r"ساعت\s+\d{2}"
+        minute_pattern = r"\d{2}\s+دقیقه"
+        second_pattern = r"\d{2}\s+ثانیه"
+        result = re.sub(hour_pattern, only_numbers, source)
+        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
+
+    @classmethod
+    def _replace_days(cls, source):
+        result = re.sub(
+            r"ام|م|ین", "", source
+        )  # removes persian variant of th/first/second/third
+        day_pairs = list(cls._number_letters.items())
+
+        def comp_key(tup):
+            return tup[0]
+
+        day_pairs.sort(key=comp_key, reverse=True)
+
+        thirteen, thirty = day_pairs[-14], day_pairs[1]
+        day_pairs[-14] = thirty
+        day_pairs[1] = thirteen
+
+        for persian_number, number in reduce(
+            lambda a, b: a + b,
+            [[(val, repl) for val in persian_word] for repl, persian_word in day_pairs],
+        ):
+            result = result.replace(persian_number, str(number))
+        return result
+
+    def handle_two_digit_year(self, year):
+        if year > 60:
+            return year + 1300
+        else:
+            return year + 1400