LanguagesSetting.get_fallback_languages() - Code Metrics - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

LanguagesSetting.get_fallback_languages() A
last analyzed 2016-06-17 16:03 UTC

↳ Parent: LanguagesSetting

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	8
c	1
b	0
f	0
rs	9.4285
cc	1

"""
The configuration wrappers that are used for :ref:`PARLER_LANGUAGES`.
"""

import copy
import sys

from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.utils import six
from django.utils.translation import get_language
from parler.utils.i18n import is_supported_django_language, get_null_language_error


def add_default_language_settings(languages_list, var_name='PARLER_LANGUAGES', **extra_defaults):
    """
    Apply extra defaults to the language settings.
    This function can also be used by other packages to
    create their own variation of ``PARLER_LANGUAGES`` with extra fields.
    For example::

        from django.conf import settings
        from parler import appsettings as parler_appsettings

        # Create local names, which are based on the global parler settings
        MYAPP_DEFAULT_LANGUAGE_CODE = getattr(settings, 'MYAPP_DEFAULT_LANGUAGE_CODE', parler_appsettings.PARLER_DEFAULT_LANGUAGE_CODE)
        MYAPP_LANGUAGES = getattr(settings, 'MYAPP_LANGUAGES', parler_appsettings.PARLER_LANGUAGES)

        # Apply the defaults to the languages
        MYAPP_LANGUAGES = parler_appsettings.add_default_language_settings(MYAPP_LANGUAGES, 'MYAPP_LANGUAGES',
            code=MYAPP_DEFAULT_LANGUAGE_CODE,
            fallback=MYAPP_DEFAULT_LANGUAGE_CODE,
            hide_untranslated=False
        )

    The returned object will be an :class:`~parler.utils.conf.LanguagesSetting` object,
    which adds additional methods to the :class:`dict` object.

    :param languages_list: The settings, in :ref:`PARLER_LANGUAGES` format.
    :param var_name: The name of your variable, for debugging output.
    :param extra_defaults: Any defaults to override in the ``languages_list['default']`` section, e.g. ``code``, ``fallback``, ``hide_untranslated``.
    :return: The updated ``languages_list`` with all defaults applied to all sections.
    :rtype: LanguagesSetting
    """
    languages_list = LanguagesSetting(languages_list)

    languages_list.setdefault('default', {})
    defaults = languages_list['default']
    defaults.setdefault('hide_untranslated', False)   # Whether queries with .active_translations() may or may not return the fallback language.

    if 'fallback' in defaults:
        #warnings.warn("Please use 'fallbacks' instead of 'fallback' in the 'defaults' section of {0}".format(var_name), DeprecationWarning)
        defaults['fallbacks'] = [defaults.pop('fallback')]
    if 'fallback' in extra_defaults:
        #warnings.warn("Please use 'fallbacks' instead of 'fallback' in parameters for {0} = add_default_language_settings(..)".format(var_name), DeprecationWarning)
        extra_defaults['fallbacks'] = [extra_defaults.pop('fallback')]

    defaults.update(extra_defaults)  # Also allow to override code and fallback this way.

    # This function previously existed in appsettings, where it could reference the defaults directly.
    # However, this module is a more logical place for this function. To avoid circular import problems,
    # the 'code' and 'fallback' parameters are always passed by the appsettings module.
    # In case these are missing, default to the original behavior for backwards compatibility.
    if 'code' not in defaults:
        from parler import appsettings
        defaults['code'] = appsettings.PARLER_DEFAULT_LANGUAGE_CODE
    if 'fallbacks' not in defaults:
        from parler import appsettings
        defaults['fallbacks'] = [appsettings.PARLER_DEFAULT_LANGUAGE_CODE]

    if not is_supported_django_language(defaults['code']):
        raise ImproperlyConfigured("The value for {0}['defaults']['code'] ('{1}') does not exist in LANGUAGES".format(var_name, defaults['code']))

    for site_id, lang_choices in six.iteritems(languages_list):
        if site_id == 'default':
            continue

        if not isinstance(lang_choices, (list, tuple)):
            raise ImproperlyConfigured("{0}[{1}] should be a tuple of language choices!".format(var_name, site_id))
        for i, choice in enumerate(lang_choices):
            if not is_supported_django_language(choice['code']):
                raise ImproperlyConfigured("{0}[{1}][{2}]['code'] does not exist in LANGUAGES".format(var_name, site_id, i))

            # Copy all items from the defaults, so you can provide new fields too.
            for key, value in six.iteritems(defaults):
                choice.setdefault(key, value)

    return languages_list


class LanguagesSetting(dict):
    """
    This is the actual object type of the :ref:`PARLER_LANGUAGES` setting.
    Besides the regular :class:`dict` behavior, it also adds some additional methods.
    """

    def get_language(self, language_code, site_id=None):
        """
        Return the language settings for the current site

        This function can be used with other settings variables
        to support modules which create their own variation of the ``PARLER_LANGUAGES`` setting.
        For an example, see :func:`~parler.appsettings.add_default_language_settings`.
        """
        if language_code is None:
            raise ValueError(get_null_language_error())

        if site_id is None:
            site_id = getattr(settings, 'SITE_ID', None)

        for lang_dict in self.get(site_id, ()):
            if lang_dict['code'] == language_code:
                return lang_dict

        # no language match, search for variant: fr-ca falls back to fr
        for lang_dict in self.get(site_id, ()):
            if lang_dict['code'].split('-')[0] == language_code.split('-')[0]:
                return lang_dict

        return self['default']

    def get_active_choices(self, language_code=None, site_id=None):
        """
        Find out which translations should be visible in the site.
        It returns a list with either a single choice (the current language),
        or a list with the current language + fallback language.
        """
        if language_code is None:
            language_code = get_language()

        lang_dict = self.get_language(language_code, site_id=site_id)
        if not lang_dict['hide_untranslated']:
            return [language_code] + [lang for lang in lang_dict['fallbacks'] if lang != language_code]
        else:
            return [language_code]

    def get_fallback_languages(self, language_code=None, site_id=None):
        """
        Find out what the fallback language is for a given language choice.

        .. versionadded 1.5
        """
        choices = self.get_active_choices(language_code, site_id=site_id)
        return choices[1:]

    def get_fallback_language(self, language_code=None, site_id=None):
        """
        Find out what the fallback language is for a given language choice.

        .. deprecated:: 1.5
           Use :func:`get_fallback_languages` instead.
        """
        choices = self.get_active_choices(language_code, site_id=site_id)
        if choices and len(choices) > 1:
            # Still take the last, like previous code.
            # With multiple fallback languages that means taking the base language.
            # Hence, upgrade the code to use get_fallback_languages() instead.
            return choices[-1]
        else:
            return None

    def get_default_language(self):
        """
        Return the default language.
        """
        return self['default']['code']

    def get_first_language(self, site_id=None):
        """
        Return the first language for the current site.
        This can be used for user interfaces, where the languages are displayed in tabs.
        """
        if site_id is None:
            site_id = getattr(settings, 'SITE_ID', None)

        try:
            return self[site_id][0]['code']
        except (KeyError, IndexError):
            # No configuration, always fallback to default language.
            # This is essentially a non-multilingual configuration.
            return self['default']['code']


def get_parler_languages_from_django_cms(cms_languages=None):
    """
    Converts django CMS' setting CMS_LANGUAGES into PARLER_LANGUAGES. Since
    CMS_LANGUAGES is a strict superset of PARLER_LANGUAGES, we do a bit of
    cleansing to remove irrelevant items.
    """
    valid_keys = ['code', 'fallbacks', 'hide_untranslated',
                  'redirect_on_fallback']
    if cms_languages:
        if sys.version_info < (3, 0, 0):
            int_types = (int, long)
        else:
            int_types = int

        parler_languages = copy.deepcopy(cms_languages)
        for site_id, site_config in cms_languages.items():
            if site_id and (
                    not isinstance(site_id, int_types) and
                    site_id != 'default'
            ):
                del parler_languages[site_id]
                continue

            if site_id == 'default':
                for key, value in site_config.items():
                    if key not in valid_keys:
                        del parler_languages['default'][key]
            else:
                for i, lang_config in enumerate(site_config):
                    for key, value in lang_config.items():
                        if key not in valid_keys:
                            del parler_languages[site_id][i][key]
        return parler_languages
    return None


1			"""
2			The configuration wrappers that are used for :ref:`PARLER_LANGUAGES`.
3			"""
4
5			import copy
6			import sys
7
8			from django.conf import settings
9			from django.core.exceptions import ImproperlyConfigured
10			from django.utils import six
11			from django.utils.translation import get_language
12			from parler.utils.i18n import is_supported_django_language, get_null_language_error
13
14
15			def add_default_language_settings(languages_list, var_name='PARLER_LANGUAGES', **extra_defaults):
16			"""
17			Apply extra defaults to the language settings.
18			This function can also be used by other packages to
19			create their own variation of ``PARLER_LANGUAGES`` with extra fields.
20			For example::
21
22			from django.conf import settings
23			from parler import appsettings as parler_appsettings
24
25			# Create local names, which are based on the global parler settings
26			MYAPP_DEFAULT_LANGUAGE_CODE = getattr(settings, 'MYAPP_DEFAULT_LANGUAGE_CODE', parler_appsettings.PARLER_DEFAULT_LANGUAGE_CODE)
27			MYAPP_LANGUAGES = getattr(settings, 'MYAPP_LANGUAGES', parler_appsettings.PARLER_LANGUAGES)
28
29			# Apply the defaults to the languages
30			MYAPP_LANGUAGES = parler_appsettings.add_default_language_settings(MYAPP_LANGUAGES, 'MYAPP_LANGUAGES',
31			code=MYAPP_DEFAULT_LANGUAGE_CODE,
32			fallback=MYAPP_DEFAULT_LANGUAGE_CODE,
33			hide_untranslated=False
34			)
35
36			The returned object will be an :class:`~parler.utils.conf.LanguagesSetting` object,
37			which adds additional methods to the :class:`dict` object.
38
39			:param languages_list: The settings, in :ref:`PARLER_LANGUAGES` format.
40			:param var_name: The name of your variable, for debugging output.
41			:param extra_defaults: Any defaults to override in the ``languages_list['default']`` section, e.g. ``code``, ``fallback``, ``hide_untranslated``.
42			:return: The updated ``languages_list`` with all defaults applied to all sections.
43			:rtype: LanguagesSetting
44			"""
45			languages_list = LanguagesSetting(languages_list)
46
47			languages_list.setdefault('default', {})
48			defaults = languages_list['default']
49			defaults.setdefault('hide_untranslated', False) # Whether queries with .active_translations() may or may not return the fallback language.
50
51			if 'fallback' in defaults:
52			#warnings.warn("Please use 'fallbacks' instead of 'fallback' in the 'defaults' section of {0}".format(var_name), DeprecationWarning)
53			defaults['fallbacks'] = [defaults.pop('fallback')]
54			if 'fallback' in extra_defaults:
55			#warnings.warn("Please use 'fallbacks' instead of 'fallback' in parameters for {0} = add_default_language_settings(..)".format(var_name), DeprecationWarning)
56			extra_defaults['fallbacks'] = [extra_defaults.pop('fallback')]
57
58			defaults.update(extra_defaults) # Also allow to override code and fallback this way.
59
60			# This function previously existed in appsettings, where it could reference the defaults directly.
61			# However, this module is a more logical place for this function. To avoid circular import problems,
62			# the 'code' and 'fallback' parameters are always passed by the appsettings module.
63			# In case these are missing, default to the original behavior for backwards compatibility.
64			if 'code' not in defaults:
65			from parler import appsettings
66			defaults['code'] = appsettings.PARLER_DEFAULT_LANGUAGE_CODE
67			if 'fallbacks' not in defaults:
68			from parler import appsettings
69			defaults['fallbacks'] = [appsettings.PARLER_DEFAULT_LANGUAGE_CODE]
70
71			if not is_supported_django_language(defaults['code']):
72			raise ImproperlyConfigured("The value for {0}['defaults']['code'] ('{1}') does not exist in LANGUAGES".format(var_name, defaults['code']))
73
74			for site_id, lang_choices in six.iteritems(languages_list):
75			if site_id == 'default':
76			continue
77
78			if not isinstance(lang_choices, (list, tuple)):
79			raise ImproperlyConfigured("{0}[{1}] should be a tuple of language choices!".format(var_name, site_id))
80			for i, choice in enumerate(lang_choices):
81			if not is_supported_django_language(choice['code']):
82			raise ImproperlyConfigured("{0}[{1}][{2}]['code'] does not exist in LANGUAGES".format(var_name, site_id, i))
83
84			# Copy all items from the defaults, so you can provide new fields too.
85			for key, value in six.iteritems(defaults):
86			choice.setdefault(key, value)
87
88			return languages_list
89
90
91			class LanguagesSetting(dict):
92			"""
93			This is the actual object type of the :ref:`PARLER_LANGUAGES` setting.
94			Besides the regular :class:`dict` behavior, it also adds some additional methods.
95			"""
96
97			def get_language(self, language_code, site_id=None):
98			"""
99			Return the language settings for the current site
100
101			This function can be used with other settings variables
102			to support modules which create their own variation of the ``PARLER_LANGUAGES`` setting.
103			For an example, see :func:`~parler.appsettings.add_default_language_settings`.
104			"""
105			if language_code is None:
106			raise ValueError(get_null_language_error())
107
108			if site_id is None:
109			site_id = getattr(settings, 'SITE_ID', None)
110
111			for lang_dict in self.get(site_id, ()):
112			if lang_dict['code'] == language_code:
113			return lang_dict
114
115			# no language match, search for variant: fr-ca falls back to fr
116			for lang_dict in self.get(site_id, ()):
117			if lang_dict['code'].split('-')[0] == language_code.split('-')[0]:
118			return lang_dict
119
120			return self['default']
121
122			def get_active_choices(self, language_code=None, site_id=None):
123			"""
124			Find out which translations should be visible in the site.
125			It returns a list with either a single choice (the current language),
126			or a list with the current language + fallback language.
127			"""
128			if language_code is None:
129			language_code = get_language()
130
131			lang_dict = self.get_language(language_code, site_id=site_id)
132			if not lang_dict['hide_untranslated']:
133			return [language_code] + [lang for lang in lang_dict['fallbacks'] if lang != language_code]
134			else:
135			return [language_code]
136
137			def get_fallback_languages(self, language_code=None, site_id=None):
138			"""
139			Find out what the fallback language is for a given language choice.
140
141			.. versionadded 1.5
142			"""
143			choices = self.get_active_choices(language_code, site_id=site_id)
144			return choices[1:]
145
146			def get_fallback_language(self, language_code=None, site_id=None):
147			"""
148			Find out what the fallback language is for a given language choice.
149
150			.. deprecated:: 1.5
151			Use :func:`get_fallback_languages` instead.
152			"""
153			choices = self.get_active_choices(language_code, site_id=site_id)
154			if choices and len(choices) > 1:
155			# Still take the last, like previous code.
156			# With multiple fallback languages that means taking the base language.
157			# Hence, upgrade the code to use get_fallback_languages() instead.
158			return choices[-1]
159			else:
160			return None
161
162			def get_default_language(self):
163			"""
164			Return the default language.
165			"""
166			return self['default']['code']
167
168			def get_first_language(self, site_id=None):
169			"""
170			Return the first language for the current site.
171			This can be used for user interfaces, where the languages are displayed in tabs.
172			"""
173			if site_id is None:
174			site_id = getattr(settings, 'SITE_ID', None)
175
176			try:
177			return self[site_id][0]['code']
178			except (KeyError, IndexError):
179			# No configuration, always fallback to default language.
180			# This is essentially a non-multilingual configuration.
181			return self['default']['code']
182
183
184			def get_parler_languages_from_django_cms(cms_languages=None):
185			"""
186			Converts django CMS' setting CMS_LANGUAGES into PARLER_LANGUAGES. Since
187			CMS_LANGUAGES is a strict superset of PARLER_LANGUAGES, we do a bit of
188			cleansing to remove irrelevant items.
189			"""
190			valid_keys = ['code', 'fallbacks', 'hide_untranslated',
191			'redirect_on_fallback']
192			if cms_languages:
193			if sys.version_info < (3, 0, 0):
194			int_types = (int, long)
195			else:
196			int_types = int
197
198			parler_languages = copy.deepcopy(cms_languages)
199			for site_id, site_config in cms_languages.items():
200			if site_id and (
201			not isinstance(site_id, int_types) and
202			site_id != 'default'
203			):
204			del parler_languages[site_id]
205			continue
206
207			if site_id == 'default':
208			for key, value in site_config.items():
209			if key not in valid_keys:
210			del parler_languages['default'][key]
211			else:
212			for i, lang_config in enumerate(site_config):
213			for key, value in lang_config.items():
214			if key not in valid_keys:
215			del parler_languages[site_id][i][key]
216			return parler_languages
217			return None
218

edoburu / django-parler

LanguagesSetting.get_fallback_languages() A last analyzed 2016-06-17 16:03 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

LanguagesSetting.get_fallback_languages() A
last analyzed 2016-06-17 16:03 UTC