+++ /dev/null
-# -*- 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()
fnp / wolnelektury.git / blobdiff