dateparser.languages.loader — DateParser 1.2.1 documentation

# Source code for dateparser.languages.loader

    from collections import OrderedDict
    from copy import deepcopy
    from importlib import import_module
    from itertools import zip_longest

    import regex as re

    from ..data import language_locale_dict, language_order
    from .locale import Locale

    LOCALE_SPLIT_PATTERN = re.compile(r"-(?=[A-Z0-9]+$)")

    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

    def _filter_valid_locales(locales):
        return [locale for locale in locales if _isvalidlocale(locale)]

    def _construct_locales(languages, region):
        if region:
            possible_locales = [language + "-" + region for language in languages]
            locales = _filter_valid_locales(possible_locales)
        else:
            locales = languages
        return locales

    class LocaleDataLoader:
        """Class that handles loading of locale instances."""

        _loaded_languages = {}
        _loaded_locales = {}

        def get_locale_map(
            self,
            languages=None,
            locales=None,
            region=None,
            use_given_order=False,
            allow_conflicting_locales=False,
        ):
            """
            Get an ordered mapping with locale codes as keys
            and corresponding locale instances as values.

            :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 to load.
            :type languages: list

            :param locales:
                A list of codes of locales which are to be loaded,
                e.g. ['fr-PF', 'qu-EC', 'af-NA']
            :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 to load.
            :type region: str

            :param use_given_order:
                If True, the returned mapping is ordered in the order locales are given.
            :type use_given_order: bool

            :param allow_conflicting_locales:
                if True, locales with same language and different region can be loaded.
            :type allow_conflicting_locales: bool

            :return: ordered locale code to locale instance mapping
            """
            return OrderedDict(
                self._load_data(
                    languages=languages,
                    locales=locales,
                    region=region,
                    use_given_order=use_given_order,
                    allow_conflicting_locales=allow_conflicting_locales,
                )
            )

        def get_locales(
            self,
            languages=None,
            locales=None,
            region=None,
            use_given_order=False,
            allow_conflicting_locales=False,
        ):
            """
            Yield locale instances.

            :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 to load.
            :type languages: list

            :param locales:
                A list of codes of locales which are to be loaded,
                e.g. ['fr-PF', 'qu-EC', 'af-NA']
            :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 to load.
            :type region: str

            :param use_given_order:
                If True, the returned mapping is ordered in the order locales are given.
            :type use_given_order: bool

            :param allow_conflicting_locales:
                if True, locales with same language and different region can be loaded.
            :type allow_conflicting_locales: bool

            :yield: locale instances
            """
            for _, locale in self._load_data(
                languages=languages,
                locales=locales,
                region=region,
                use_given_order=use_given_order,
                allow_conflicting_locales=allow_conflicting_locales,
            ):
                yield locale

        def get_locale(self, shortname):
            """
            Get a locale instance.

            :param shortname:
                A locale code, e.g. 'fr-PF', 'qu-EC', 'af-NA'.
            :type shortname: str

            :return: locale instance
            """
            return list(self.get_locales(locales=[shortname]))[0]

        def _load_data(
            self,
            languages=None,
            locales=None,
            region=None,
            use_given_order=False,
            allow_conflicting_locales=False,
        ):
            locale_dict = OrderedDict()
            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)
                    if not _isvalidlocale(locale):
                        invalid_locales.append(locale)
                if invalid_locales:
                    raise ValueError(
                        "Unknown locale(s): %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"
                        )

            else:
                if languages is None:
                    languages = language_order
                unsupported_languages = set(languages) - set(language_order)
                if unsupported_languages:
                    raise ValueError(
                        "Unknown language(s): %s"
                        % ", ".join(map(repr, unsupported_languages))
                    )
                if region is None:
                    region = ""
                locales = _construct_locales(languages, region)
                locale_dict.update(
                    zip_longest(
                        locales, tuple(zip_longest(languages, [], fillvalue=region))
                    )
                )

            if not use_given_order:
                locale_dict = OrderedDict(
                    sorted(locale_dict.items(), key=lambda x: language_order.index(x[1][0]))
                )

            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
                        self._loaded_locales[shortname] = locale
                yield shortname, self._loaded_locales[shortname]

    default_loader = LocaleDataLoader()