parler.utils.LanguagesSetting.get_default_language() - Code Metrics - Inspection of "Merge pull request #110 from tanyunshi/fix_unorder..." - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3a0699...a6fb63 )

by Diederik van der

created 2015-12-16 12:34 UTC

get_default_language() A

↳ Parent: parler.utils.LanguagesSetting

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	1
dl	0
loc	5
rs	9.4286

"""
The configuration wrappers that are used for :ref:`PARLER_LANGUAGES`.
"""
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
import warnings


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 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

        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']


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

edoburu / django-parler

Push — master ( 3a0699...a6fb63 )

get_default_language() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like