X-Git-Url: https://git.mdrn.pl/wolnelektury.git/blobdiff_plain/d467f1fa349730919e9fe906287e63563c888063..891b9e3b7ecaedc9ac32bc941400a267c77482a0:/apps/modeltranslation/translator.py diff --git a/apps/modeltranslation/translator.py b/apps/modeltranslation/translator.py new file mode 100644 index 000000000..0a5536261 --- /dev/null +++ b/apps/modeltranslation/translator.py @@ -0,0 +1,191 @@ +# -*- coding: utf-8 -*- +from django.conf import settings +#from django.contrib.contenttypes.models import ContentType +from django.db import models +from django.db.models import signals +from django.db.models.base import ModelBase +from django.utils.functional import curry + +from modeltranslation.fields import TranslationField +from modeltranslation.utils import (TranslationFieldDescriptor, + build_localized_fieldname) + + +class AlreadyRegistered(Exception): + pass + + +class NotRegistered(Exception): + pass + + +class TranslationOptions(object): + """ + The TranslationOptions object is used to specify the fields to translate. + + The options are registered in combination with a model class at the + ``modeltranslation.translator.translator`` instance. + + It caches the content type of the translated model for faster lookup later + on. + """ + def __init__(self, *args, **kwargs): + # self.translation_model = None + #self.model_ct = None + self.localized_fieldnames = list() + + +def add_localized_fields(model): + """ + Monkey patchs the original model class to provide additional fields for + every language. Only do that for fields which are defined in the + translation options of the model. + + Returns a dict mapping the original fieldname to a list containing the + names of the localized fields created for the original field. + """ + localized_fields = dict() + translation_opts = translator.get_options_for_model(model) + for field_name in translation_opts.fields: + localized_fields[field_name] = list() + for l in settings.LANGUAGES: + # Construct the name for the localized field + localized_field_name = build_localized_fieldname(field_name, l[0]) + # Check if the model already has a field by that name + if hasattr(model, localized_field_name): + raise ValueError("Error adding translation field. The model "\ + "'%s' already contains a field named '%s'. "\ + % (instance.__class__.__name__, + localized_field_name)) + + # This approach implements the translation fields as full valid + # django model fields and therefore adds them via add_to_class + localized_field = model.add_to_class( \ + localized_field_name, + TranslationField(model._meta.get_field(field_name), l[0])) + localized_fields[field_name].append(localized_field_name) + return localized_fields + + +#def translated_model_initialized(field_names, instance, **kwargs): + #print "translated_model_initialized instance:", \ + #instance, ", field:", field_names + #for field_name in field_names: + #initial_val = getattr(instance, field_name) + #print " field: %s, initialval: %s" % (field_name, initial_val) + #setattr(instance.__class__, field_name, + #TranslationFieldDescriptor(field_name, initial_val)) + + +#def translated_model_initializing(sender, args, kwargs, **signal_kwargs): + #print "translated_model_initializing", sender, args, kwargs + #trans_opts = translator.get_options_for_model(sender) + #for field_name in trans_opts.fields: + #setattr(sender, field_name, TranslationFieldDescriptor(field_name)) + + +class Translator(object): + """ + A Translator object encapsulates an instance of a translator. Models are + registered with the Translator using the register() method. + """ + def __init__(self): + # model_class class -> translation_opts instance + self._registry = {} + + def register(self, model_or_iterable, translation_opts, **options): + """ + Registers the given model(s) with the given translation options. + + The model(s) should be Model classes, not instances. + + If a model is already registered for translation, this will raise + AlreadyRegistered. + """ + # Don't import the humongous validation code unless required + if translation_opts and settings.DEBUG: + from django.contrib.admin.validation import validate + else: + validate = lambda model, adminclass: None + + #if not translation_opts: + #translation_opts = TranslationOptions + if isinstance(model_or_iterable, ModelBase): + model_or_iterable = [model_or_iterable] + + for model in model_or_iterable: + if model in self._registry: + raise AlreadyRegistered('The model %s is already registered ' + 'for translation' % model.__name__) + + # If we got **options then dynamically construct a subclass of + # translation_opts with those **options. + if options: + # For reasons I don't quite understand, without a __module__ + # the created class appears to "live" in the wrong place, + # which causes issues later on. + options['__module__'] = __name__ + translation_opts = type("%sAdmin" % model.__name__, + (translation_opts,), options) + + # Validate (which might be a no-op) + #validate(translation_opts, model) + + # Store the translation class associated to the model + self._registry[model] = translation_opts + + # Get the content type of the original model and store it on the + # translation options for faster lookup later on. + #translation_opts.model_ct = \ + #ContentType.objects.get_for_model(model) + + # Add the localized fields to the model and store the names of + # these fields in the model's translation options for faster lookup + # later on. + translation_opts.localized_fieldnames = add_localized_fields(model) + + # Create a reverse dict mapping the localized_fieldnames to the + # original fieldname + rev_dict = dict() + for orig_name, loc_names in \ + translation_opts.localized_fieldnames.items(): + for ln in loc_names: + rev_dict[ln] = orig_name + + translation_opts.localized_fieldnames_rev = rev_dict + + # print "Applying descriptor field for model %s" % model + for field_name in translation_opts.fields: + setattr(model, field_name, TranslationFieldDescriptor(field_name)) + + #signals.pre_init.connect(translated_model_initializing, sender=model, + #weak=False) + + def unregister(self, model_or_iterable): + """ + Unregisters the given model(s). + + If a model isn't already registered, this will raise NotRegistered. + """ + if isinstance(model_or_iterable, ModelBase): + model_or_iterable = [model_or_iterable] + for model in model_or_iterable: + if model not in self._registry: + raise NotRegistered('The model "%s" is not registered for ' + 'translation' % model.__name__) + del self._registry[model] + + def get_options_for_model(self, model): + """ + Returns the translation options for the given ``model``. If the + ``model`` is not registered a ``NotRegistered`` exception is raised. + """ + try: + return self._registry[model] + except KeyError: + raise NotRegistered('The model "%s" is not registered for ' + 'translation' % model.__name__) + + +# This global object represents the singleton translator object +translator = Translator()