/usr/lib/python2.7/dist-packages/feincms/extensions.py is in python-django-feincms 1.7.4-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 | """
Base types for extensions refactor
"""
import re
import warnings
from django.contrib import admin
from django.core.exceptions import ImproperlyConfigured
from feincms.utils import get_object
class ExtensionsMixin(object):
@property
def _feincms_extensions(self):
warnings.warn(
'Start using _extensions instead of _feincms_extensions'
' today!',
DeprecationWarning, stacklevel=2)
return set(self._extensions)
@classmethod
def register_extensions(cls, *extensions):
"""
Register all extensions passed as arguments.
Extensions should be specified as a string to the python module
containing the extension. If it is a bundled extension of FeinCMS,
you do not need to specify the full python module path -- only
specifying the last part (f.e. ``'seo'`` or ``'translations'``) is
sufficient.
"""
if not hasattr(cls, '_extensions'):
cls._extensions = []
cls._extensions_seen = []
here = cls.__module__.split('.')[:-1]
search_paths = [
'.'.join(here + ['extensions']),
'.'.join(here[:-1] + ['extensions']),
'feincms.module.extensions',
]
for ext in extensions:
if ext in cls._extensions:
continue
extension = None
if isinstance(ext, basestring):
paths = [ext, '%s.register' % ext]
for path in search_paths:
paths.extend([
'%s.%s.register' % (path, ext),
'%s.%s' % (path, ext),
])
for idx, path in enumerate(paths):
try:
extension = get_object(path)
if idx >= 2:
warnings.warn(
'Using short names for extensions has been'
' deprecated and will be removed in'
' FeinCMS v1.8. Please provide the full'
' python path to the extension'
' %s instead (%s).' % (
ext,
re.sub(r'\.register$', '', path),
),
DeprecationWarning, stacklevel=2)
break
except (AttributeError, ImportError, ValueError):
pass
if not extension:
raise ImproperlyConfigured(
'%s is not a valid extension for %s' % (
ext, cls.__name__))
if hasattr(extension, 'Extension'):
extension = extension.Extension
elif hasattr(extension, 'register'):
extension = extension.register
elif hasattr(extension, '__call__'):
pass
else:
raise ImproperlyConfigured(
'%s is not a valid extension for %s' % (
ext, cls.__name__))
if extension in cls._extensions_seen:
continue
cls._extensions_seen.append(extension)
if hasattr(extension, 'handle_model'):
cls._extensions.append(extension(cls))
else:
cls._extensions.append(LegacyExtension(cls, extension=extension))
class Extension(object):
def __init__(self, model, **kwargs):
self.model = model
for key, value in kwargs.items():
if not hasattr(self, key):
raise TypeError('%s() received an invalid keyword %r' % (
self.__class__.__name__, key))
setattr(self, key, value)
self.handle_model()
def handle_model(self):
raise NotImplementedError
def handle_modeladmin(self, modeladmin):
pass
class LegacyExtension(Extension):
"""
Wrapper for legacy extensions
"""
#: Legacy extension function
extension = None
def handle_model(self):
self.fieldsets = []
self.filter_horizontal = []
self.filter_vertical = []
self.list_display = []
self.list_filter = []
self.raw_id_fields = []
self.search_fields = []
self.extension_options = []
self.known_keys = self.__dict__.keys()
self.extension(self.model, self)
def handle_modeladmin(self, modeladmin):
if self.fieldsets:
modeladmin.fieldsets.extend(self.fieldsets)
if self.filter_horizontal:
modeladmin.filter_horizontal.extend(self.filter_horizontal)
if self.filter_vertical:
modeladmin.filter_vertical.extend(self.filter_vertical)
if self.list_display:
modeladmin.list_display.extend(self.list_display)
if self.list_filter:
modeladmin.list_filter.extend(self.list_filter)
if self.raw_id_fields:
modeladmin.raw_id_fields.extend(self.raw_id_fields)
if self.search_fields:
modeladmin.search_fields.extend(self.search_fields)
if self.extension_options:
for f in self.extension_options:
modeladmin.add_extension_options(*f)
for key, value in self.__dict__.items():
if key not in self.known_keys:
setattr(modeladmin.__class__, key, value)
def add_extension_options(self, *f):
if f:
self.extension_options.append(f)
class ExtensionModelAdmin(admin.ModelAdmin):
def __init__(self, *args, **kwargs):
super(ExtensionModelAdmin, self).__init__(*args, **kwargs)
self.initialize_extensions()
def initialize_extensions(self):
if not hasattr(self, '_extensions_initialized'):
self._extensions_initialized = True
for extension in getattr(self.model, '_extensions', []):
extension.handle_modeladmin(self)
def add_extension_options(self, *f):
if self.fieldsets is None:
return
if isinstance(f[-1], dict): # called with a fieldset
self.fieldsets.insert(self.fieldset_insertion_index, f)
f[1]['classes'] = list(f[1].get('classes', []))
f[1]['classes'].append('collapse')
elif f: # assume called with "other" fields
try:
self.fieldsets[1][1]['fields'].extend(f)
except IndexError:
# Fall back to first fieldset if second does not exist
# XXX This is really messy.
self.fieldsets[0][1]['fields'].extend(f)
|