dateparser 1.2.1__py3-none-any.whl

dateparser/utils/__init__.py

@@ -0,0 +1,257 @@
+import calendar
+import logging
+import types
+import unicodedata
+from collections import OrderedDict
+from datetime import datetime
+
+import regex as re
+from pytz import UTC, UnknownTimeZoneError, timezone
+from tzlocal import get_localzone
+
+from dateparser.timezone_parser import StaticTzInfo, _tz_offsets
+
+
+def strip_braces(date_string):
+    return re.sub(r"[{}()<>\[\]]+", "", date_string)
+
+
+def normalize_unicode(string, form="NFKD"):
+    return "".join(
+        c
+        for c in unicodedata.normalize(form, string)
+        if unicodedata.category(c) != "Mn"
+    )
+
+
+def combine_dicts(primary_dict, supplementary_dict):
+    combined_dict = OrderedDict()
+    for key, value in primary_dict.items():
+        if key in supplementary_dict:
+            if isinstance(value, list):
+                combined_dict[key] = value + supplementary_dict[key]
+            elif isinstance(value, dict):
+                combined_dict[key] = combine_dicts(value, supplementary_dict[key])
+            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()
+    ]
+    for key in remaining_keys:
+        combined_dict[key] = supplementary_dict[key]
+    return combined_dict
+
+
+def find_date_separator(format):
+    m = re.search(r"(?:(?:%[dbBmaA])(\W))+", format)
+    if m:
+        return m.group(1)
+
+
+def _get_missing_parts(fmt):
+    """
+    Return a list containing missing parts (day, month, year)
+    from a date format checking its directives
+    """
+    directive_mapping = {
+        "day": ["%d", "%-d", "%j", "%-j"],
+        "month": ["%b", "%B", "%m", "%-m"],
+        "year": ["%y", "%-y", "%Y"],
+    }
+
+    missing = [
+        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:
+        for name, info in _tz_offsets:
+            if info["regex"].search(" %s" % tz_string):
+                return StaticTzInfo(name, info["offset"])
+        else:
+            raise e
+
+
+def localize_timezone(date_time, tz_string):
+    if date_time.tzinfo:
+        return date_time
+
+    tz = get_timezone_from_tz_string(tz_string)
+
+    if hasattr(tz, "localize"):
+        date_time = tz.localize(date_time)
+    else:
+        date_time = date_time.replace(tzinfo=tz)
+
+    return date_time
+
+
+def apply_tzdatabase_timezone(date_time, pytz_string):
+    usr_timezone = timezone(pytz_string)
+
+    if date_time.tzinfo != usr_timezone:
+        date_time = date_time.astimezone(usr_timezone)
+
+    return date_time
+
+
+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):
+            tz = StaticTzInfo(name, info["offset"])
+            return utc_datetime.astimezone(tz)
+
+
+def apply_timezone(date_time, tz_string):
+    if not date_time.tzinfo:
+        if hasattr(UTC, "localize"):
+            date_time = UTC.localize(date_time)
+        else:
+            date_time = date_time.replace(tzinfo=UTC)
+
+    new_datetime = apply_dateparser_timezone(date_time, tz_string)
+
+    if not new_datetime:
+        new_datetime = apply_tzdatabase_timezone(date_time, tz_string)
+
+    return new_datetime
+
+
+def apply_timezone_from_settings(date_obj, settings):
+    tz = get_localzone()
+    if settings is None:
+        return date_obj
+
+    if "local" in settings.TIMEZONE.lower():
+        if hasattr(tz, "localize"):
+            date_obj = tz.localize(date_obj)
+        else:
+            date_obj = date_obj.replace(tzinfo=tz)
+    else:
+        date_obj = localize_timezone(date_obj, settings.TIMEZONE)
+
+    if settings.TO_TIMEZONE:
+        date_obj = apply_timezone(date_obj, settings.TO_TIMEZONE)
+
+    if settings.RETURN_AS_TIMEZONE_AWARE is not True:
+        date_obj = date_obj.replace(tzinfo=None)
+
+    return date_obj
+
+
+def get_last_day_of_month(year, month):
+    return calendar.monthrange(year, month)[1]
+
+
+def get_previous_leap_year(year):
+    return _get_leap_year(year, future=False)
+
+
+def get_next_leap_year(year):
+    return _get_leap_year(year, future=True)
+
+
+def _get_leap_year(year, future):
+    """
+    Iterate through previous or next years until it gets a valid leap year
+    This is performed to avoid missing or including centurial leap years
+    """
+    step = 1 if future else -1
+    leap_year = year + step
+    while not calendar.isleap(leap_year):
+        leap_year += step
+    return leap_year
+
+
+def set_correct_day_from_settings(date_obj, settings, current_day=None):
+    """Set correct day attending the `PREFER_DAY_OF_MONTH` setting."""
+    options = {
+        "first": 1,
+        "last": get_last_day_of_month(date_obj.year, date_obj.month),
+        "current": current_day or datetime.now().day,
+    }
+
+    try:
+        return date_obj.replace(day=options[settings.PREFER_DAY_OF_MONTH])
+    except ValueError:
+        return date_obj.replace(day=options["last"])
+
+
+def set_correct_month_from_settings(date_obj, settings, current_month=None):
+    """Set correct month attending the `PREFER_MONTH_OF_YEAR` setting."""
+    options = {"first": 1, "last": 12, "current": current_month or datetime.now().month}
+
+    try:
+        return date_obj.replace(month=options[settings.PREFER_MONTH_OF_YEAR])
+    except ValueError:
+        return date_obj.replace(month=options["last"])
+
+
+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]
+
+        return staticmethod(constructor)
+
+    if not (
+        hasattr(cls, "get_key")
+        and isinstance(cls.get_key, types.MethodType)
+        and cls.get_key.__self__ is cls
+    ):
+        raise NotImplementedError(
+            "Registry classes require to implement class method get_key"
+        )
+
+    setattr(cls, "__new__", choose(cls.__new__))
+    return cls
+
+
+def get_logger():
+    setup_logging()
+    return logging.getLogger("dateparser")
+
+
+def setup_logging():
+    if len(logging.root.handlers):
+        return
+
+    config = {
+        "version": 1,
+        "disable_existing_loggers": True,
+        "formatters": {
+            "console": {
+                "format": "%(asctime)s %(levelname)s: [%(name)s] %(message)s",
+            },
+        },
+        "handlers": {
+            "console": {
+                "level": logging.DEBUG,
+                "class": "logging.StreamHandler",
+                "formatter": "console",
+                "stream": "ext://sys.stdout",
+            },
+        },
+        "root": {
+            "level": logging.DEBUG,
+            "handlers": ["console"],
+        },
+    }
+    logging.config.dictConfig(config)

dateparser/utils/strptime.py

@@ -0,0 +1,108 @@
+import importlib.util
+import sys
+from datetime import datetime
+
+import regex as re
+
+TIME_MATCHER = re.compile(
+    r".*?"
+    r"(?P<hour>2[0-3]|[0-1]\d|\d):"
+    r"(?P<minute>[0-5]\d|\d):"
+    r"(?P<second>6[0-1]|[0-5]\d|\d)"
+    r"\.(?P<microsecond>[0-9]{1,6})"
+)
+
+MS_SEARCHER = re.compile(r"\.(?P<microsecond>[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.
+
+    For example, if system's locale is set to fr_FR. Parser won't recognize
+    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)
+    _exec_module(_strptime_spec, _strptime)
+    sys.modules["strptime_patched"] = _strptime
+
+    _calendar = importlib.util.module_from_spec(_strptime_spec)
+    _exec_module(_strptime_spec, _calendar)
+    sys.modules["calendar_patched"] = _calendar
+
+    _strptime._getlang = lambda: ("en_US", "UTF-8")
+    _strptime.calendar = _calendar
+    _strptime.calendar.day_abbr = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]
+    _strptime.calendar.day_name = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday",
+    ]
+    _strptime.calendar.month_abbr = [
+        "",
+        "jan",
+        "feb",
+        "mar",
+        "apr",
+        "may",
+        "jun",
+        "jul",
+        "aug",
+        "sep",
+        "oct",
+        "nov",
+        "dec",
+    ]
+    _strptime.calendar.month_name = [
+        "",
+        "january",
+        "february",
+        "march",
+        "april",
+        "may",
+        "june",
+        "july",
+        "august",
+        "september",
+        "october",
+        "november",
+        "december",
+    ]
+
+    return _strptime._strptime_time
+
+
+__strptime = patch_strptime()
+
+
+def strptime(date_string, format):
+    obj = datetime(*__strptime(date_string, format)[:-3])
+
+    if "%f" in format:
+        try:
+            match_groups = TIME_MATCHER.match(date_string).groupdict()
+            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()
+            ms = match_groups["microsecond"]
+            ms = ms + ((6 - len(ms)) * "0")
+            obj = obj.replace(microsecond=int(ms))
+
+    return obj

dateparser-1.2.1.dist-info/AUTHORS.rst

@@ -0,0 +1,17 @@
+=======
+Credits
+=======
+
+Currently, more than 100 committers have contributed to this project, making this
+contributors list really hard to maintain, so we have decided to stop updating
+this list.
+
+To see the people behind this code, you can run ``git shortlog -s -n`` or visit the
+contributions section in Github: https://github.com/scrapinghub/dateparser/graphs/contributors
+
+We really appreciate **all the people that has contributed to this project with their
+time and ideas**. Special mention to **Waqas Shabir** (waqasshabbir), **Eugene Amirov**
+(Allactaga) and **Artur Sadurski** (asadurski) for creating and maintaining this awesome
+project.
+
+To all of you... thank you for building and improving this!

dateparser-1.2.1.dist-info/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2014, Scrapinghub
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of DateParser nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.