Django-constance package integrate in project from github.

.travis.yml

@@ -3,11 +3,12 @@ python:
     - 3.4
     - 3.5
     - 3.6
+    - 3.7
 
 env:
     - DJANGO='django>=1.10,<1.11'
     - DJANGO='django>=1.11,<2.0'
-    - DJANGO='django>=2.0,<2.1'
+    - DJANGO='django>=2.0'
 
 install:
     - travis_retry pip install $DJANGO

constance/__init__.py

+from django.utils.functional import LazyObject
+
+__version__ = '2.2.0'
+
+default_app_config = 'constance.apps.ConstanceConfig'
+
+
+class LazyConfig(LazyObject):
+    def _setup(self):
+        from .base import Config
+        self._wrapped = Config()
+
+
+config = LazyConfig()

constance/admin.py

+from collections import OrderedDict
+from datetime import datetime, date, time, timedelta
+from decimal import Decimal
+from operator import itemgetter
+import hashlib
+import os
+
+from django import forms, VERSION
+from django.apps import apps
+from django.conf import settings as django_settings
+from django.conf.urls import url
+from django.contrib import admin, messages
+from django.contrib.admin import widgets
+from django.contrib.admin.options import csrf_protect_m
+from django.core.exceptions import PermissionDenied, ImproperlyConfigured
+from django.forms import fields
+from django.http import HttpResponseRedirect
+from django.template.response import TemplateResponse
+from django.utils import six
+from django.utils.encoding import smart_bytes
+from django.utils.formats import localize
+from django.utils.module_loading import import_string
+from django.utils.translation import ugettext_lazy as _
+
+from . import LazyConfig, settings
+
+
+config = LazyConfig()
+
+
+NUMERIC_WIDGET = forms.TextInput(attrs={'size': 10})
+
+INTEGER_LIKE = (fields.IntegerField, {'widget': NUMERIC_WIDGET})
+STRING_LIKE = (fields.CharField, {
+    'widget': forms.Textarea(attrs={'rows': 3}),
+    'required': False,
+})
+
+FIELDS = {
+    bool: (fields.BooleanField, {'required': False}),
+    int: INTEGER_LIKE,
+    Decimal: (fields.DecimalField, {'widget': NUMERIC_WIDGET}),
+    str: STRING_LIKE,
+    datetime: (
+        fields.SplitDateTimeField, {'widget': widgets.AdminSplitDateTime}
+    ),
+    timedelta: (
+        fields.DurationField, {'widget': widgets.AdminTextInputWidget}
+    ),
+    date: (fields.DateField, {'widget': widgets.AdminDateWidget}),
+    time: (fields.TimeField, {'widget': widgets.AdminTimeWidget}),
+    float: (fields.FloatField, {'widget': NUMERIC_WIDGET}),
+}
+
+
+def parse_additional_fields(fields):
+    for key in fields:
+        field = list(fields[key])
+
+        if len(field) == 1:
+            field.append({})
+
+        field[0] = import_string(field[0])
+
+        if 'widget' in field[1]:
+            klass = import_string(field[1]['widget'])
+            field[1]['widget'] = klass(
+                **(field[1].get('widget_kwargs', {}) or {})
+            )
+
+            if 'widget_kwargs' in field[1]:
+                del field[1]['widget_kwargs']
+
+        fields[key] = field
+
+    return fields
+
+
+FIELDS.update(parse_additional_fields(settings.ADDITIONAL_FIELDS))
+
+if not six.PY3:
+    FIELDS.update({
+        long: INTEGER_LIKE,
+        unicode: STRING_LIKE,
+    })
+
+
+def get_values():
+    """
+    Get dictionary of values from the backend
+    :return:
+    """
+
+    # First load a mapping between config name and default value
+    default_initial = ((name, options[0])
+                       for name, options in settings.CONFIG.items())
+    # Then update the mapping with actually values from the backend
+    initial = dict(default_initial, **dict(config._backend.mget(settings.CONFIG)))
+
+    return initial
+
+
+class ConstanceForm(forms.Form):
+    version = forms.CharField(widget=forms.HiddenInput)
+
+    def __init__(self, initial, *args, **kwargs):
+        super(ConstanceForm, self).__init__(*args, initial=initial, **kwargs)
+        version_hash = hashlib.md5()
+
+        for name, options in settings.CONFIG.items():
+            default = options[0]
+            if len(options) == 3:
+                config_type = options[2]
+                if config_type not in settings.ADDITIONAL_FIELDS and not isinstance(default, config_type):
+                    raise ImproperlyConfigured(_("Default value type must be "
+                                                 "equal to declared config "
+                                                 "parameter type. Please fix "
+                                                 "the default value of "
+                                                 "'%(name)s'.")
+                                               % {'name': name})
+            else:
+                config_type = type(default)
+
+            if config_type not in FIELDS:
+                raise ImproperlyConfigured(_("Constance doesn't support "
+                                             "config values of the type "
+                                             "%(config_type)s. Please fix "
+                                             "the value of '%(name)s'.")
+                                           % {'config_type': config_type,
+                                              'name': name})
+            field_class, kwargs = FIELDS[config_type]
+            self.fields[name] = field_class(label=name, **kwargs)
+
+            version_hash.update(smart_bytes(initial.get(name, '')))
+        self.initial['version'] = version_hash.hexdigest()
+
+    def save(self):
+        for file_field in self.files:
+            file = self.cleaned_data[file_field]
+            file_path = os.path.join(django_settings.MEDIA_ROOT, file.name)
+            with open(file_path, 'wb+') as destination:
+                for chunk in file.chunks():
+                    destination.write(chunk)
+                self.cleaned_data[file_field] = file.name
+
+        for name in settings.CONFIG:
+            if getattr(config, name) != self.cleaned_data[name]:
+                setattr(config, name, self.cleaned_data[name])
+
+    def clean_version(self):
+        value = self.cleaned_data['version']
+
+        if settings.IGNORE_ADMIN_VERSION_CHECK:
+            return value
+
+        if value != self.initial['version']:
+            raise forms.ValidationError(_('The settings have been modified '
+                                          'by someone else. Please reload the '
+                                          'form and resubmit your changes.'))
+        return value
+
+    def clean(self):
+        cleaned_data = super(ConstanceForm, self).clean()
+
+        if not settings.CONFIG_FIELDSETS:
+            return cleaned_data
+
+        field_name_list = []
+        for fieldset_title, fields_list in settings.CONFIG_FIELDSETS.items():
+            for field_name in fields_list:
+                field_name_list.append(field_name)
+        if field_name_list and set(set(settings.CONFIG.keys()) - set(field_name_list)):
+            raise forms.ValidationError(_('CONSTANCE_CONFIG_FIELDSETS is missing '
+                                          'field(s) that exists in CONSTANCE_CONFIG.'))
+
+        return cleaned_data
+
+
+class ConstanceAdmin(admin.ModelAdmin):
+    change_list_template = 'admin/constance/change_list.html'
+    change_list_form = ConstanceForm
+
+    def get_urls(self):
+        info = self.model._meta.app_label, self.model._meta.module_name
+        return [
+            url(r'^$',
+                self.admin_site.admin_view(self.changelist_view),
+                name='%s_%s_changelist' % info),
+            url(r'^$',
+                self.admin_site.admin_view(self.changelist_view),
+                name='%s_%s_add' % info),
+        ]
+
+    def get_config_value(self, name, options, form, initial):
+        default, help_text = options[0], options[1]
+        # First try to load the value from the actual backend
+        value = initial.get(name)
+        # Then if the returned value is None, get the default
+        if value is None:
+            value = getattr(config, name)
+        config_value = {
+            'name': name,
+            'default': localize(default),
+            'raw_default': default,
+            'help_text': _(help_text),
+            'value': localize(value),
+            'modified': localize(value) != localize(default),
+            'form_field': form[name],
+            'is_date': isinstance(default, date),
+            'is_datetime': isinstance(default, datetime),
+            'is_checkbox': isinstance(form[name].field.widget, forms.CheckboxInput),
+            'is_file': isinstance(form[name].field.widget, forms.FileInput),
+        }
+
+        return config_value
+
+    def get_changelist_form(self, request):
+        """
+        Returns a Form class for use in the changelist_view.
+        """
+        # Defaults to self.change_list_form in order to preserve backward
+        # compatibility
+        return self.change_list_form
+
+    @csrf_protect_m
+    def changelist_view(self, request, extra_context=None):
+        if not self.has_change_permission(request, None):
+            raise PermissionDenied
+        initial = get_values()
+        form_cls = self.get_changelist_form(request)
+        form = form_cls(initial=initial)
+        if request.method == 'POST':
+            form = form_cls(
+                data=request.POST, files=request.FILES, initial=initial
+            )
+            if form.is_valid():
+                form.save()
+                messages.add_message(
+                    request,
+                    messages.SUCCESS,
+                    _('Live settings updated successfully.'),
+                )
+                return HttpResponseRedirect('.')
+        context = dict(
+            self.admin_site.each_context(request),
+            config_values=[],
+            title=self.model._meta.app_config.verbose_name,
+            app_label='constance',
+            opts=self.model._meta,
+            form=form,
+            media=self.media + form.media,
+            icon_type='gif' if VERSION < (1, 9) else 'svg',
+        )
+        for name, options in settings.CONFIG.items():
+            context['config_values'].append(
+                self.get_config_value(name, options, form, initial)
+            )
+
+        if settings.CONFIG_FIELDSETS:
+            context['fieldsets'] = []
+            for fieldset_title, fields_list in settings.CONFIG_FIELDSETS.items():
+                fields_exist = all(field in settings.CONFIG for field in fields_list)
+                assert fields_exist, "CONSTANCE_CONFIG_FIELDSETS contains field(s) that does not exist"
+                config_values = []
+
+                for name in fields_list:
+                    options = settings.CONFIG.get(name)
+                    if options:
+                        config_values.append(
+                            self.get_config_value(name, options, form, initial)
+                        )
+
+                context['fieldsets'].append({
+                    'title': fieldset_title,
+                    'config_values': config_values
+                })
+            if not isinstance(settings.CONFIG_FIELDSETS, OrderedDict):
+                context['fieldsets'].sort(key=itemgetter('title'))
+
+        if not isinstance(settings.CONFIG, OrderedDict):
+            context['config_values'].sort(key=itemgetter('name'))
+        request.current_app = self.admin_site.name
+        return TemplateResponse(request, self.change_list_template, context)
+
+    def has_add_permission(self, *args, **kwargs):
+        return False
+
+    def has_delete_permission(self, *args, **kwargs):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        if settings.SUPERUSER_ONLY:
+            return request.user.is_superuser
+        return super(ConstanceAdmin, self).has_change_permission(request, obj)
+
+
+class Config(object):
+    class Meta(object):
+        app_label = 'constance'
+        object_name = 'Config'
+        model_name = module_name = 'config'
+        verbose_name_plural = _('config')
+        abstract = False
+        swapped = False
+
+        def get_ordered_objects(self):
+            return False
+
+        def get_change_permission(self):
+            return 'change_%s' % self.model_name
+
+        @property
+        def app_config(self):
+            return apps.get_app_config(self.app_label)
+
+        @property
+        def label(self):
+            return '%s.%s' % (self.app_label, self.object_name)
+
+        @property
+        def label_lower(self):
+            return '%s.%s' % (self.app_label, self.model_name)
+
+    _meta = Meta()
+
+
+admin.site.register([Config], ConstanceAdmin)

constance/apps.py

+from django.db.models import signals
+from django.apps import AppConfig
+
+
+class ConstanceConfig(AppConfig):
+    name = 'constance'
+    verbose_name = 'Constance'
+
+    def ready(self):
+        super(ConstanceConfig, self).ready()
+        signals.post_migrate.connect(self.create_perm,
+                                     dispatch_uid='constance.create_perm')
+
+    def create_perm(self, using=None, *args, **kwargs):
+        """
+        Creates a fake content type and permission
+        to be able to check for permissions
+        """
+        from django.conf import settings
+        from django.contrib.auth.models import Permission
+        from django.contrib.contenttypes.models import ContentType
+
+        constance_dbs = getattr(settings, 'CONSTANCE_DBS', None)
+        if constance_dbs is not None and using not in constance_dbs:
+            return
+        if ContentType._meta.installed and Permission._meta.installed:
+            content_type, created = ContentType.objects.using(using).get_or_create(
+                app_label='constance',
+                model='config',
+            )
+
+            permission, created = Permission.objects.using(using).get_or_create(
+                content_type=content_type,
+                codename='change_config',
+                defaults={'name': 'Can change config'})

constance/backends/__init__.py

+"""
+Defines the base constance backend
+"""
+
+
+class Backend(object):
+
+    def get(self, key):
+        """
+        Get the key from the backend store and return the value.
+        Return None if not found.
+        """
+        raise NotImplementedError
+
+    def mget(self, keys):
+        """
+        Get the keys from the backend store and return a list of the values.
+        Return an empty list if not found.
+        """
+        raise NotImplementedError
+
+    def set(self, key, value):
+        """
+        Add the value to the backend store given the key.
+        """
+        raise NotImplementedError

constance/backends/database/__init__.py

+from django.core.cache import caches
+from django.core.cache.backends.locmem import LocMemCache
+from django.core.exceptions import ImproperlyConfigured
+from django.db import OperationalError, ProgrammingError
+from django.db.models.signals import post_save
+
+from .. import Backend
+from ... import settings, signals, config
+
+
+class DatabaseBackend(Backend):
+    def __init__(self):
+        from .models import Constance
+        self._model = Constance
+        self._prefix = settings.DATABASE_PREFIX
+        self._autofill_timeout = settings.DATABASE_CACHE_AUTOFILL_TIMEOUT
+        self._autofill_cachekey = 'autofilled'
+
+        if not self._model._meta.installed:
+            raise ImproperlyConfigured(
+                "The constance.backends.database app isn't installed "
+                "correctly. Make sure it's in your INSTALLED_APPS setting.")
+
+        if settings.DATABASE_CACHE_BACKEND:
+            self._cache = caches[settings.DATABASE_CACHE_BACKEND]
+            if isinstance(self._cache, LocMemCache):
+                raise ImproperlyConfigured(
+                    "The CONSTANCE_DATABASE_CACHE_BACKEND setting refers to a "
+                    "subclass of Django's local-memory backend (%r). Please "
+                    "set it to a backend that supports cross-process caching."
+                    % settings.DATABASE_CACHE_BACKEND)
+        else:
+            self._cache = None
+        self.autofill()
+        # Clear simple cache.
+        post_save.connect(self.clear, sender=self._model)
+
+    def add_prefix(self, key):
+        return "%s%s" % (self._prefix, key)
+
+    def autofill(self):
+        if not self._autofill_timeout or not self._cache:
+            return
+        full_cachekey = self.add_prefix(self._autofill_cachekey)
+        if self._cache.get(full_cachekey):
+            return
+        autofill_values = {}
+        autofill_values[full_cachekey] = 1
+        for key, value in self.mget(settings.CONFIG):
+            autofill_values[self.add_prefix(key)] = value
+        self._cache.set_many(autofill_values, timeout=self._autofill_timeout)
+
+    def mget(self, keys):
+        if not keys:
+            return
+        keys = {self.add_prefix(key): key for key in keys}
+        try:
+            stored = self._model._default_manager.filter(key__in=keys)
+            for const in stored:
+                yield keys[const.key], const.value
+        except (OperationalError, ProgrammingError):
+            pass
+
+    def get(self, key):
+        key = self.add_prefix(key)
+        if self._cache:
+            value = self._cache.get(key)
+            if value is None:
+                self.autofill()
+                value = self._cache.get(key)
+        else:
+            value = None
+        if value is None:
+            try:
+                value = self._model._default_manager.get(key=key).value
+            except (OperationalError, ProgrammingError, self._model.DoesNotExist):
+                pass
+            else:
+                if self._cache:
+                    self._cache.add(key, value)
+        return value
+
+    def set(self, key, value):
+        old_value = self.get(key)
+
+        try:
+            constance, created = self._model._default_manager.get_or_create(
+                key=self.add_prefix(key), defaults={'value': value}
+            )
+        except (OperationalError, ProgrammingError):
+            # database is not created, noop
+            return
+
+        if not created:
+            constance.value = value
+            constance.save()
+        if self._cache:
+            self._cache.set(key, value)
+
+        signals.config_updated.send(
+            sender=config, key=key, old_value=old_value, new_value=value
+        )
+
+    def clear(self, sender, instance, created, **kwargs):
+        if self._cache and not created:
+            keys = [self.add_prefix(k) for k in settings.CONFIG]
+            keys.append(self.add_prefix(self._autofill_cachekey))
+            self._cache.delete_many(keys)
+            self.autofill()

constance/backends/database/migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+import picklefield.fields
+
+
+class Migration(migrations.Migration):
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='Constance',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', primary_key=True,
+                                        auto_created=True, serialize=False)),
+                ('key', models.CharField(unique=True, max_length=255)),
+                ('value', picklefield.fields.PickledObjectField(editable=False)),
+            ],
+            options={
+                'verbose_name': 'constance',
+                'verbose_name_plural': 'constances',
+                'db_table': 'constance_config',
+            },
+            bases=(models.Model,),
+        ),
+    ]

constance/backends/database/models.py

+from django.db import models
+from django.core.exceptions import ImproperlyConfigured
+
+from django.utils.translation import ugettext_lazy as _
+
+try:
+    from picklefield import PickledObjectField
+except ImportError:
+    raise ImproperlyConfigured("Couldn't find the the 3rd party app "
+                               "django-picklefield which is required for "
+                               "the constance database backend.")
+
+
+class Constance(models.Model):
+    key = models.CharField(max_length=255, unique=True)
+    value = PickledObjectField()
+
+    class Meta:
+        verbose_name = _('constance')
+        verbose_name_plural = _('constances')
+        db_table = 'constance_config'
+
+    def __unicode__(self):
+        return self.key

constance/backends/database/south_migrations/0001_initial.py

+# -*- coding: utf-8 -*-
+from south.db import db
+from south.v2 import SchemaMigration
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'Constance'
+        db.create_table('constance_config', (
+            ('id', self.gf('django.db.models.fields.AutoField')(
+                primary_key=True)),
+            ('key', self.gf('django.db.models.fields.TextField')()),
+            ('value', self.gf('picklefield.fields.PickledObjectField')()),
+        ))
+        db.send_create_signal('database', ['Constance'])
+
+    def backwards(self, orm):
+        # Deleting model 'Constance'
+        db.delete_table('constance_config')
+
+    models = {
+        'database.constance': {
+            'Meta': {'object_name': 'Constance',
+                     'db_table': "'constance_config'"},
+            'id': ('django.db.models.fields.AutoField', [],
+                   {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.TextField', [], {}),
+            'value': ('picklefield.fields.PickledObjectField', [], {})
+        }
+    }
+
+    complete_apps = ['database']

constance/backends/database/south_migrations/0002_auto__chg_field_constance_key__add_unique_constance_key.py

+# -*- coding: utf-8 -*-
+from south.db import db
+from south.v2 import SchemaMigration
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Changing field 'Constance.key'
+        db.alter_column('constance_config', 'key',
+                        self.gf('django.db.models.fields.CharField')(
+                            max_length=255))
+        # Adding unique constraint on 'Constance', fields ['key']
+        db.create_unique('constance_config', ['key'])
+
+    def backwards(self, orm):
+        # Removing unique constraint on 'Constance', fields ['key']
+        db.delete_unique('constance_config', ['key'])
+
+        # Changing field 'Constance.key'
+        db.alter_column('constance_config', 'key',
+                        self.gf('django.db.models.fields.TextField')())
+
+    models = {
+        'database.constance': {
+            'Meta': {'object_name': 'Constance',
+                     'db_table': "'constance_config'"},
+            'id': ('django.db.models.fields.AutoField', [],
+                   {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [],
+                    {'unique': 'True', 'max_length': '255'}),
+            'value': ('picklefield.fields.PickledObjectField', [], {})
+        }
+    }
+
+    complete_apps = ['database']

constance/backends/redisd.py

+from django.core.exceptions import ImproperlyConfigured
+from django.utils import six
+from django.utils.six.moves import zip
+
+from . import Backend
+from .. import settings, utils, signals, config
+
+try:
+    from cPickle import loads, dumps
+except ImportError:
+    from pickle import loads, dumps
+
+
+class RedisBackend(Backend):
+
+    def __init__(self):
+        super(RedisBackend, self).__init__()
+        self._prefix = settings.REDIS_PREFIX
+        connection_cls = settings.REDIS_CONNECTION_CLASS
+        if connection_cls is not None:
+            self._rd = utils.import_module_attr(connection_cls)()
+        else:
+            try:
+                import redis
+            except ImportError:
+                raise ImproperlyConfigured(
+                    "The Redis backend requires redis-py to be installed.")
+            if isinstance(settings.REDIS_CONNECTION, six.string_types):
+                self._rd = redis.from_url(settings.REDIS_CONNECTION)
+            else:
+                self._rd = redis.Redis(**settings.REDIS_CONNECTION)
+
+    def add_prefix(self, key):
+        return "%s%s" % (self._prefix, key)
+
+    def get(self, key):
+        value = self._rd.get(self.add_prefix(key))
+        if value:
+            return loads(value)
+        return None
+
+    def mget(self, keys):
+        if not keys:
+            return
+        prefixed_keys = [self.add_prefix(key) for key in keys]
+        for key, value in zip(keys, self._rd.mget(prefixed_keys)):
+            if value:
+                yield key, loads(value)
+
+    def set(self, key, value):
+        old_value = self.get(key)
+        self._rd.set(self.add_prefix(key), dumps(value))
+        signals.config_updated.send(
+            sender=config, key=key, old_value=old_value, new_value=value
+        )

constance/base.py

+from . import settings, utils
+
+
+class Config(object):
+    """
+    The global config wrapper that handles the backend.
+    """
+    def __init__(self):
+        super(Config, self).__setattr__('_backend',
+                                        utils.import_module_attr(settings.BACKEND)())
+
+    def __getattr__(self, key):
+        try:
+            if not len(settings.CONFIG[key]) in (2, 3):
+                raise AttributeError(key)
+            default = settings.CONFIG[key][0]
+        except KeyError:
+            raise AttributeError(key)
+        result = self._backend.get(key)
+        if result is None:
+            result = default
+            setattr(self, key, default)
+            return result
+        return result
+
+    def __setattr__(self, key, value):
+        if key not in settings.CONFIG:
+            raise AttributeError(key)
+        self._backend.set(key, value)
+
+    def __dir__(self):
+        return settings.CONFIG.keys()

constance/context_processors.py

+import constance
+
+
+def config(request):
+    """
+    Simple context processor that puts the config into every
+    RequestContext. Just make sure you have a setting like this:
+
+        TEMPLATE_CONTEXT_PROCESSORS = (
+            # ...
+            'constance.context_processors.config',
+        )
+
+    """
+    return {"config": constance.config}

constance/locale/cs_CZ/LC_MESSAGES/django.po

+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+#
+# Translators:
+msgid ""
+msgstr ""
+"Project-Id-Version: django-constance\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-06-13 19:40+0530\n"
+"PO-Revision-Date: 2014-11-27 18:13+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: Czech (Czech Republic) (http://www.transifex.com/projects/p/"
+"django-constance/language/cs_CZ/)\n"
+"Language: cs_CZ\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;\n"
+
+#: admin.py:113
+#, python-format
+msgid ""
+"Default value type must be equal to declared config parameter type. Please "
+"fix the default value of '%(name)s'."
+msgstr ""
+
+#: admin.py:123
+#, python-format
+msgid ""
+"Constance doesn't support config values of the type %(config_type)s. Please "
+"fix the value of '%(name)s'."
+msgstr ""
+
+#: admin.py:147
+msgid ""
+"The settings have been modified by someone else. Please reload the form and "
+"resubmit your changes."
+msgstr ""
+
+#: admin.py:160
+msgid ""
+"CONSTANCE_CONFIG_FIELDSETS does not contain fields that exist in "
+"CONSTANCE_CONFIG."
+msgstr ""
+
+#: admin.py:224
+msgid "Live settings updated successfully."
+msgstr "Nastavení bylo úspěšně uloženo."
+
+#: admin.py:285
+msgid "config"
+msgstr "nastavení"
+
+#: apps.py:8
+msgid "Constance"
+msgstr ""
+
+#: backends/database/models.py:19
+msgid "constance"
+msgstr "konstanta"
+
+#: backends/database/models.py:20
+msgid "constances"
+msgstr "konstanty"
+
+#: management/commands/constance.py:30
+msgid "Get/Set In-database config settings handled by Constance"
+msgstr ""
+
+#: templates/admin/constance/change_list.html:75
+msgid "Save"
+msgstr "Uložit"
+
+#: templates/admin/constance/change_list.html:84
+msgid "Home"
+msgstr "Domů"
+
+#: templates/admin/constance/includes/results_list.html:5
+msgid "Name"
+msgstr "Název"
+
+#: templates/admin/constance/includes/results_list.html:6
+msgid "Default"
+msgstr "Výchozí hodnota"
+
+#: templates/admin/constance/includes/results_list.html:7
+msgid "Value"
+msgstr "Hodnota"
+
+#: templates/admin/constance/includes/results_list.html:8
+msgid "Is modified"
+msgstr "Je změněna?"
+
+#~ msgid "Constance config"
+#~ msgstr "Nastavení konstant"

constance/locale/de/LC_MESSAGES/django.po

+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+#
+# Translators:
+# Jannis Leidel <jannis@leidel.info>, 2014
+msgid ""
+msgstr ""
+"Project-Id-Version: django-constance\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2017-06-13 19:40+0530\n"
+"PO-Revision-Date: 2014-11-27 18:17+0000\n"
+"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
+"Language-Team: German (http://www.transifex.com/projects/p/django-constance/"
+"language/de/)\n"
+"Language: de\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: admin.py:113
+#, fuzzy, python-format
+#| msgid ""
+#| "Constance doesn't support config values of the type %(config_type)s. "
+#| "Please fix the value of '%(name)s'."
+msgid ""
+"Default value type must be equal to declared config parameter type. Please "
+"fix the default value of '%(name)s'."
+msgstr ""
+"Konstanze unterstützt die Konfigurationswerte vom Typ %(config_type)s nicht. "
+"Bitte den Ausgangswert von '%(name)s' ändern."
+
+#: admin.py:123
+#, python-format
+msgid ""
+"Constance doesn't support config values of the type %(config_type)s. Please "
+"fix the value of '%(name)s'."
+msgstr ""
+"Konstanze unterstützt die Konfigurationswerte vom Typ %(config_type)s nicht. "
+"Bitte den Ausgangswert von '%(name)s' ändern."
+
+#: admin.py:147
+msgid ""
+"The settings have been modified by someone else. Please reload the form and "
+"resubmit your changes."
+msgstr ""
+"Die Konfiguration wurde seit Öffnen dieser Seite verändert. Bitte die Seite "
+"neuladen und die Änderungen erneut vornehmen."
+
+#: admin.py:160
+msgid ""
+"CONSTANCE_CONFIG_FIELDSETS does not contain fields that exist in "
+"CONSTANCE_CONFIG."
+msgstr ""
+
+#: admin.py:224
+msgid "Live settings updated successfully."
+msgstr "Die Livekonfiguration wurde erfolgreich aktualisiert."
+
+#: admin.py:285
+msgid "config"
+msgstr "Konfiguration"
+
+#: apps.py:8
+msgid "Constance"
+msgstr "Konstanze"
+
+#: backends/database/models.py:19
+msgid "constance"
+msgstr "Konstanze"
+
+#: backends/database/models.py:20
+msgid "constances"
+msgstr "Konstanzes"
+
+#: management/commands/constance.py:30
+msgid "Get/Set In-database config settings handled by Constance"
+msgstr ""
+
+#: templates/admin/constance/change_list.html:75
+msgid "Save"
+msgstr "Sichern"
+
+#: templates/admin/constance/change_list.html:84
+msgid "Home"
+msgstr "Start"
+
+#: templates/admin/constance/includes/results_list.html:5
+msgid "Name"
+msgstr "Name"
+
+#: templates/admin/constance/includes/results_list.html:6
+msgid "Default"
+msgstr "Voreinstellung"
+
+#: templates/admin/constance/includes/results_list.html:7
+msgid "Value"
+msgstr "Wert"
+
+#: templates/admin/constance/includes/results_list.html:8
+msgid "Is modified"
+msgstr "Ist modifiziert"
+
+#~ msgid "Constance config"
+#~ msgstr "Constance Konfiguration"