| 1 |
import sys |
| 2 |
|
| 3 |
from django.core.exceptions import ImproperlyConfigured |
| 4 |
|
| 5 |
from .utils import import_attribute |
| 6 |
|
| 7 |
|
| 8 |
class AppConfOptions: |
| 9 |
|
| 10 |
def __init__(self, meta, prefix=None): |
| 11 |
self.prefix = prefix |
| 12 |
self.holder_path = getattr(meta, 'holder', 'django.conf.settings') |
| 13 |
self.holder = import_attribute(self.holder_path) |
| 14 |
self.proxy = getattr(meta, 'proxy', False) |
| 15 |
self.required = getattr(meta, 'required', []) |
| 16 |
self.configured_data = {} |
| 17 |
|
| 18 |
def prefixed_name(self, name): |
| 19 |
if name.startswith(self.prefix.upper()): |
| 20 |
return name |
| 21 |
return "{}_{}".format(self.prefix.upper(), name.upper()) |
| 22 |
|
| 23 |
def contribute_to_class(self, cls, name): |
| 24 |
cls._meta = self |
| 25 |
self.names = {} |
| 26 |
self.defaults = {} |
| 27 |
|
| 28 |
|
| 29 |
class AppConfMetaClass(type): |
| 30 |
|
| 31 |
def __new__(cls, name, bases, attrs): |
| 32 |
super_new = super().__new__ |
| 33 |
parents = [b for b in bases if isinstance(b, AppConfMetaClass)] |
| 34 |
if not parents: |
| 35 |
return super_new(cls, name, bases, attrs) |
| 36 |
|
| 37 |
# Create the class. |
| 38 |
module = attrs.pop('__module__') |
| 39 |
new_class = super_new(cls, name, bases, {'__module__': module}) |
| 40 |
attr_meta = attrs.pop('Meta', None) |
| 41 |
if attr_meta: |
| 42 |
meta = attr_meta |
| 43 |
else: |
| 44 |
attr_meta = type('Meta', (object,), {}) |
| 45 |
meta = getattr(new_class, 'Meta', None) |
| 46 |
|
| 47 |
prefix = getattr(meta, 'prefix', getattr(meta, 'app_label', None)) |
| 48 |
if prefix is None: |
| 49 |
# Figure out the prefix by looking one level up. |
| 50 |
# For 'django.contrib.sites.models', this would be 'sites'. |
| 51 |
model_module = sys.modules[new_class.__module__] |
| 52 |
prefix = model_module.__name__.split('.')[-2] |
| 53 |
|
| 54 |
new_class.add_to_class('_meta', AppConfOptions(meta, prefix)) |
| 55 |
new_class.add_to_class('Meta', attr_meta) |
| 56 |
|
| 57 |
for parent in parents[::-1]: |
| 58 |
if hasattr(parent, '_meta'): |
| 59 |
new_class._meta.names.update(parent._meta.names) |
| 60 |
new_class._meta.defaults.update(parent._meta.defaults) |
| 61 |
new_class._meta.configured_data.update( |
| 62 |
parent._meta.configured_data) |
| 63 |
|
| 64 |
for name in filter(str.isupper, list(attrs.keys())): |
| 65 |
prefixed_name = new_class._meta.prefixed_name(name) |
| 66 |
new_class._meta.names[name] = prefixed_name |
| 67 |
new_class._meta.defaults[prefixed_name] = attrs.pop(name) |
| 68 |
|
| 69 |
# Add all attributes to the class. |
| 70 |
for name, value in attrs.items(): |
| 71 |
new_class.add_to_class(name, value) |
| 72 |
|
| 73 |
new_class._configure() |
| 74 |
for name, value in new_class._meta.configured_data.items(): |
| 75 |
prefixed_name = new_class._meta.prefixed_name(name) |
| 76 |
setattr(new_class._meta.holder, prefixed_name, value) |
| 77 |
new_class.add_to_class(name, value) |
| 78 |
|
| 79 |
# Confirm presence of required settings. |
| 80 |
for name in new_class._meta.required: |
| 81 |
prefixed_name = new_class._meta.prefixed_name(name) |
| 82 |
if not hasattr(new_class._meta.holder, prefixed_name): |
| 83 |
raise ImproperlyConfigured('The required setting %s is' |
| 84 |
' missing.' % prefixed_name) |
| 85 |
|
| 86 |
return new_class |
| 87 |
|
| 88 |
def add_to_class(cls, name, value): |
| 89 |
if hasattr(value, 'contribute_to_class'): |
| 90 |
value.contribute_to_class(cls, name) |
| 91 |
else: |
| 92 |
setattr(cls, name, value) |
| 93 |
|
| 94 |
def _configure(cls): |
| 95 |
# the ad-hoc settings class instance used to configure each value |
| 96 |
obj = cls() |
| 97 |
for name, prefixed_name in obj._meta.names.items(): |
| 98 |
default_value = obj._meta.defaults.get(prefixed_name) |
| 99 |
value = getattr(obj._meta.holder, prefixed_name, default_value) |
| 100 |
callback = getattr(obj, "configure_%s" % name.lower(), None) |
| 101 |
if callable(callback): |
| 102 |
value = callback(value) |
| 103 |
cls._meta.configured_data[name] = value |
| 104 |
cls._meta.configured_data = obj.configure() |
| 105 |
|
| 106 |
|
| 107 |
class AppConf(metaclass=AppConfMetaClass): |
| 108 |
""" |
| 109 |
An app setting object to be used for handling app setting defaults |
| 110 |
gracefully and providing a nice API for them. |
| 111 |
""" |
| 112 |
def __init__(self, **kwargs): |
| 113 |
for name, value in kwargs.items(): |
| 114 |
setattr(self, name, value) |
| 115 |
|
| 116 |
def __dir__(self): |
| 117 |
return sorted(set(self._meta.names.keys())) |
| 118 |
|
| 119 |
# For instance access.. |
| 120 |
@property |
| 121 |
def configured_data(self): |
| 122 |
return self._meta.configured_data |
| 123 |
|
| 124 |
def __getattr__(self, name): |
| 125 |
if self._meta.proxy: |
| 126 |
return getattr(self._meta.holder, name) |
| 127 |
raise AttributeError("%s not found. Use '%s' instead." % |
| 128 |
(name, self._meta.holder_path)) |
| 129 |
|
| 130 |
def __setattr__(self, name, value): |
| 131 |
if name == name.upper(): |
| 132 |
setattr(self._meta.holder, |
| 133 |
self._meta.prefixed_name(name), value) |
| 134 |
object.__setattr__(self, name, value) |
| 135 |
|
| 136 |
def configure(self): |
| 137 |
""" |
| 138 |
Hook for doing any extra configuration, returning a dictionary |
| 139 |
containing the configured data. |
| 140 |
""" |
| 141 |
return self.configured_data |