This module is where most of the functionality is implemented.
The default sequence for fallback languages, populates itself from settings.LANGUAGES, could possibly become a setting on it’s own at some point.
The cache mentioned in this class is the instance of the class itself, since it inherits dict.
Possibly this class is not feature complete since it does not care about multi-relation queries. It should probably use nani.fieldtranslator.translate() after the first level if it hits the Shared Model.てz
Returns the translated fieldname for key. If it’s already cached, return it from the cache, otherwise call build()
Returns the key prefixed by 'master__' if it’s a shared field, otherwise returns the key unchanged.
A mixin class for django.db.models.query.ValuesQuerySet which implements the functionality needed by TranslationQueryset.values() and TranslationQueryset.values_list().
Strips 'master__' from the key if the key starts with that string.
Iterates over the rows from the superclass iterator and calls _strip_master() on the key if the row is a dictionary.
Any method on this queryset that returns a model instance or a queryset of model instances actually returns a Translations Model which gets combined to behave like a Shared Model. While this manager is on the Shared Model, it is actually a manager for the Translations Model since the model gets switched when this queryset is instantiated from the TranslationManager.
A dictionary of django classes to nani classes to mixin when _clone() is called with an explicit klass argument.
A list of field names on the Shared Model.
The cached field translator for this manager.
The real manager of the Shared Model.
The fallback manager of the Shared Model.
The language code of this queryset.
The (real) manager of the Translations Model.
The Shared Model.
The field translator for this manager, sets _field_translator if it’s None.
Returns a list of field names on the Shared Model, sets _local_field_names if it’s None.
Translates args (django.db.models.expressions.Q objects) and kwargs (dictionary of query lookups and values) to be language aware, by prefixing fields on the Shared Model with 'master__'. Uses field_translator for the kwargs and _recurse_q() for the args. Returns a tuple of translated args and translated kwargs.
Translate a list of fieldnames by prefixing fields on the Shared Model with 'master__' using field_translator. Returns a list of translated fieldnames.
Recursively walks a django.db.models.expressions.Q object and translates it’s query lookups to be prefixed by 'master__' if they access a field on Shared Model.
Every django.db.models.expressions.Q object has an attribute django.db.models.expressions.Q.children which is either a list of other django.db.models.expressions.Q objects or a tuple where the key is the query lookup.
This method returns a new django.db.models.expressions.Q object.
Searches a django.db.models.expressions.Q object for language code lookups. If it finds a child django.db.models.expressions.Q object that defines a language code, it returns that language code if it’s not None. Used in get() to ensure a language code is defined.
For more information about django.db.models.expressions.Q objects, see _recurse_q().
Returns the language code if one was found or None.
Splits keyword arguments into two dictionaries holding the shared and translated fields.
Returns a tuple of dictionaries of shared and translated fields.
Given a django.db.models.query.QuerySet class or subclass, it checks if the class is a subclass of any class in override_classes and if so, returns a new class which mixes the initial class, the class from override_classes and TranslationQueryset. Otherwise returns the class given.
Returns a clone of this queryset but for the shared model. Does so by using _real_manager and filtering over this queryset. Returns a queryset for the Shared Model.
Specifies a language for this queryset. This sets the _language_code and filters by the language code.
If no language code is given, django.utils.translations.get_language() is called to get the current language.
Returns a queryset.
Creates a new instance using the kwargs given. If _language_code is not set and language_code is not in kwargs, it uses django.utils.translations.get_language() to get the current language and injects that into kwargs.
This causes two queries as opposed to the one by the normal queryset.
Returns the newly created (combined) instance.
Gets a single instance from this queryset using the args and kwargs given. The args and kwargs are translated using _translate_args_kwargs().
If a language code is given in the kwargs, it calls language() using the language code provided. If none is given in kwargs, it uses _find_language_code() on the django.db.models.expressions.Q objects given in args. If no args were given or they don’t contain a language code, it searches the django.db.models.sql.where.WhereNode objects on the current queryset for language codes. If none was found, it calls language() without an argument, which in turn uses django.utils.translations.get_language() to enforce a language to be used in this queryset.
Returns a (combined) instance if one can be found for the filters given, otherwise raises an appropriate exception depending on whether no or multiple objects were found.
Translates args and kwargs using _translate_args_kwargs() and calls the superclass using the new args and kwargs.
Loops through the passed aggregates and translates the fieldnames using _translate_fieldnames() and calls the superclass
Translates the fieldname (if given) using field_translator and calls the superclass.
Not implemented yet.
Deletes the Shared Model using _get_shared_query_set().
Deletes the translations (and only the translations) by first breaking their relation to the Shared Model and then calling the delete method on the superclass. This uses two queries.
Updates this queryset using kwargs. Calls _split_kwargs() to get two dictionaries holding only the shared or translated fields respectively. If translated fields are given, calls the superclass with the translated fields. If shared fields are given, uses _get_shared_query_set() to update the shared fields.
If both shared and translated fields are updated, two queries are executed, if only one of the two are given, one query is executed.
Returns the count of updated objects, which if both translated and shared fields are given is the sum of the two update calls.
Translates fields using _translated_fieldnames() and calls the superclass.
Translates fields using _translate_fieldnames() and calls the superclass.
Translates fields using _translate_fieldnames() and calls the superclass.
Not really implemented yet, but if filter_obj is an empty dictionary it just returns this queryset, since this is required to get admin to work.
Not implemented yet.
Translates fields using _translated_fieldnames() and calls the superclass.
Not implemented yet.
Not implemented yet.
Not implemented yet.
Injects _local_field_names, _field_translator, _language_code, _real_manager and _fallback_manager into kwargs. If a klass is given, calls _get_class() to get a mixed class if necessary.
Calls the superclass with the new kwargs and klass.
Manager to be used on nani.models.TranslatableModel.
The Translations Model for this manager.
Calls get_query_set() to get a queryset and calls TranslationQueryset.language() on that queryset.
Returns an instance of FallbackQueryset for this manager.
Returns an instance of TranslationQueryset for this manager. The queryset returned will have the master relation to the Shared Model marked to be selected when querying, using select_related().
Contributes this manager, the real manager and the fallback manager onto the class using contribute_real_manager() and contribute_fallback_manager().
Creates a real manager and contributes it to the model after prefixing the name with an underscore.
Creates a fallback manager and contributes it to the model after prefixing the name with an underscore and suffixing it with '_fallback'.
A queryset that can optionally use fallbacks and by default only fetches the Shared Model.
List of fallbacks to use (or None).
If _translation_fallbacks is set, it iterates using the superclass and tries to get the translation using the order of language codes defined in _translation_fallbacks. As soon as it finds a translation for an object, it yields a combined object using that translation. Otherwise yields an uncombined object. Due to the way this works, it can cause a lot of queries and this should be improved if possible.
If no fallbacks are given, it just iterates using the superclass.
If this method gets called, iterator() will use the fallbacks defined here. If not fallbacks are given, FALLBACK_LANGUAGES will be used.
Injects translation_fallbacks into kwargs and calls the superclass.
Proxies to FallbackQueryset.use_fallbacks() by calling get_query_set() first.
Returns an instance of FallbackQueryset for this manager.
The language code of this queryset.
Calls language() using _language_code as an argument.
Translates args and kwargs into translation aware args and kwargs using nani.fieldtranslator.translate() by iterating over the kwargs dictionary and translating it’s keys and recursing over the django.db.models.expressions.Q objects in args using _recurse_q().
Returns a triple of newargs, newkwargs and extra_filters where newargs and newkwargs are the translated versions of args and kwargs and extra_filters is a django.db.models.expressions.Q object to use to filter for the current language.
Recursively translate the keys in the django.db.models.expressions.Q object given using nani.fieldtranslator.translate(). For more information about django.db.models.expressions.Q, see TranslationQueryset._recurse_q().
Returns a tuple of q and language_joins where q is the translated django.db.models.expressions.Q object and language_joins is a list of extra language join filters to be applied using the current language.
Calls language() using _language_code as an argument.
Translates the fieldnames given using nani.fieldtranslator.translate()
Returns a tuple of newfields and extra_filters where newfields is a list of translated fieldnames and extra_filters is a django.db.models.expressions.Q object to be used to filter for language joins.
Sets the _language_code attribute either to the language given with language_code or by getting the current language from django.utils.translations.get_language(). Unlike TranslationQueryset.language(), this does not actually filter by the language yet as this happens in _filter_extra().
Gets a single object from this queryset by filtering by args and kwargs, which are first translated using _translate_args_kwargs(). Calls _filter_extra() with the extra_filters returned by _translate_args_kwargs() to get a queryset from the superclass and to call that queryset.
Returns an instance of the model of this queryset or raises an appropriate exception when none or multiple objects were found.
Filters the queryset by args and kwargs by translating them using _translate_args_kwargs() and calling _filter_extra() with the extra_filters returned by _translate_args_kwargs().
Not implemented yet.
If a fieldname is given, uses nani.fieldtranslator.translate() to translate that fieldname. Calls _filter_extra() with the extra_filters returned by nani.fieldtranslator.translate() if it was used, otherwise with an empty django.db.models.expressions.Q object.
Not implemented yet
Calls _translated_fieldnames() to translated the fields. Then calls _filter_extra() with the extra_filters returned by _translated_fieldnames().
Calls _translated_fieldnames() to translated the fields. Then calls _filter_extra() with the extra_filters returned by _translated_fieldnames().
Not implemented yet.
Not implemented yet.
Not really implemented yet, but if filter_obj is an empty dictionary it just returns this queryset, to make admin work.
Not implemented yet.
Calls _translated_fieldnames() to translated the fields. Then calls _filter_extra() with the extra_filters returned by _translated_fieldnames().
Not implemented yet.
Not implemented yet.
Not implemented yet.
Injects _language_code into kwargs and calls the superclass.
Filters this queryset by the django.db.models.expressions.Q object provided in extra_filters and returns a queryset from the superclass, so that the methods that call this method can directely access methods on the superclass to reduce boilerplate code.
Returns an instance of TranslationAwareQueryset.