parler.TranslatedFieldDescriptor.__get__() - Code Metrics - Inspection of "Fix Django 1.9 warnings that will break in Django..." - edoburu/django-parler - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e685ff...828b34 )

by Diederik van der

created 2016-02-26 15:39 UTC

parler.TranslatedFieldDescriptor.get() B

↳ Parent: parler.TranslatedFieldDescriptor

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
cc	5
dl	0
loc	21
rs	8.439

"""
All fields that are attached to the models.

The core design of django-parler is to attach descriptor fields
to the shared model, which then proxies the get/set calls to the translated model.

The :class:`TranslatedField` objects are automatically added to the shared model,
but may be added explicitly as well. This also allows to set the ``any_language`` configuration option.
It's also useful for abstract models; add a :class:`TranslatedField` to
indicate that the derived model is expected to provide that translatable field.
"""
from __future__ import unicode_literals

import django
from django.forms.forms import pretty_name


# TODO: inherit RelatedField?
class TranslatedField(object):
    """
    Proxy field attached to a model.

    The field is automatically added to the shared model.
    However, this can be assigned manually to be more explicit, or to pass the ``any_language`` value.
    The ``any_language=True`` option causes the attribute to always return a translated value,
    even when the current language and fallback are missing.
    This can be useful for "title" attributes for example.

    Example:

    .. code-block:: python

        from django.db import models
        from parler.models import TranslatableModel, TranslatedFieldsModel

        class MyModel(TranslatableModel):
            title = TranslatedField(any_language=True)  # Add with any-fallback support
            slug = TranslatedField()                    # Optional, but explicitly mentioned


        class MyModelTranslation(TranslatedFieldsModel):
            # Manual model class:
            master = models.ForeignKey(MyModel, related_name='translations', null=True)
            title = models.CharField("Title", max_length=200)
            slug = models.SlugField("Slug")
    """

    def __init__(self, any_language=False):
        self.model = None
        self.name = None
        self.any_language = any_language
        self._meta = None

    def contribute_to_class(self, cls, name):
        #super(TranslatedField, self).contribute_to_class(cls, name)
        self.model = cls
        self.name = name

        # Add the proxy attribute
        setattr(cls, self.name, TranslatedFieldDescriptor(self))

    @property
    def meta(self):
        if self._meta is None:
            self._meta = self.model._parler_meta._get_extension_by_field(self.name)
        return self._meta


class TranslatedFieldDescriptor(object):
    """
    Descriptor for translated attributes.

    This attribute proxies all get/set calls to the translated model.
    """

    def __init__(self, field):
        """
        :type field: TranslatedField
        """
        self.field = field

    def __get__(self, instance, instance_type=None):
        if not instance:
            # Return the class attribute when asked for by the admin.
            return self

        # Auto create is useless for __get__, will return empty titles everywhere.
        # Better use a fallback instead, just like gettext does.
        translation = None
        meta = self.field.meta
        try:
            translation = instance._get_translated_model(use_fallback=True, meta=meta)
        except meta.model.DoesNotExist as e:
            if self.field.any_language:
                translation = instance._get_any_translated_model(meta=meta)  # returns None on error.

            if translation is None:
                # Improve error message
                e.args = ("{1}\nAttempted to read attribute {0}.".format(self.field.name, e.args[0]),)
                raise

        return getattr(translation, self.field.name)

    def __set__(self, instance, value):
        if instance is None:
            raise AttributeError("{0} must be accessed via instance".format(self.field.opts.object_name))

        # When assigning the property, assign to the current language.
        # No fallback is used in this case.
        translation = instance._get_translated_model(use_fallback=False, auto_create=True, meta=self.field.meta)
        setattr(translation, self.field.name, value)

    def __delete__(self, instance):
        # No autocreate or fallback, as this is delete.
        # Rather blow it all up when the attribute doesn't exist.
        # Similar to getting a KeyError on `del dict['UNKNOWN_KEY']`
        translation = instance._get_translated_model(meta=self.field.meta)
        delattr(translation, self.field.name)

    def __repr__(self):
        return "<{0} for {1}.{2}>".format(self.__class__.__name__, self.field.model.__name__, self.field.name)

    @property
    def short_description(self):
        """
        Ensure that the admin ``list_display`` renders the correct verbose name for translated fields.

        The :func:`~django.contrib.admin.utils.label_for_field` function
        uses :func:`~django.db.models.Options.get_field_by_name` to find the find and ``verbose_name``.
        However, for translated fields, this option does not exist,
        hence it falls back to reading the attribute and trying ``short_description``.
        Ideally, translated fields should also appear in this list, to be treated like regular fields.
        """
        translations_model = self.field.meta.model
        if translations_model is None:
            # This only happens with abstract models. The code is accessing the descriptor at the base model directly,
            # not the upgraded descriptor version that contribute_translations() installed.
            # Fallback to what the admin label_for_field() would have done otherwise.
            return pretty_name(self.field.name)

        if django.VERSION >= (1, 8):
            field = translations_model._meta.get_field(self.field.name)
        else:
            field = translations_model._meta.get_field_by_name(self.field.name)[0]

        return field.verbose_name


class LanguageCodeDescriptor(object):
    """
    This is the property to access the ``language_code`` in the ``TranslatableModel``.
    """

    def __get__(self, instance, instance_type=None):
        if not instance:
            raise AttributeError("language_code must be accessed via instance")

        return instance._current_language

    def __set__(self, instance, value):
        raise AttributeError("The 'language_code' attribute cannot be changed directly! Use the set_current_language() method instead.")

    def __delete__(self, instance):
        raise AttributeError("The 'language_code' attribute cannot be deleted!")


try:
    from south.modelsinspector import add_ignored_fields
except ImportError:
    pass
else:
    _name_re = "^" + __name__.replace(".", "\.")
    add_ignored_fields((
        _name_re + "\.TranslatedField",
    ))


1			"""
2			All fields that are attached to the models.
3
4			The core design of django-parler is to attach descriptor fields
5			to the shared model, which then proxies the get/set calls to the translated model.
6
7			The :class:`TranslatedField` objects are automatically added to the shared model,
8			but may be added explicitly as well. This also allows to set the ``any_language`` configuration option.
9			It's also useful for abstract models; add a :class:`TranslatedField` to
10			indicate that the derived model is expected to provide that translatable field.
11			"""
12			from __future__ import unicode_literals
13
14			import django
15			from django.forms.forms import pretty_name
16
17
18			# TODO: inherit RelatedField?
19			class TranslatedField(object):
20			"""
21			Proxy field attached to a model.
22
23			The field is automatically added to the shared model.
24			However, this can be assigned manually to be more explicit, or to pass the ``any_language`` value.
25			The ``any_language=True`` option causes the attribute to always return a translated value,
26			even when the current language and fallback are missing.
27			This can be useful for "title" attributes for example.
28
29			Example:
30
31			.. code-block:: python
32
33			from django.db import models
34			from parler.models import TranslatableModel, TranslatedFieldsModel
35
36			class MyModel(TranslatableModel):
37			title = TranslatedField(any_language=True) # Add with any-fallback support
38			slug = TranslatedField() # Optional, but explicitly mentioned
39
40
41			class MyModelTranslation(TranslatedFieldsModel):
42			# Manual model class:
43			master = models.ForeignKey(MyModel, related_name='translations', null=True)
44			title = models.CharField("Title", max_length=200)
45			slug = models.SlugField("Slug")
46			"""
47
48			def __init__(self, any_language=False):
49			self.model = None
50			self.name = None
51			self.any_language = any_language
52			self._meta = None
53
54			def contribute_to_class(self, cls, name):
55			#super(TranslatedField, self).contribute_to_class(cls, name)
56			self.model = cls
57			self.name = name
58
59			# Add the proxy attribute
60			setattr(cls, self.name, TranslatedFieldDescriptor(self))
61
62			@property
63			def meta(self):
64			if self._meta is None:
65			self._meta = self.model._parler_meta._get_extension_by_field(self.name)
66			return self._meta
67
68
69			class TranslatedFieldDescriptor(object):
70			"""
71			Descriptor for translated attributes.
72
73			This attribute proxies all get/set calls to the translated model.
74			"""
75
76			def __init__(self, field):
77			"""
78			:type field: TranslatedField
79			"""
80			self.field = field
81
82			def __get__(self, instance, instance_type=None):
83			if not instance:
84			# Return the class attribute when asked for by the admin.
85			return self
86
87			# Auto create is useless for __get__, will return empty titles everywhere.
88			# Better use a fallback instead, just like gettext does.
89			translation = None
90			meta = self.field.meta
91			try:
92			translation = instance._get_translated_model(use_fallback=True, meta=meta)
93			except meta.model.DoesNotExist as e:
94			if self.field.any_language:
95			translation = instance._get_any_translated_model(meta=meta) # returns None on error.
96
97			if translation is None:
98			# Improve error message
99			e.args = ("{1}\nAttempted to read attribute {0}.".format(self.field.name, e.args[0]),)
100			raise
101
102			return getattr(translation, self.field.name)
103
104			def __set__(self, instance, value):
105			if instance is None:
106			raise AttributeError("{0} must be accessed via instance".format(self.field.opts.object_name))
107
108			# When assigning the property, assign to the current language.
109			# No fallback is used in this case.
110			translation = instance._get_translated_model(use_fallback=False, auto_create=True, meta=self.field.meta)
111			setattr(translation, self.field.name, value)
112
113			def __delete__(self, instance):
114			# No autocreate or fallback, as this is delete.
115			# Rather blow it all up when the attribute doesn't exist.
116			# Similar to getting a KeyError on `del dict['UNKNOWN_KEY']`
117			translation = instance._get_translated_model(meta=self.field.meta)
118			delattr(translation, self.field.name)
119
120			def __repr__(self):
121			return "<{0} for {1}.{2}>".format(self.__class__.__name__, self.field.model.__name__, self.field.name)
122
123			@property
124			def short_description(self):
125			"""
126			Ensure that the admin ``list_display`` renders the correct verbose name for translated fields.
127
128			The :func:`~django.contrib.admin.utils.label_for_field` function
129			uses :func:`~django.db.models.Options.get_field_by_name` to find the find and ``verbose_name``.
130			However, for translated fields, this option does not exist,
131			hence it falls back to reading the attribute and trying ``short_description``.
132			Ideally, translated fields should also appear in this list, to be treated like regular fields.
133			"""
134			translations_model = self.field.meta.model
135			if translations_model is None:
136			# This only happens with abstract models. The code is accessing the descriptor at the base model directly,
137			# not the upgraded descriptor version that contribute_translations() installed.
138			# Fallback to what the admin label_for_field() would have done otherwise.
139			return pretty_name(self.field.name)
140
141			if django.VERSION >= (1, 8):
142			field = translations_model._meta.get_field(self.field.name)
143			else:
144			field = translations_model._meta.get_field_by_name(self.field.name)[0]
145
146			return field.verbose_name
147
148
149			class LanguageCodeDescriptor(object):
150			"""
151			This is the property to access the ``language_code`` in the ``TranslatableModel``.
152			"""
153
154			def __get__(self, instance, instance_type=None):
155			if not instance:
156			raise AttributeError("language_code must be accessed via instance")
157
158			return instance._current_language
159
160			def __set__(self, instance, value):
161			raise AttributeError("The 'language_code' attribute cannot be changed directly! Use the set_current_language() method instead.")
162
163			def __delete__(self, instance):
164			raise AttributeError("The 'language_code' attribute cannot be deleted!")
165
166
167			try:
168			from south.modelsinspector import add_ignored_fields
169			except ImportError:
170			pass
171			else:
172			_name_re = "^" + __name__.replace(".", "\.")
173			add_ignored_fields((
174			_name_re + "\.TranslatedField",
175			))
176

edoburu / django-parler

Push — master ( e685ff...828b34 )

parler.TranslatedFieldDescriptor.__get__() B

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like

parler.TranslatedFieldDescriptor.get() B