def modeltranslation_update_slugs(sender, **kwargs):
        # https://bitbucket.org/neithere/django-autoslug/pull-request/11/modeltranslation-support-fix-issue-19/
        # http://django-modeltranslation.readthedocs.org
        #
        # TODO: tests
        #
        if not modeltranslation_utils:
            return

        instance = kwargs['instance']
        slugs = {}

        for field in instance._meta.fields:
            if type(field) == AutoSlugField:
                for lang in settings.LANGUAGES:
                    lang_code = lang[0]
                    lang_code = lang_code.replace('-', '_')

                    populate_from_localized = modeltranslation_utils.build_localized_fieldname(field.populate_from, lang_code)
                    populate_from_value = getattr(instance, populate_from_localized)

                    field_name_localized = modeltranslation_utils.build_localized_fieldname(field.name, lang_code)
                    field_value = getattr(instance, field_name_localized)

                    if not field_value or field.always_update:
                        slug = field.slugify(populate_from_value)
                        slugs[field_name_localized] = slug

        sender.objects.filter(pk=instance.pk).update(**slugs)

 def _patch_prepopulated_fields(self):
     if self.prepopulated_fields:
         # prepopulated_fields_new = dict(self.prepopulated_fields)
         # for (k, v) in self.prepopulated_fields.items():
         #     if v[0] in self.trans_opts.fields:
         #         translation_fields = get_translation_fields(v[0])
         #         prepopulated_fields_new[k] = tuple([translation_fields[0]])
         prepopulated_fields_new = {}
         for (k, v) in self.prepopulated_fields.items():
             if k in self.trans_opts.fields:
                 translation_fields = [(l, build_localized_fieldname(k, l)) for l in AVAILABLE_LANGUAGES]
                 new_keys = tuple(translation_fields)
             else:
                 new_keys = ((None, k),)
             for lang, new_key in new_keys:
                 languages = AVAILABLE_LANGUAGES
                 if lang:
                     languages = [lang]
                 new_vals = []
                 for val in v:
                     if val in self.trans_opts.fields:
                         translation_fields = [build_localized_fieldname(val, l) for l in languages]
                         new_vals.extend(translation_fields)
                     else:
                         new_vals.append(val)
                 new_vals = tuple(new_vals)
                 prepopulated_fields_new[new_key] = new_vals
         self.prepopulated_fields = prepopulated_fields_new

    def test_sitemap_lang_slug(self):
        """Test that the url is in the locale language"""
        site = Site.objects.get_current()
        from modeltranslation.utils import build_localized_fieldname  # pylint: disable=F0401

        kwargs1 = {}
        kwargs2 = {}

        for lang_code, lang_name in settings.LANGUAGES:
            loc_title_var = build_localized_fieldname('title', lang_code)
            loc_slug_var = build_localized_fieldname('slug', lang_code)
            kwargs1[loc_title_var] = 'article-{0}-1'.format(lang_name)
            kwargs2[loc_title_var] = 'other-article-{0}-2'.format(lang_name)
            kwargs1[loc_slug_var] = slugify(kwargs1[loc_title_var])
            kwargs2[loc_slug_var] = slugify(kwargs2[loc_title_var])

        article_class = get_article_class()

        article1 = mommy.make(article_class, publication=BaseArticle.PUBLISHED, **kwargs1)
        article2 = mommy.make(article_class, publication=BaseArticle.PUBLISHED, **kwargs2)

        factory = RequestFactory()
        request = factory.get('/sitemap.xml')
        response = sitemap_view(request, get_sitemaps())
        self.assertEqual(200, response.status_code)

        for (lang, name) in settings.LANGUAGES:
            activate(lang)
            self.assertContains(response, site.domain + article1.get_absolute_url())
            self.assertContains(response, site.domain + article2.get_absolute_url())

 def handle(self, *args, **options):
     """command"""
     #look for emailing to be sent
     verbose = options.get('verbosity', 1)
     
     if not is_localized():
         print("the site is not localized this is not required")
     
     from modeltranslation.utils import build_localized_fieldname
     
     for alias in Alias.objects.all():
         cursor = connection.cursor()
         
         cursor.execute(
             '''SELECT path, redirect_url FROM coop_cms_alias where id={0}'''.format(alias.id))
         row = cursor.fetchone()
         print(row)
         (path, redirect_url) = row
         
         languages = [x for (x, y) in settings.LANGUAGES]
         
         lang_code = languages[0]
         path_field_name = build_localized_fieldname('path', lang_code)
         redirect_url_field_name = build_localized_fieldname('redirect_url', lang_code)
         if (not getattr(alias, path_field_name)) and (not getattr(alias, redirect_url_field_name)):
             print("update", alias.id, path, redirect_url)
             setattr(alias, path_field_name, path)
             setattr(alias, redirect_url_field_name, redirect_url)
             alias.save()

def _new_set_url_path(self, parent):
    """
    This method override populates url_path for each specified language.
    This way we can get different urls for each language, defined
    by page slug.
    """
    for language in mt_settings.AVAILABLE_LANGUAGES:
        localized_slug_field = build_localized_fieldname('slug', language)
        default_localized_slug_field = build_localized_fieldname('slug', mt_settings.DEFAULT_LANGUAGE)
        localized_url_path_field = build_localized_fieldname('url_path', language)
        default_localized_url_path_field = build_localized_fieldname('url_path', mt_settings.DEFAULT_LANGUAGE)

        if parent:
            parent = parent.specific

            # Emulate the default behavior of django-modeltranslation to get the slug and url path
            # for the current language. If the value for the current language is invalid we get the one
            # for the default fallback language
            slug = getattr(self, localized_slug_field, None) or getattr(self, default_localized_slug_field, self.slug)
            parent_url_path = getattr(parent, localized_url_path_field, None) or \
                              getattr(parent, default_localized_url_path_field, parent.url_path)

            setattr(self, localized_url_path_field, parent_url_path + slug + '/')

        else:
            # a page without a parent is the tree root,
            # which always has a url_path of '/'
            setattr(self, localized_url_path_field, '/')

    # update url_path for children pages
    for child in self.get_children().specific():
        child.set_url_path(self.specific)
        child.save()

    return self.url_path

 def __get__(self, instance, owner):
     """
     Returns value from the translation field for the current language, or
     value for some another language according to fallback languages, or the
     custom fallback value, or field's default value.
     """
     if instance is None:
         return self
     default = NONE
     undefined = self.fallback_undefined
     if undefined is NONE:
         default = self.field.get_default()
         undefined = default
     langs = resolution_order(get_language(), self.fallback_languages)
     for lang in langs:
         loc_field_name = build_localized_fieldname(self.field.name, lang)
         val = getattr(instance, loc_field_name, None)
         if val is not None and val != undefined:
             return val
     if mt_settings.ENABLE_FALLBACKS and self.fallback_value is not NONE:
         return self.fallback_value
     else:
         if default is NONE:
             default = self.field.get_default()
         return default

 def cache_name(self):
     """
     Used in django 1.x
     """
     lang = get_language()
     cache = build_localized_fieldname(self.accessor, lang)
     return "_%s_cache" % cache

def add_localized_fields(model):
    """
    Monkey patches 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:
            # Create a dynamic translation field
            translation_field = create_translation_field(
                model=model, field_name=field_name, lang=l[0])
            # 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. Model '%s' already "
                    "contains a field named '%s'." % (
                        model._meta.object_name, localized_field_name))
            # This approach implements the translation fields as full valid
            # django model fields and therefore adds them via add_to_class
            model.add_to_class(localized_field_name, translation_field)
            localized_fields[field_name].append(localized_field_name)
    return localized_fields

    def __init__(self, translated_field, language, *args, **kwargs):
        # Update the dict of this field with the content of the original one
        # This might be a bit radical?! Seems to work though...
        self.__dict__.update(translated_field.__dict__)

        # Store the originally wrapped field for later
        self.translated_field = translated_field
        self.language = language

        # Translation are always optional (for now - maybe add some parameters
        # to the translation options for configuring this)

        if not isinstance(self, fields.BooleanField):
            # TODO: Do we really want to enforce null *at all*? Shouldn't this
            # better honour the null setting of the translated field?
            self.null = True
        self.blank = True

        # Adjust the name of this field to reflect the language
        self.attname = build_localized_fieldname(self.translated_field.name, self.language)
        self.name = self.attname

        # Copy the verbose name and append a language suffix
        # (will show up e.g. in the admin).
        self.verbose_name = build_localized_verbose_name(translated_field.verbose_name, language)

 def __get__(self, instance, owner):
     """
     Returns value from the translation field for the current language, or
     value for some another language according to fallback languages, or the
     custom fallback value, or field's default value.
     """
     if instance is None:
         return self
     default = NONE
     undefined = self.fallback_undefined
     if undefined is NONE:
         default = self.field.get_default()
         undefined = default
     langs = resolution_order(get_language(), self.fallback_languages)
     for lang in langs:
         loc_field_name = build_localized_fieldname(self.field.name, lang)
         val = getattr(instance, loc_field_name, None)
         if self.meaningful_value(val, undefined):
             return val
     if mt_settings.ENABLE_FALLBACKS and self.fallback_value is not NONE:
         return self.fallback_value
     else:
         if default is NONE:
             default = self.field.get_default()
         # Some fields like FileField behave strange, as their get_default() doesn't return
         # instance of attr_class, but rather None or ''.
         # Normally this case is handled in the descriptor, but since we have overridden it, we
         # must mock it up.
         if (isinstance(self.field, fields.files.FileField) and
                 not isinstance(default, self.field.attr_class)):
             return self.field.attr_class(instance, self.field, default)
         return default

 def get_attname_column(self):
     attname = self.get_attname()
     column = (
         build_localized_fieldname(self.translated_field.db_column or self.translated_field.name, self.language)
         or attname
     )
     return attname, column

 def __init__(self):
     super(Command, self).__init__()
     update_fields = ['url_path']
     for language in mt_settings.AVAILABLE_LANGUAGES:
         localized_url_path = build_localized_fieldname('url_path', language)
         update_fields.append(localized_url_path)
     self.update_fields = update_fields

def add_translation_fields(model, opts):
    """
    Monkey patches the original model class to provide additional fields for
    every language.

    Adds newly created translation fields to the given translation options.
    """
    model_empty_values = getattr(opts, 'empty_values', NONE)
    for field_name in opts.local_fields.keys():
        field_empty_value = parse_field(model_empty_values, field_name, NONE)
        for l in mt_settings.AVAILABLE_LANGUAGES:
            # Create a dynamic translation field
            translation_field = create_translation_field(
                model=model, field_name=field_name, lang=l, empty_value=field_empty_value)
            # Construct the name for the localized field
            localized_field_name = build_localized_fieldname(field_name, l)
            # Check if the model already has a field by that name
            if hasattr(model, localized_field_name):
                raise ValueError(
                    "Error adding translation field. Model '%s' already contains a field named"
                    "'%s'." % (model._meta.object_name, localized_field_name))
            # This approach implements the translation fields as full valid
            # django model fields and therefore adds them via add_to_class
            model.add_to_class(localized_field_name, translation_field)
            opts.add_translation_field(field_name, translation_field)

    # Rebuild information about parents fields. If there are opts.local_fields, field cache would be
    # invalidated (by model._meta.add_field() function). Otherwise, we need to do it manually.
    if len(opts.local_fields) == 0:
        model._meta._fill_fields_cache()

    def __init__(self, translated_field, language, *args, **kwargs):
        # Store the originally wrapped field for later
        self.translated_field = translated_field
        self.language = language
        
        # Update the dict of this field with the content of the original one
        # This might be a bit radical?! Seems to work though...
        self.__dict__.update(translated_field.__dict__)        
        
        # Translation are always optional (for now - maybe add some parameters
        # to the translation options for configuring this)
        self.null = True
        self.blank = True

        # If translations are optional, uniqueness can't be enforced
        self._unique = False
        
        # Adjust the name of this field to reflect the language
        self.attname = build_localized_fieldname(translated_field.name, language)
        self.name = self.attname
        
        # Copy the verbose name and append a language suffix (will e.g. in the
        # admin). This might be a proxy function so we have to check that here.
        if hasattr(translated_field.verbose_name, '_proxy____unicode_cast'):            
            verbose_name = translated_field.verbose_name._proxy____unicode_cast()
        else:
            verbose_name = translated_field.verbose_name                       
        self.verbose_name = '%s [%s]' % (verbose_name, language)

def rewrite_lookup_key(model, lookup_key):
    translatable_fields = get_translatable_fields_for_model(model)
    if translatable_fields is not None:
        pieces = lookup_key.split('__')
        # If we are doing a lookup on a translatable field,
        # we want to rewrite it to the actual field name
        # For example, we want to rewrite "name__startswith" to "name_fr__startswith"
        if pieces[0] in translatable_fields:
            lookup_key = build_localized_fieldname(pieces[0], get_language())

            remaining_lookup = '__'.join(pieces[1:])
            if remaining_lookup:
                lookup_key = '%s__%s' % (lookup_key, remaining_lookup)

    pieces = lookup_key.split('__')
    if len(pieces) > 1:
        # Check if we are doing a lookup to a related trans model
        fields_to_trans_models = get_fields_to_translatable_models(model)
        for field_to_trans, transmodel in fields_to_trans_models:
            if pieces[0] == field_to_trans:
                sub_lookup = '__'.join(pieces[1:])
                if sub_lookup:
                    sub_lookup = rewrite_lookup_key(transmodel, sub_lookup)
                    lookup_key = '%s__%s' % (pieces[0], sub_lookup)
                break

    return lookup_key

 def get_attname_column(self):
     attname = self.get_attname()
     if self.translated_field.db_column:
         column = build_localized_fieldname(self.translated_field.db_column)
     else:
         column = attname
     return attname, column

def _validate_slugs(page):
    """
    Determine whether the given slug is available for use on a child page of
    parent_page.
    """
    parent_page = page.get_parent()

    if parent_page is None:
        # the root page's slug can be whatever it likes...
        return {}

    # Save the current active language
    current_language = get_language()

    siblings = page.get_siblings(inclusive=False).specific()

    errors = {}

    for language in mt_settings.AVAILABLE_LANGUAGES:
        # Temporarily activate every language because even though there might
        # be no repeated value for slug_pt the fallback of an empty slug could
        # already be in use

        trans_real.activate(language)

        siblings_slugs = [sibling.slug for sibling in siblings]

        if page.specific.slug in siblings_slugs:
            errors[build_localized_fieldname('slug', language)] = _("This slug is already in use")

    # Re-enable the original language
    trans_real.activate(current_language)

    return errors

 def save(self):
     """
     Save each of the settings to the DB.
     """
     active_language = get_language()
     for (name, value) in self.cleaned_data.items():
         if name not in registry:
             name, code = name.rsplit('_modeltranslation_', 1)
         else:
             code = None
         setting_obj, created = Setting.objects.get_or_create(name=name)
         if settings.USE_MODELTRANSLATION:
             if registry[name]["translatable"]:
                 try:
                     activate(code)
                 except:
                     pass
                 finally:
                     setting_obj.value = value
                     activate(active_language)
             else:
                 # Duplicate the value of the setting for every language
                 for code in OrderedDict(settings.LANGUAGES):
                     setattr(setting_obj,
                             build_localized_fieldname('value', code),
                             value)
         else:
             setting_obj.value = value
         setting_obj.save()

    def _patch_simple_panel(self, model, original_panel):
        panel_class = original_panel.__class__
        translated_panels = []
        translation_registered_fields = translator.get_options_for_model(model).fields

        # If the panel field is not registered for translation
        # the original one is returned
        if original_panel.field_name not in translation_registered_fields:
            return [original_panel]

        for language in mt_settings.AVAILABLE_LANGUAGES:
            original_field = model._meta.get_field(original_panel.field_name)
            localized_field_name = build_localized_fieldname(original_panel.field_name, language)

            # if the original field is required and the current language is the default one
            # this field's blank property is set to False
            if not original_field.blank and language == mt_settings.DEFAULT_LANGUAGE:
                localized_field = model._meta.get_field(localized_field_name)
                localized_field.blank = False

            localized_panel = panel_class(localized_field_name)

            # Pass the original panel extra attributes to the localized
            if hasattr(original_panel, 'classname'):
                localized_panel.classname = original_panel.classname
            if hasattr(original_panel, 'widget'):
                localized_panel.widget = original_panel.widget

            translated_panels.append(localized_panel)

        return translated_panels

 def __set__(self, instance, value):
     lang = get_language()
     loc_field_name = build_localized_fieldname(self.name, lang)
     # also update the translation field of the current language
     setattr(instance, loc_field_name, value)
     # update the original field via the __dict__ to prevent calling the
     # descriptor
     instance.__dict__[self.name] = value