Move hvad settings to HVAD dict, and add settings for basic customizable behaviors.

Author: spectras

docs/public/release_notes.rst

@@ -12,8 +12,27 @@ Python and Django versions supported:
 - So, as a reminder, supported Django versions for this release are:
   1.8 LTS, 1.9, 1.10.x (for x ≥ 1).
 
+New features:
+
+- Automatic loading of translations on attribute access can now be disabled,
+  by setting ``HVAD["AUTOLOAD_TRANSLATIONS"]`` to ``False``. This will prevent
+  hvad from initiating database queries. Accessing translatable attributes with
+  no translation loaded will then raise an :exc:`~exceptions.AttributeError`.
+- It is possible to automatically install :class:`~hvad.manager.TranslationQueryset`
+  as the default queryset for all translatable models, by setting
+  ``HVAD["USE_DEFAULT_QUERYSET"]`` to ``True``. Specifically, it changes
+  :attr:`~hvad.manager.TranslationManager.default_class` to be a
+  :class:`~hvad.manager.TranslationQueryset` instead of a
+  :class:`~django.db.models.query.QuerySet`.
+  See the section about
+  :ref:`overriding the default queryset <override-default-queryset>`
+  for advantages and caveats of doing so.
+
 Compatibility warnings:
 
+- All settings have been moved to a unique ``HVAD`` dictionary. Please update
+  your django settings accordingly.
+
 - Deprecated class :class:`~ hvad.manager.FallbackQueryset` has been removed.
   Using it along with
   :meth:`FallbackQueryset.use_fallbacks() <hvad.manager.FallbackQueryset.use_fallbacks>`

hvad/admin.py

@@ -1,7 +1,5 @@
 import functools
-import django
 import warnings
-from django.conf import settings
 from django.contrib.admin.options import ModelAdmin, csrf_protect_m, InlineModelAdmin
 from django.contrib.admin.utils import flatten_fieldsets, unquote, get_deleted_objects
 from django.contrib.contenttypes.models import ContentType
@@ -16,14 +14,13 @@
 from django.template.loader import select_template
 from django.utils.encoding import iri_to_uri, force_text
 from django.utils.functional import curry
-from django.utils.translation import ugettext_lazy as _, get_language
+from django.utils.translation import ugettext_lazy as _, get_language, get_language_info
 from hvad.compat import urlencode, urlparse
 from hvad.forms import TranslatableModelForm, translatable_inlineformset_factory, translatable_modelform_factory
+from hvad.settings import hvad_settings
 from hvad.utils import load_translation
-from hvad.manager import FALLBACK_LANGUAGES, TranslationQueryset
+from hvad.manager import TranslationQueryset
 
-def get_language_name(language_code):
-    return dict(settings.LANGUAGES).get(language_code, language_code)
 
 class InlineModelForm(TranslatableModelForm):
     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
@@ -84,7 +81,7 @@ def get_language_tabs(self, obj, request, available_languages):
         tabs = []
         get = request.GET.copy()
         language = self._language(request)
-        for key, name in settings.LANGUAGES:
+        for key, name in hvad_settings.LANGUAGES:
             get['language'] = key
             url = '%s?%s' % (request.path, get.urlencode())
             if language == key:
@@ -163,7 +160,7 @@ def get_form(self, request, obj=None, **kwargs):
     def render_change_form(self, request, context, add=False, change=False,
                            form_url='', obj=None):
         lang_code = self._language(request)
-        lang = get_language_name(lang_code)
+        lang = get_language_info(lang_code)['name_local']
         available_languages = self.get_available_languages(obj)
 
         context.update({
@@ -229,8 +226,7 @@ def delete_translation(self, request, object_id, language_code):
         deleted_objects, model_count, perms_needed, protected = get_deleted_objects(
             [obj], translations_model._meta, request.user, self.admin_site, using)
 
-        lang = get_language_name(language_code) 
-            
+        lang = get_language_info(language_code)['name_local']
 
         if request.POST: # The user has already confirmed the deletion.
             if perms_needed:
@@ -285,7 +281,7 @@ def deletion_not_allowed(self, request, obj, language_code):
                 'language_code': language_code,
                 'opts': opts,
                 'app_label': opts.app_label,
-                'language_name': get_language_name(language_code),
+                'language_name': get_language_info(language_code)['name_local'],
                 'object_name': force_text(opts.verbose_name),
             },
         )
@@ -328,7 +324,7 @@ def get_object(self, request, object_id, from_field=None):
 
     def get_queryset(self, request):
         language = self._language(request)
-        qs = self.model._default_manager.language(language).fallbacks(*FALLBACK_LANGUAGES)
+        qs = self.model._default_manager.language(language).fallbacks(*hvad_settings.FALLBACK_LANGUAGES)
 
         # TODO: this should be handled by some parameter to the ChangeList.
         ordering = getattr(self, 'ordering', None) or ()

hvad/descriptors.py

@@ -1,44 +1,46 @@
-from django.utils.translation import get_language
-from hvad.utils import get_translation, set_cached_translation, get_cached_translation
 from django.apps import registry
+from django.utils.translation import get_language
+from hvad.settings import hvad_settings
+from hvad.utils import get_translation, set_cached_translation
 
-
-class BaseDescriptor(object):
-    """
-    Base descriptor class with a helper to get the translations instance.
+class TranslatedAttribute(object):
+    """ Proxy descriptor, forwarding attribute access to loaded translation.
+        If no translation is loaded, it will attempt to load one depending on settings
     """
-    def __init__(self, opts):
-        self.opts = opts
+
+    def __init__(self, model, name):
+        self.translations_model = model._meta.translations_model
+        self.name = name
         self._NoTranslationError = type('NoTranslationError',
-                                        (AttributeError, opts.translations_model.DoesNotExist),
+                                        (AttributeError, model._meta.translations_model.DoesNotExist),
                                         {})
-    
+        super(TranslatedAttribute, self).__init__()
+
     def translation(self, instance):
-        translation = get_cached_translation(instance)
-        if translation is None:
+        try:
+            return getattr(instance, instance._meta.translations_cache)
+        except AttributeError:
+            pass
+
+        if hvad_settings.AUTOLOAD_TRANSLATIONS:
             try:
                 translation = get_translation(instance)
-            except self.opts.translations_model.DoesNotExist:
+            except instance._meta.translations_model.DoesNotExist:
                 raise self._NoTranslationError('Accessing a translated field requires that '
                                                'the instance has a translation loaded, or a '
                                                'valid translation in current language (%s) '
                                                'loadable from the database' % get_language())
             set_cached_translation(instance, translation)
-        return translation
-
-
-class TranslatedAttribute(BaseDescriptor):
-    """ Proxies attributes from the shared instance to the translated instance. """
-
-    def __init__(self, opts, name):
-        self.name = name
-        super(TranslatedAttribute, self).__init__(opts)
+            return translation
+        else:
+            raise AttributeError('No translation loaded and auto-loading is disabled because '
+                                 'settings.HVAD[\'AUTOLOAD_TRANSLATIONS\'] is False')
 
     def __get__(self, instance, instance_type=None):
         if not instance:
             if not registry.apps.ready: #pragma: no cover
                 raise AttributeError('Attribute not available until registry is ready.')
-            return self.opts.translations_model._meta.get_field(self.name).default
+            return self.translations_model._meta.get_field(self.name).default
         return getattr(self.translation(instance), self.name)
 
     def __set__(self, instance, value):
@@ -54,8 +56,8 @@ class LanguageCodeAttribute(TranslatedAttribute):
     be deleted. Trying to do so will always cause an attribute error.
     
     """
-    def __init__(self, opts):
-        super(LanguageCodeAttribute, self).__init__(opts, 'language_code')
+    def __init__(self, model):
+        super(LanguageCodeAttribute, self).__init__(model, 'language_code')
 
     def __set__(self, instance, value):
         raise AttributeError("The 'language_code' attribute cannot be changed directly.")

hvad/forms.py

@@ -1,4 +1,3 @@
-from django.conf import settings
 from django.core.exceptions import FieldError, ValidationError
 from django.forms.fields import CharField
 from django.forms.formsets import formset_factory
@@ -10,6 +9,7 @@
 from django.utils.translation import get_language, ugettext as _
 from hvad.compat import with_metaclass
 from hvad.models import TranslatableModel, BaseTranslationModel
+from hvad.settings import hvad_settings
 from hvad.utils import (set_cached_translation, get_cached_translation, load_translation)
 from collections import OrderedDict
 
@@ -326,7 +326,7 @@ def add_fields(self, form, index):
         if not 'language_code' in form.fields:
             form.fields['language_code'] = CharField(
                 required=True, initial=form.instance.language_code,
-                widget=Select(choices=(('', '--'),)+settings.LANGUAGES)
+                widget=Select(choices=(('', '--'),)+hvad_settings.LANGUAGES)
             )
             # Add language_code to self._meta.fields so it is included in validation stage
             try:

hvad/manager.py

@@ -1,5 +1,4 @@
 import django
-from django.conf import settings
 from django.core.exceptions import FieldError
 from django.db import connections, models, transaction, IntegrityError
 if django.VERSION >= (1, 9):
@@ -13,7 +12,8 @@
 from hvad.compat import string_types
 from hvad.query import (query_terms, q_children, expression_nodes,
                         add_alias_constraints)
-from hvad.utils import combine, settings_updater
+from hvad.settings import hvad_settings
+from hvad.utils import combine
 from copy import deepcopy
 import logging
 import sys
@@ -23,12 +23,6 @@
 # Logging-related globals
 _logger = logging.getLogger(__name__)
 
-# Global settings, wrapped so they react to SettingsOverride
-@settings_updater
-def update_settings(*args, **kwargs):
-    global FALLBACK_LANGUAGES
-    FALLBACK_LANGUAGES = tuple(code for code, name in settings.LANGUAGES)
-
 #===============================================================================
 
 class FieldTranslator(object):
@@ -463,7 +457,7 @@ def language(self, language_code=None):
 
     def fallbacks(self, *fallbacks):
         if not fallbacks:
-            self._language_fallbacks = FALLBACK_LANGUAGES
+            self._language_fallbacks = hvad_settings.FALLBACK_LANGUAGES
         elif fallbacks == (None,):
             self._language_fallbacks = None
         else:
@@ -779,7 +773,7 @@ class TranslationManager(models.Manager):
 
     queryset_class = TranslationQueryset
     fallback_class = QuerySet
-    default_class = QuerySet
+    default_class = TranslationQueryset if hvad_settings.USE_DEFAULT_QUERYSET else QuerySet
 
     def __init__(self, *args, **kwargs):
         self.queryset_class = kwargs.pop('queryset_class', self.queryset_class)

hvad/models.py

@@ -1,7 +1,6 @@
 import django
 from django.core import checks
 from django.core.exceptions import ImproperlyConfigured
-from django.conf import settings
 from django.db import models
 from django.db.models.base import ModelBase
 from django.db.models.fields import FieldDoesNotExist
@@ -10,23 +9,15 @@
 from django.utils.translation import get_language
 from hvad.descriptors import LanguageCodeAttribute, TranslatedAttribute
 from hvad.manager import TranslationManager, TranslationsModelManager
+from hvad.settings import hvad_settings
 from hvad.utils import (get_cached_translation, set_cached_translation,
-                        SmartGetFieldByName, SmartGetField, settings_updater)
+                        SmartGetFieldByName, SmartGetField)
 from hvad.compat import MethodType
 from itertools import chain
 import sys
 
 #===============================================================================
 
-# Global settings, wrapped so they react to SettingsOverride
-@settings_updater
-def update_settings(*args, **kwargs):
-    global FALLBACK_LANGUAGES, TABLE_NAME_SEPARATOR
-    FALLBACK_LANGUAGES = tuple( code for code, name in settings.LANGUAGES )
-    TABLE_NAME_SEPARATOR = getattr(settings, 'HVAD_TABLE_NAME_SEPARATOR', '_')
-
-#===============================================================================
-
 class TranslatedFields(object):
     """ Wrapper class to define translated fields on a model. """
 
@@ -146,7 +137,7 @@ def _build_meta_class(self, model, tfields):
             'managed': model._meta.managed,
             'app_label': model._meta.app_label,
             'db_table': meta.get('db_table',
-                                 '%s%stranslation' % (model._meta.db_table, TABLE_NAME_SEPARATOR)),
+                                 hvad_settings.TABLE_NAME_FORMAT % (model._meta.db_table,)),
             'default_permissions': (),
         })
 
@@ -182,12 +173,12 @@ def contribute_translations(self, model, translations_model, related_name):
             if field.name in ignore_fields:
                 continue
             if field.name == 'language_code':
-                attr = LanguageCodeAttribute(model._meta)
+                attr = LanguageCodeAttribute(model)
             else:
-                attr = TranslatedAttribute(model._meta, field.name)
+                attr = TranslatedAttribute(model, field.name)
                 attname = field.get_attname()
                 if attname and attname != field.name:
-                    setattr(model, attname, TranslatedAttribute(model._meta, attname))
+                    setattr(model, attname, TranslatedAttribute(model, attname))
             setattr(model, field.name, attr)
 
 #===============================================================================
@@ -238,8 +229,6 @@ def __init__(self, *args, **kwargs):
                 else:
                     tkwargs[key] = value
         super(TranslatableModel, self).__init__(*args, **skwargs)
-
-        # Create a translation if there are translated fields
         if tkwargs:
             tkwargs['language_code'] = tkwargs.get('language_code') or get_language()
             set_cached_translation(self, self._meta.translations_model(**tkwargs))
@@ -313,7 +302,7 @@ def lazy_translation_getter(self, name, default=None):
         translation_dict = dict((t.language_code, t) for t in translations)
 
         # see if we have the right language, or any language in fallbacks
-        for code in (get_language(), settings.LANGUAGE_CODE) + FALLBACK_LANGUAGES:
+        for code in (get_language(),) + hvad_settings.FALLBACK_LANGUAGES:
             try:
                 translation = translation_dict[code]
             except KeyError: