Source code for quade.settings

# This module is inspired by and indebted to Hypothesis' _settings module.
from collections import Iterable
from inspect import cleandoc

from attr import attrib, attrs
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.utils import six
from six import with_metaclass

__all__ = [

class Setting(object):
    """A descriptor that prevents deletion and provides a docstring."""
    name = attrib()
    default = attrib()
    default_description = attrib(default='')
    description = attrib(default='')
    validator = attrib(default=None)

    def __get__(self, obj, objtype=None):
        if obj is None:  # pragma: no cover
            return self
                return obj.__dict__[]
            except KeyError:  # pragma: no cover
                raise AttributeError(

    def __set__(self, obj, value):
        obj.__dict__[] = value

    def __delete__(self, obj):
        raise AttributeError('Cannot delete attribute {}'.format(

    def __doc__(self):
        return "{}\n\nDefault: {}".format(
            self.default_description or '``{}``'.format(self.default)

[docs]class AllEnvs(object): """Enable Quade unconditionally.""" @staticmethod def func(_): return True
[docs]class DebugEnvs(object): """Enable Quade if the environment has DEBUG = True.""" @staticmethod def func(s): return s.DEBUG
[docs]def is_superuser(view): """Allow access to the view if the requesting user is a superuser.""" return view.request.user.is_superuser
all_settings = {} def validate_allowed_envs(val): if any([val in [AllEnvs, DebugEnvs], callable(val), isinstance(val, Iterable)]): return val else: raise TypeError def validate_access_test_func(val): if callable(val): return val else: raise TypeError def validate_boolean(val): if isinstance(val, bool): return val else: raise TypeError class SettingsMeta(type): def __new__(cls, name, bases, dct): obj = super(SettingsMeta, cls).__new__(cls, name, bases, dct) obj.define_setting( name='fixtures_file', default='quade.fixtures', description="""A dotted path to the location of your fixtures.""", ) obj.define_setting( name='allowed_envs', default=DebugEnvs, default_description=""":class:`.DebugEnvs`""", description="""Controls which environments Quade can run on. Allowed values are: - :class:`.DebugEnvs` - :class:`.AllEnvs` - a string -- your ``django.conf.settings.ENV`` is compared exactly to this string - an iterable -- your ``django.conf.settings.ENV`` is checked exactly for membership in the iterable - any callable that accepts one argument, the Django settings object If Quade is not enabled, fixtures will not be loaded, but views will be available to users with appropriate access, application models and tables can be accessed, etc. """, validator=validate_allowed_envs, ) obj.define_setting( name='access_test_func', default=is_superuser, default_description=""":func:`.is_superuser`""", description="""A callable that restricts access to Quade's views. The callable should accept one argument (a Django view class).""", validator=validate_access_test_func ) obj.define_setting( name='use_celery', default=False, description="""Whether to use Celery to set up a Record. Enabling this is useful if your fixtures take a long time to run. See :doc:`celery` for additional details. """, validator=validate_boolean, ) return obj
[docs]class Settings(with_metaclass(SettingsMeta)): _WHITELISTED_PROPERTIES = ['_construction_complete'] def __init__(self, **kwargs): self._construction_complete = False for setting in all_settings.values(): val = kwargs.pop(, setting.default) if setting.validator: try: val = setting.validator(val) except: raise ImproperlyConfigured( "{} is not a valid value for Quade setting {}".format(val, ) setattr(self,, val) if kwargs: suffix = '' if len(kwargs) == 1 else 's' raise AttributeError("No such setting{}: '{}'".format(suffix, "', '".join(kwargs.keys()))) self._construction_complete = True @classmethod def define_setting(cls, name, **kwargs): s = Setting(name, **kwargs) all_settings[name] = s setattr(cls, name, s) @property def allowed(self): """Based on the settings, determine if scenarios are allowed to run on this environment.""" if self.allowed_envs in [AllEnvs, DebugEnvs]: func = self.allowed_envs.func elif callable(self.allowed_envs): func = self.allowed_envs elif isinstance(self.allowed_envs, six.string_types): def func(s): return s.ENV == self.allowed_envs elif isinstance(self.allowed_envs, Iterable): def func(s): return s.ENV in self.allowed_envs if func(settings): return True else: return False def __setattr__(self, key, value): if key in self._WHITELISTED_PROPERTIES: return super(Settings, self).__setattr__(key, value) elif key in all_settings: if self._construction_complete: raise RuntimeError('Quade settings may not be modified during runtime.') else: return super(Settings, self).__setattr__(key, value) else: # pragma: no cover raise AttributeError('No such setting {}'.format(key))