dateparser 1.2.1__py3-none-any.whl

dateparser/languages/loader.py

@@ -0,0 +1,224 @@
+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()