parler.utils.get_parler_languages_from_django_cms() - Code Metrics - Inspection of "Merge pull request #99 from mkoistinen/mkoistinen/..." - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 694f72...cd6ab8 )

by Diederik van der

created 2015-12-16 12:44 UTC

parler.utils.get_parler_languages_from_django_cms() F

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	13
dl	0
loc	34
rs	2.7716

How to fix Complexity

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


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

        # 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 parler_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
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
92			class LanguagesSetting(dict):
93			"""
94			This is the actual object type of the :ref:`PARLER_LANGUAGES` setting.
95			Besides the regular :class:`dict` behavior, it also adds some additional methods.
96			"""
97
98			def get_language(self, language_code, site_id=None):
99			"""
100			Return the language settings for the current site
101
102			This function can be used with other settings variables
103			to support modules which create their own variation of the ``PARLER_LANGUAGES`` setting.
104			For an example, see :func:`~parler.appsettings.add_default_language_settings`.
105			"""
106			if site_id is None:
107			site_id = getattr(settings, 'SITE_ID', None)
108
109			for lang_dict in self.get(site_id, ()):
110			if lang_dict['code'] == language_code:
111			return lang_dict
112
113			# no language match, search for variant: fr-ca falls back to fr
114			for lang_dict in self.get(site_id, ()):
115			if lang_dict['code'].split('-')[0] == language_code.split('-')[0]:
116			return lang_dict
117
118			return self['default']
119
120
121			def get_active_choices(self, language_code=None, site_id=None):
122			"""
123			Find out which translations should be visible in the site.
124			It returns a list with either a single choice (the current language),
125			or a list with the current language + fallback language.
126			"""
127			if language_code is None:
128			language_code = get_language()
129
130			lang_dict = self.get_language(language_code, site_id=site_id)
131			if not lang_dict['hide_untranslated']:
132			return [language_code] + [lang for lang in lang_dict['fallbacks'] if lang != language_code]
133			else:
134			return [language_code]
135
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
147			def get_fallback_language(self, language_code=None, site_id=None):
148			"""
149			Find out what the fallback language is for a given language choice.
150
151			.. deprecated:: 1.5
152			Use :func:`get_fallback_languages` instead.
153			"""
154			choices = self.get_active_choices(language_code, site_id=site_id)
155			if choices and len(choices) > 1:
156			# Still take the last, like previous code.
157			# With multiple fallback languages that means taking the base language.
158			# Hence, upgrade the code to use get_fallback_languages() instead.
159			return choices[-1]
160			else:
161			return None
162
163
164			def get_default_language(self):
165			"""
166			Return the default language.
167			"""
168			return self['default']['code']
169
170
171			def get_first_language(self, site_id=None):
172			"""
173			Return the first language for the current site.
174			This can be used for user interfaces, where the languages are displayed in tabs.
175			"""
176			if site_id is None:
177			site_id = getattr(settings, 'SITE_ID', None)
178
179			try:
180			return self[site_id][0]['code']
181			except (KeyError, IndexError):
182			# No configuration, always fallback to default language.
183			# This is essentially a non-multilingual configuration.
184			return self['default']['code']
185
186
187			def get_parler_languages_from_django_cms(cms_languages=None):
188			"""
189			Converts django CMS' setting CMS_LANGUAGES into PARLER_LANGUAGES. Since
190			CMS_LANGUAGES is a strict superset of PARLER_LANGUAGES, we do a bit of
191			cleansing to remove irrelevant items.
192			"""
193			valid_keys = ['code', 'fallbacks', 'hide_untranslated',
194			'redirect_on_fallback']
195			if cms_languages:
196			if sys.version_info < (3, 0, 0):
197			int_types = (int, long)
198			else:
199			int_types = int
200
201			parler_languages = copy.deepcopy(cms_languages)
202			for site_id, site_config in parler_languages.items():
203			if site_id and (
204			not isinstance(site_id, int_types) and
205			site_id != 'default'
206			):
207			del parler_languages[site_id]
208			continue
209
210			if site_id == 'default':
211			for key, value in site_config.items():
212			if key not in valid_keys:
213			del parler_languages['default'][key]
214			else:
215			for i, lang_config in enumerate(site_config):
216			for key, value in lang_config.items():
217			if key not in valid_keys:
218			del parler_languages[site_id][i][key]
219			return parler_languages
220			return None
221

edoburu / django-parler

Push — master ( 694f72...cd6ab8 )

parler.utils.get_parler_languages_from_django_cms() F

Complexity

Size

Duplication

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like