def handle(self, *args, **kwargs):
# Initialize pubsub helper.
pubsub = PubSub()
if DIRECTOR_ENABLED:
logger.info('Starting director.')
pubsub.init_director()
if FORWARDER_ENABLED:
logger.info('Starting forwarder.')
pubsub.init_forwarder()
# Get factories for connection and tornado webapp.
authenticator_factory = import_string(AUTHENTICATOR_FACTORY)
connection_factory = import_string(CONNECTION_FACTORY)
webapp_factory = import_string(WEBAPP_FACTORY)
# Create app and listen on SEVER_PORT
app = webapp_factory(connection_factory(authenticator_factory(), pubsub))
app.listen(SERVER_PORT)
loop = ioloop.IOLoop().instance()
try:
logger.info('Starting omnibusd.')
loop.start()
except KeyboardInterrupt:
logger.info('Received KeyboardInterrup, stopping omnibusd.')
loop.stop()
def import_named(course, path):
if path.startswith('.'):
try:
return import_string('exercises.' + course['key'] + path)
except:
return import_string('courses.' + course['key'] + path)
return import_string(path)
def validate_value(self, document_type, value):
# Check default
if not value and self.default:
value = self.get_default_value()
if not value and self.get_required_for(document_type=document_type):
raise ValidationError(
_('This metadata is required for this document type.')
)
if self.lookup:
lookup_options = self.get_lookup_values()
if value not in lookup_options:
raise ValidationError(
_('Value is not one of the provided options.')
)
if self.validation:
validator = import_string(self.validation)()
validator.validate(value)
if self.parser:
parser = import_string(self.parser)()
value = parser.parse(value)
return value
def __init__(self, server, params, backend):
self._backend = backend
self._server = server
self._params = params
self.reverse_key = get_key_func(
params.get("REVERSE_KEY_FUNCTION") or "django_redis.util.default_reverse_key"
)
if not self._server:
raise ImproperlyConfigured("Missing connections string")
if not isinstance(self._server, (list, tuple, set)):
self._server = self._server.split(",")
self._clients = [None] * len(self._server)
self._options = params.get("OPTIONS", {})
self._slave_read_only = self._options.get('SLAVE_READ_ONLY', True)
serializer_path = self._options.get("SERIALIZER", "django_redis.serializers.pickle.PickleSerializer")
serializer_cls = import_string(serializer_path)
compressor_path = self._options.get("COMPRESSOR", "django_redis.compressors.identity.IdentityCompressor")
compressor_cls = import_string(compressor_path)
self._serializer = serializer_cls(options=self._options)
self._compressor = compressor_cls(options=self._options)
self.connection_factory = pool.get_connection_factory(options=self._options)
def fire(signal_name, obj=None, namespace="aristotle_mdr.contrib.async_signals", **kwargs):
from django.utils.module_loading import import_string
message = kwargs
if getattr(settings, 'ARISTOTLE_ASYNC_SIGNALS', False):
# pragma: no cover -- We've dropped channels, and are awaiting (pun) on celery stuff
message.update({
'__object__': {
'pk': obj.pk,
'app_label': obj._meta.app_label,
'model_name': obj._meta.model_name,
},
# "__signal__": signal_name,
})
from aristotle_bg_workers.celery import app
message = clean_signal(message)
app.send_task(
'fire_async_signal',
args=[namespace, signal_name],
kwargs={"message": message}
)
# Channel("aristotle_mdr.contrib.channels.%s" % signal_name).send(message)
else:
message.update({'__object__': {'object': obj}})
import_string("%s.%s" % (namespace, signal_name))(message)
def __init__(self, params):
params = params.copy()
options = params.pop('OPTIONS').copy()
super(MakoTemplates, self).__init__(params)
environment = options.pop('environment', 'mako.lookup.TemplateLookup')
environment_cls = import_string(environment)
options.setdefault('collection_size', 5000)
options.setdefault('module_directory', tempfile.gettempdir())
options.setdefault('output_encoding', 'utf-8')
options.setdefault('encoding_errors', 'replace')
options.setdefault('filesystem_checks', True)
options.setdefault('directories', self.template_dirs)
context_option = options.pop('context', None)
if context_option is not None:
if type(context_option) == dict:
self.tpls_context.update(context_option)
elif isinstance(context_option, six.string_types):
default_context = import_string(context_option)
if type(default_context) == dict:
self.tpls_context.update(default_context)
self.lookup = environment_cls(**options)
def __init__(self):
# Import it in constructor instead of module so it won't fail at import even if django is not installed.
from django.conf import settings
from django.utils.module_loading import import_string
try:
container = settings.SERVICE_CONTAINER
except (AttributeError, NameError) as e:
try:
container_class = settings.SERVICE_CONTAINER_CLASS
except (AttributeError, NameError) as e:
container_class = 'rdc.dic.Container'
# If we got a string, import it.
if isinstance(container_class, six.string_types):
container_class = import_string(container_class)
container = container_class()
# If we got a string, import it.
if isinstance(container, six.string_types):
container = import_string(container)
assert isinstance(container, Container), ('I tried my best to find your container but I got stuck. Either set '
'SERVICE_CONTAINER_CLASS to a container factory or SERVICE_CONTAINER '
'to a container instance. Thanks, bye.')
self.container = container
if not 'request' in self.container.scopes:
self.container.scopes['request'] = NamespacedScope()
def get_connection(backend=None, template_prefix=None, template_suffix=None,
fail_silently=False, **kwargs):
"""Load a templated e-mail backend and return an instance of it.
If backend is None (default) settings.TEMPLATED_EMAIL_BACKEND is used.
Both fail_silently and other keyword arguments are used in the
constructor of the backend.
"""
# This method is mostly a copy of the backend loader present in
# django.core.mail.get_connection
klass_path = backend or getattr(settings, 'TEMPLATED_EMAIL_BACKEND',
TemplateBackend)
if isinstance(klass_path, six.string_types):
try:
# First check if class name is omitted and we have module in settings
klass = import_string(klass_path + '.' + 'TemplateBackend')
except ImportError:
# Fallback to class name
klass = import_string(klass_path)
else:
klass = klass_path
return klass(fail_silently=fail_silently, template_prefix=template_prefix,
template_suffix=template_suffix, **kwargs)
def get_inline_classes(obj):
"""Get the proper inline classes for the current object.
:param obj: The object to get inline classes for.
"""
if not obj:
return []
inlines = []
for m in PAGE_MODEL_CLASSES:
# Get the page inline
page_inline = getattr(m, 'admin_page_inline', GenericPageInline)
if isinstance(page_inline, six.string_types):
page_inline = import_string(page_inline)
if getattr(m, 'identifier', None) == obj.template:
page_inline.model = m
inlines.append(page_inline)
# Add other inlines if defined
for inline in getattr(m, 'admin_inlines', []):
if isinstance(inline, six.string_types):
inline = import_string(inline)
inlines.append(inline)
return inlines
def __init__(self, *args, **kwargs):
super(DatabaseWrapper, self).__init__(*args, **kwargs)
self.db_config = args[0]
client_class = self.db_config['CLIENT']
client_class = import_string(client_class)
self.db_name = self.db_config['NAME']
self.client = client_class(self.db_config)
schema_module = self.db_config.get('SCHEMA', None)
self.migrations = self.db_config.get('MIGRATIONS', False)
if schema_module:
self.SchemaEditorClass = import_string(schema_module + '.DatabaseSchemaEditor')
self._cache = import_module(self.client.compiler_module)
self.ops = DatabaseOperations(self, cache=self._cache)
self.creation = DatabaseCreation(self)
self.features = DatabaseFeatures(self)
self.validation = BaseDatabaseValidation(self)
introspection_module = self.db_config.get('INTROSPECTION', None)
if introspection_module:
self.introspectionClass = import_string(introspection_module + '.DatabaseIntrospection')
self.introspection = self.introspectionClass(self)
else:
self.introspection = DatabaseIntrospection(self)
logger.debug('Initialized django_any_backend. Compiler is %s. Client is %s.'
% (self.client.compiler_module, client_class))
logger.debug('DB_config: %s' % self.db_config)
def get_custom_field_mapping(cls):
"""
Class method for getting custom, user defined, field mappings
:return: Field mapping dict where the key is a model field class and the value is an OmniField subclass
"""
field_mapping = {}
custom_fields = getattr(settings, 'OMNI_FORMS_CUSTOM_FIELD_MAPPING', {})
for key, value in custom_fields.items():
try:
field_mapping_key = import_string(key)
except ImportError:
raise ImproperlyConfigured(
'Could not import \'{0}\' from settings.OMNI_FORMS_CUSTOM_FIELD_MAPPING '
'Please update your settings file'.format(key)
)
try:
field_mapping_value = import_string(value)
except ImportError:
raise ImproperlyConfigured(
'Could not import \'{0}\' from \'settings.OMNI_FORMS_CUSTOM_FIELD_MAPPING[{1}].\''
'Please update your settings file'.format(value, key)
)
else:
if not issubclass(field_mapping_value, OmniField):
raise ImproperlyConfigured('\'{0}\' defined in OMNI_FORMS_CUSTOM_FIELD_MAPPING must be a '
'subclass of omniforms.models.OmniField'.format(value))
field_mapping[field_mapping_key] = field_mapping_value
return field_mapping
def sync_ldap_users(self, ldap_users):
"""Synchronize users with local user model."""
ldap_usernames = set()
for cname, ldap_attributes in ldap_users:
defaults = {}
if not isinstance(ldap_attributes, dict):
# In some cases attributes is not a dict; skip these invalid users
continue
for ldap_name, field in self.settings.USER_ATTRIBUTES.items():
try:
defaults[field] = ldap_attributes[ldap_name][0].decode('utf-8')
except KeyError:
defaults[field] = ''
username = defaults[self.settings.USERNAME_FIELD].lower()
kwargs = {
self.settings.USERNAME_FIELD + '__iexact': username,
'defaults': defaults,
}
try:
user, created = self.settings.model.objects.get_or_create(**kwargs)
except (IntegrityError, DataError) as e:
logger.error("Error creating user %s: %s" % (username, e))
else:
updated = False
if created:
logger.debug("Created user %s" % username)
user.set_unusable_password()
else:
for name, attr in defaults.items():
current_attr = getattr(user, name, None)
if current_attr != attr:
setattr(user, name, attr)
updated = True
if updated:
logger.debug("Updated user %s" % username)
for path in self.settings.USER_CALLBACKS:
callback = import_string(path)
callback(user, ldap_attributes, created, updated)
user.save()
if self.settings.REMOVED_USER_CALLBACKS:
ldap_usernames.add(username)
if self.settings.REMOVED_USER_CALLBACKS:
django_usernames = set(self.settings.model.objects.values_list(self.settings.USERNAME_FIELD, flat=True))
for username in django_usernames - ldap_usernames:
user = self.settings.model.objects.get(**{self.settings.USERNAME_FIELD: username})
for path in self.settings.REMOVED_USER_CALLBACKS:
callback = import_string(path)
callback(user)
logger.debug("Called %s for user %s" % (path, username))
logger.info("Users are synchronized")
def environment(**options):
extra_globals = options.pop('extra_globals', {})
extra_filters = options.pop('extra_filters', {})
extensions = ['jinja2.ext.i18n',
'jinja2.ext.with_']
env = jinja2.Environment(**options, extensions=extensions)
env.install_gettext_translations(translation, newstyle=True)
env.globals.update({
'messages': get_messages,
'static': staticfiles_storage.url,
'url': url,
'csrf': csrf,
})
env.globals.update({
k: import_string(v) for k, v in extra_globals.items()
})
env.filters.update({
'pie': pie,
'textdiff': textdiff,
'unidiff': unidiff,
'format_datedelta': format_datedelta,
'format_timedelta': format_timedelta,
'format_datetime': format_datetime,
'format_date': format_date,
'decode_json': decode_json,
'markdown_safe': markdown_safe,
'is_youtube_link': is_youtube_link,
'get_youtube_embed_link': get_youtube_embed_link,
'is_yamusic_link': is_yamusic_link,
'get_yamusic_embed_link': get_yamusic_embed_link,
})
env.filters.update({
k: import_string(v) for k, v in extra_filters.items()
})
return env
def __init__(self, *args, **kwargs):
self.schema = kwargs.pop('schema')
super(DynamicFormMixin, self).__init__(*args, **kwargs)
widgets = self.schema.get('widgets', {})
field_order = self.schema.get(
'field_order', self.schema['fields'].keys()
)
for field_name in field_order:
field_data = self.schema['fields'][field_name]
field_class = import_string(field_data['class'])
kwargs = {
'label': field_data['label'],
'required': field_data.get('required', True),
'initial': field_data.get('default', None),
'help_text': field_data.get('help_text'),
}
if widgets and field_name in widgets:
widget = widgets[field_name]
kwargs['widget'] = import_string(
widget['class']
)(**widget.get('kwargs', {}))
kwargs.update(field_data.get('kwargs', {}))
self.fields[field_name] = field_class(**kwargs)
def handle(self, comment, *args, **options):
items = {}
created_count = 0
from django.conf import settings
translation.activate(settings.LANGUAGE_CODE)
for key, import_path in STAT_METRICS.items():
f = import_string(import_path)
name = getattr(f, 'name', key)
description = getattr(f, 'description', import_path)
item, created = Item.objects.get_or_create(key=key, defaults={'name': name, 'description': description})
if created:
created_count += 1
items[key] = item
self.stdout.write("Registered {} new items.".format(created_count))
values = []
start = monotonic()
time = now()
for key, import_path in STAT_METRICS.items():
f = import_string(import_path)
values.append(Value(item=items[key], time=time, value=f()))
end = int(monotonic() - start)
desc = _("Time (seconds) in which metric statistical information was collected.")
system_item, created = Item.objects.get_or_create(key='stats.collect_time',
defaults={'name': _("Time to calculate statistics"),
'description': desc})
values.append(Value(item=system_item, time=time, value=end))
with transaction.atomic():
Value.objects.bulk_create(values)
Item.objects.filter(pk__in=[value.item.pk for value in values]).update(last_updated=now())
self.stdout.write("Registered {} values.".format(len(values)))
translation.deactivate()
def __init__(self):
# Lazily import to avoid dependency
from .tasks import send
self.send = send
# Check we can import our specified backend up-front
import_string(app_settings.BACKEND_FOR_QUEUE)()
def add_serializer(cls, klass, serializer_class):
if isinstance(klass, string_types):
klass = import_string(klass)
if isinstance(serializer_class, string_types):
serializer_class = import_string(serializer_class)
cls.serializers[klass] = serializer_class
def __init__(self, worker, **kwargs):
"""
:param worker: celery worker
"""
worker.app.listenclosely_app = ListenCloselyApp(import_string(conf.LISTENCLOSELY_MESSAGE_SERVICE_BACKEND),
import_string(conf.LISTENCLOSELY_AGENT_STRATEGY),
int(conf.LISTENCLOSELY_QUERY_TIME_OBSOLETE))
logger.info("Listenclosely App initialized")
def _perform_import(self, value, setting_name):
try:
if isinstance(value, six.string_types):
return import_string(value)
elif isinstance(value, (list, tuple)):
return [import_string(item) for item in value]
except (ImportError, ImproperlyConfigured) as e:
raise ImportError("Could not import module '{}' "
"(Have you checked the setting '{}' for app '{}'?): {}".format(value, self._user_settings_key, setting_name, e))
def get_converted_widget(self, widgets_module):
if not isinstance(self.widget, widgets.CheckboxSelectMultiple):
return
try:
new_widget = import_string(widgets_module + '.CheckboxSelectMultiple')()
except ImportError:
new_widget = import_string('djng.forms.widgets.CheckboxSelectMultiple')()
new_widget.__dict__ = self.widget.__dict__
return new_widget
def __init__(self, *args, **kwargs):
"""
Patch constructor
"""
self._cache = caches[settings.CACHE]
self._buffer_storage = import_string(settings.BUFFER)(
**settings.BUFFER_KWARGS)
self._remote_storage = import_string(settings.REMOTE)()
super(ManifestStorage, self).__init__(*args, **kwargs)
def test_import_string(self):
cls = import_string('django.utils.module_loading.import_string')
self.assertEqual(cls, import_string)
# Test exceptions raised
self.assertRaises(ImportError, import_string, 'no_dots_in_path')
msg = 'Module "utils_tests" does not define a "unexistent" attribute'
with six.assertRaisesRegex(self, ImportError, msg):
import_string('utils_tests.unexistent')
def get_converted_widget(self, widgets_module):
if not isinstance(self.widget, widgets.CheckboxInput):
return
try:
new_widget = import_string(widgets_module + '.CheckboxInput')(self.label)
except ImportError:
new_widget = import_string('djng.forms.widgets.CheckboxInput')(self.label)
new_widget.__dict__.update(self.widget.__dict__)
return new_widget
def get_rich_text_editor_widget(name='default'):
editor_settings = getattr(settings, 'WAGTAILADMIN_RICH_TEXT_EDITORS', DEFAULT_RICH_TEXT_EDITORS)
editor = editor_settings[name]
options = editor.get('OPTIONS', None)
if options is None:
return import_string(editor['WIDGET'])()
return import_string(editor['WIDGET'])(options=options)
def test_import_string(self):
cls = import_string("django.utils.module_loading.import_string")
self.assertEqual(cls, import_string)
# Test exceptions raised
with self.assertRaises(ImportError):
import_string("no_dots_in_path")
msg = 'Module "utils_tests" does not define a "unexistent" attribute'
with self.assertRaisesMessage(ImportError, msg):
import_string("utils_tests.unexistent")
def reconstruct_manager(mgr):
as_manager, manager_path, qs_path, args, kwargs = mgr.deconstruct()
if as_manager:
qs_class = import_string(qs_path)
instance = qs_class.as_manager()
else:
manager_class = import_string(manager_path)
instance = manager_class(*args, **kwargs)
# We rely on the ordering of the creation_counter of the original
# instance
managers[mgr.name] = (mgr.creation_counter, instance)
def get_storage(type):
if type=='BaseImage':
storage = import_string(settings.IMAGE_STORAGE)()
elif type=='BaseSecureImage':
storage = import_string(settings.SECURE_IMAGE_STORAGE)()
elif type=='BaseMedia':
storage = import_string(settings.MEDIA_STORAGE)()
elif type=='BaseSecureMedia':
storage = import_string(settings.SECURE_MEDIA_STORAGE)()
return storage
def reload_config(backend=None):
global _backend_str
global _backend
global _notifier
if backend is not None:
_backend = import_string(backend)
_notifier = _backend()
else:
_backend_str = getattr(settings, 'MEMNOTIFY_BACKEND', _DEFAULT_BACKEND)
_backend = import_string(_backend_str or _DEFAULT_BACKEND)
_notifier = _backend()
def construct_managers(self):
"Deep-clone the managers using deconstruction"
# Sort all managers by their creation counter
sorted_managers = sorted(self.managers, key=lambda v: v[1].creation_counter)
for mgr_name, manager in sorted_managers:
as_manager, manager_path, qs_path, args, kwargs = manager.deconstruct()
if as_manager:
qs_class = import_string(qs_path)
yield mgr_name, qs_class.as_manager()
else:
manager_class = import_string(manager_path)
yield mgr_name, manager_class(*args, **kwargs)
def __init__(self, options):
pool_cls_path = options.get("CONNECTION_POOL_CLASS",
"redis.connection.ConnectionPool")
self.pool_cls = import_string(pool_cls_path)
self.pool_cls_kwargs = options.get("CONNECTION_POOL_KWARGS", {})
redis_client_cls_path = options.get("REDIS_CLIENT_CLASS",
"redis.client.StrictRedis")
self.redis_client_cls = import_string(redis_client_cls_path)
self.redis_client_cls_kwargs = options.get("REDIS_CLIENT_KWARGS", {})
self.options = options
def from_model(cls, model, exclude_rels=False):
"""
Feed me a model, get a ModelState representing it out.
"""
# Deconstruct the fields
fields = []
for field in model._meta.local_fields:
if getattr(field, "rel", None) and exclude_rels:
continue
if isinstance(field, OrderWrt):
continue
name, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
try:
fields.append((name, field_class(*args, **kwargs)))
except TypeError as e:
raise TypeError("Couldn't reconstruct field %s on %s.%s: %s" %
(
name,
model._meta.app_label,
model._meta.object_name,
e,
))
if not exclude_rels:
for field in model._meta.local_many_to_many:
name, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
try:
fields.append((name, field_class(*args, **kwargs)))
except TypeError as e:
raise TypeError(
"Couldn't reconstruct m2m field %s on %s: %s" % (
name,
model._meta.object_name,
e,
))
# Extract the options
options = {}
for name in DEFAULT_NAMES:
# Ignore some special options
if name in ["apps", "app_label"]:
continue
elif name in model._meta.original_attrs:
if name == "unique_together":
ut = model._meta.original_attrs["unique_together"]
options[name] = set(normalize_together(ut))
elif name == "index_together":
it = model._meta.original_attrs["index_together"]
options[name] = set(normalize_together(it))
else:
options[name] = model._meta.original_attrs[name]
# Force-convert all options to text_type (#23226)
options = cls.force_text_recursive(options)
# If we're ignoring relationships, remove all field-listing model
# options (that option basically just means "make a stub model")
if exclude_rels:
for key in [
"unique_together", "index_together",
"order_with_respect_to"
]:
if key in options:
del options[key]
def flatten_bases(model):
bases = []
for base in model.__bases__:
if hasattr(base, "_meta") and base._meta.abstract:
bases.extend(flatten_bases(base))
else:
bases.append(base)
return bases
# We can't rely on __mro__ directly because we only want to flatten
# abstract models and not the whole tree. However by recursing on
# __bases__ we may end up with duplicates and ordering issues, we
# therefore discard any duplicates and reorder the bases according
# to their index in the MRO.
flattened_bases = sorted(set(flatten_bases(model)),
key=lambda x: model.__mro__.index(x))
# Make our record
bases = tuple(
("%s.%s" %
(base._meta.app_label,
base._meta.model_name) if hasattr(base, "_meta") else base)
for base in flattened_bases)
# Ensure at least one base inherits from models.Model
if not any((isinstance(base, six.string_types)
or issubclass(base, models.Model)) for base in bases):
bases = (models.Model, )
return cls(
model._meta.app_label,
model._meta.object_name,
fields,
options,
bases,
)
def import_webdriver(cls, browser):
return import_string("selenium.webdriver.%s.webdriver.WebDriver" %
browser)
def get_cookie_signer(salt="django.core.signing.get_cookie_signer"):
Signer = import_string(settings.SIGNING_BACKEND)
key = force_bytes(settings.SECRET_KEY) # SECRET_KEY may be str or bytes.
return Signer(b"django.http.cookies" + key, salt=salt)
def factory(cls, view, **attributes):
if isinstance(view, str):
view = import_string(view)
return type(view.__name__, (view, cls), attributes)
def _improve_attribute_docs(obj, name, lines):
"""Improve the documentation of various attributes.
This improves the navigation between related objects.
:param obj: the instance of the object to document.
:param name: full dotted path to the object.
:param lines: expected documentation lines.
"""
if obj is None:
# Happens with form attributes.
return
if isinstance(obj, DeferredAttribute):
# This only points to a field name, not a field.
# Get the field by importing the name.
cls_path, field_name = name.rsplit(".", 1)
model = import_string(cls_path)
field = None
if django.VERSION >= (3, 0):
field = field = model._meta.get_field(obj.field.name)
else:
field = model._meta.get_field(obj.field_name)
del lines[:] # lines.clear() is Python 3 only
lines.append(
"**Model field:** {label}".format(label=field.verbose_name))
elif isinstance(obj, _FIELD_DESCRIPTORS):
# These
del lines[:]
lines.append(
"**Model field:** {label}".format(label=obj.field.verbose_name))
if isinstance(obj, FileDescriptor):
lines.append(
"**Return type:** :class:`~django.db.models.fields.files.FieldFile`"
)
elif PhoneNumberDescriptor is not None and isinstance(
obj, PhoneNumberDescriptor):
lines.append(
"**Return type:** :class:`~phonenumber_field.phonenumber.PhoneNumber`"
)
elif isinstance(obj, related_descriptors.ForwardManyToOneDescriptor):
# Display a reasonable output for forward descriptors.
related_model = obj.field.remote_field.model
if isinstance(related_model, str):
cls_path = related_model
else:
cls_path = "{}.{}".format(related_model.__module__,
related_model.__name__)
del lines[:]
lines.append("**Model field:** {label}, "
"accesses the :class:`~{cls_path}` model.".format(
label=obj.field.verbose_name, cls_path=cls_path))
elif isinstance(obj, related_descriptors.ReverseOneToOneDescriptor):
related_model = obj.related.related_model
if isinstance(related_model, str):
cls_path = related_model
else:
cls_path = "{}.{}".format(related_model.__module__,
related_model.__name__)
del lines[:]
lines.append("**Model field:** {label}, "
"accesses the :class:`~{cls_path}` model.".format(
label=obj.related.field.verbose_name,
cls_path=cls_path))
elif isinstance(obj, related_descriptors.ReverseManyToOneDescriptor):
related_model = obj.rel.related_model
if isinstance(related_model, str):
cls_path = related_model
else:
cls_path = "{}.{}".format(related_model.__module__,
related_model.__name__)
del lines[:]
lines.append("**Model field:** {label}, "
"accesses the M2M :class:`~{cls_path}` model.".format(
label=obj.field.verbose_name, cls_path=cls_path))
elif isinstance(obj, (models.Manager, ManagerDescriptor)):
# Somehow the 'objects' manager doesn't pass through the docstrings.
module, cls_name, field_name = name.rsplit(".", 2)
lines.append("Django manager to access the ORM")
tpl = "Use ``{cls_name}.objects.all()`` to fetch all objects."
lines.append(tpl.format(cls_name=cls_name))
def get_storage_class(import_path=None):
return import_string(import_path or settings.DEFAULT_FILE_STORAGE)
'''
Admin configuration for PlainUser
'''
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.utils.translation import ugettext_lazy as _
from .forms import PlainUserChangeForm, PlainUserCreationForm
from django.utils.module_loading import import_string
from django.conf import settings
USER_MODEL_PATH = getattr(settings, 'USER_MODEL_PATH',
'accounts.models.PlainUser')
AUTH_USER_MODEL = import_string(USER_MODEL_PATH)
class PlainUserAdmin(UserAdmin):
#user_fields = tuple(['email', 'password1', 'password2'] + PlainUser.REQUIRED_FIELDS)
fieldsets = (
(None, {
'fields':
tuple(['email', 'password'] + AUTH_USER_MODEL.REQUIRED_FIELDS)
}),
(_('Permissions'), {
'fields': ('is_active', 'is_staff', 'is_superuser', 'groups',
'user_permissions')
}),
(_('Important dates'), {
'fields': ('last_login', 'date_joined')
}),
def get_cookie_signer(salt='django.core.signing.get_cookie_signer'):
Signer = import_string(settings.SIGNING_BACKEND)
key = force_bytes(settings.SECRET_KEY)
return Signer(b'django.http.cookies' + key, salt=salt)
def connector_class(self):
return import_string(getattr(self, self._connector_field))
def test_default_backend(self):
default_backend = import_string(ChatworkConfig.DEFAULT_BACKEND)
self.assertEqual(get_backend(), default_backend)
def get_exporter_class(format_):
class_str = dict(settings.EXPLORER_DATA_EXPORTERS)[f"{format_}"]
return import_string(class_str)
def acs(r):
saml_client = _get_saml_client(get_current_domain(r))
resp = r.POST.get('SAMLResponse', None)
next_url = r.session.get('login_next_url', _default_next_url())
if not resp:
return HttpResponseRedirect(get_reverse([denied, 'denied', 'django_saml2_auth:denied']))
authn_response = saml_client.parse_authn_request_response(
resp, entity.BINDING_HTTP_POST)
if authn_response is None:
return HttpResponseRedirect(get_reverse([denied, 'denied', 'django_saml2_auth:denied']))
user_identity = authn_response.get_identity()
if user_identity is None:
return HttpResponseRedirect(get_reverse([denied, 'denied', 'django_saml2_auth:denied']))
user_email = user_identity[settings.SAML2_AUTH.get('ATTRIBUTES_MAP', {}).get('email', 'Email')][0]
user_name = user_identity[settings.SAML2_AUTH.get('ATTRIBUTES_MAP', {}).get('username', 'UserName')][0]
user_first_name = user_identity[settings.SAML2_AUTH.get('ATTRIBUTES_MAP', {}).get('first_name', 'FirstName')][0]
user_last_name = user_identity[settings.SAML2_AUTH.get('ATTRIBUTES_MAP', {}).get('last_name', 'LastName')][0]
target_user = None
is_new_user = False
try:
target_user = User.objects.get(username=user_name)
if settings.SAML2_AUTH.get('TRIGGER', {}).get('BEFORE_LOGIN', None):
import_string(settings.SAML2_AUTH['TRIGGER']['BEFORE_LOGIN'])(user_identity)
except User.DoesNotExist:
new_user_should_be_created = settings.SAML2_AUTH.get('CREATE_USER', True)
if new_user_should_be_created:
target_user = _create_new_user(user_name, user_email, user_first_name, user_last_name)
if settings.SAML2_AUTH.get('TRIGGER', {}).get('CREATE_USER', None):
import_string(settings.SAML2_AUTH['TRIGGER']['CREATE_USER'])(user_identity)
is_new_user = True
else:
return HttpResponseRedirect(get_reverse([denied, 'denied', 'django_saml2_auth:denied']))
r.session.flush()
if target_user.is_active:
target_user.backend = 'django.contrib.auth.backends.ModelBackend'
login(r, target_user)
else:
return HttpResponseRedirect(get_reverse([denied, 'denied', 'django_saml2_auth:denied']))
if settings.SAML2_AUTH.get('USE_JWT') is True:
# We use JWT auth send token to frontend
jwt_token = jwt_encode(target_user)
query = '?uid={}&token={}'.format(target_user.id, jwt_token)
frontend_url = settings.SAML2_AUTH.get(
'FRONTEND_URL', next_url)
return HttpResponseRedirect(frontend_url+query)
# Add in section to generate a rest framework auth token
if settings.SAML2_AUTH.get('USE_TOKEN_AUTHENTICATION') is True:
# Generate a token for the user
token, _ = Token.objects.get_or_create(user=target_user)
query = '?token={}'.format(token)
frontend_url = settings.SAML2_AUTH.get('FRONTEND_URL', next_url)
return HttpResponseRedirect(frontend_url+query)
if is_new_user:
try:
return render(r, 'django_saml2_auth/welcome.html', {'user': r.user})
except TemplateDoesNotExist:
return HttpResponseRedirect(next_url)
else:
return HttpResponseRedirect(next_url)
def __init__(self, params):
self.context_processors = [
import_string(p)
for p in params['OPTIONS'].pop('context_processors', [])
]
super(Jinja2Backend, self).__init__(params)
def get_default_renderer():
renderer_class = import_string(settings.FORM_RENDERER)
return renderer_class()
def parser_class(self):
return import_string(self.parser)
from braces.views import LoginRequiredMixin
from registration.backends.default.views import ActivationView
from .forms import CustomPasswordResetForm, SetPasswordForm
from .utils import get_social_message_errors
PROFILE_FORM_PATH = getattr(settings, "PROFILE_FORM",
"quickstartup.accounts.forms.ProfileForm")
PASSWORD_CHANGE_FORM_PATH = getattr(
settings, "PASSWORD_CHANGE_FORM",
"django.contrib.auth.forms.PasswordChangeForm")
PASSWORD_FORM_PATH = getattr(settings, "PASSWORD_FORM",
"quickstartup.accounts.forms.SetPasswordForm")
PROFILE_FORM = import_string(PROFILE_FORM_PATH)
PASSWORD_CHANGE_FORM = import_string(PASSWORD_CHANGE_FORM_PATH)
PASSWORD_FORM = import_string(PASSWORD_FORM_PATH)
@sensitive_post_parameters()
@csrf_protect
@never_cache
def login(request, *args, **kwargs):
if request.user.is_authenticated():
return redirect(resolve_url(settings.LOGIN_REDIRECT_URL))
return auth_login(request, *args, **kwargs)
@csrf_protect
def password_reset(request,
def my_get_finder(import_path):
Finder = import_string(import_path)
if not issubclass(Finder, finders.BaseFinder):
raise ImproperlyConfigured('Finder "%s" is not a subclass of "%s"' %
(Finder, finders.BaseFinder))
return Finder()
def get_func(key, default):
func_path = getattr(settings, key, default)
return import_string(func_path)
def get_form_class(self):
if self.form_class:
return self.form_class
else:
return import_string(
settings.CRADMIN_LEGACY_REGISTER_ACCOUNT_FORM_CLASS)
def load_backend(backend):
path = 'blueapps.account.components.{backend}'.format(backend=backend)
return import_string(path)
def _oidc_user(self, *args, **kwargs):
factory = import_string(settings.CALUMA_OIDC_USER_FACTORY)
return factory(*args, **kwargs)
def get_token_generator():
token_generator = import_string(settings.SSO_DEFAULT_TOKEN_GENERATOR)
return token_generator
def get_default_exception_reporter_filter():
# Instantiate the default filter for the first time and cache it.
return import_string(settings.DEFAULT_EXCEPTION_REPORTER_FILTER)()
def get_idtoken_finalizer():
idtoken_finalizer = import_string(settings.SSO_DEFAULT_IDTOKEN_FINALIZER)
return idtoken_finalizer
def _init_settings_to_import(self):
for setting_name in SETTINGS_TO_IMPORT:
value = getattr(self, setting_name)
if isinstance(value, str):
setattr(self, setting_name, import_string(value))
def construct_fields(self):
"Deep-clone the fields using deconstruction"
for name, field in self.fields:
_, path, args, kwargs = field.deconstruct()
field_class = import_string(path)
yield name, field_class(*args, **kwargs)
# This is for fetching the emails of the admins and the users.
url(r'^api/v1/dev_get_emails$', zerver.views.auth.api_dev_get_emails, name='zerver.views.auth.api_dev_get_emails'),
# Used to present the GOOGLE_CLIENT_ID to mobile apps
url(r'^api/v1/fetch_google_client_id$',
zerver.views.auth.api_fetch_google_client_id,
name='zerver.views.auth.api_fetch_google_client_id'),
]
# Include URL configuration files for site-specified extra installed
# Django apps
for app_name in settings.EXTRA_INSTALLED_APPS:
app_dir = os.path.join(settings.DEPLOY_ROOT, app_name)
if os.path.exists(os.path.join(app_dir, 'urls.py')):
urls += [url(r'^', include('%s.urls' % (app_name,)))]
i18n_urls += import_string("{}.urls.i18n_urlpatterns".format(app_name))
# Tornado views
urls += [
# Used internally for communication between Django and Tornado processes
url(r'^notify_tornado$', zerver.tornado.views.notify, name='zerver.tornado.views.notify'),
]
# Python Social Auth
urls += [url(r'^', include('social.apps.django_app.urls', namespace='social'))]
# User documentation site
urls += [url(r'^help/(?P<article>.*)$', HelpView.as_view(template_name='zerver/help/main.html'))]
if settings.DEVELOPMENT:
urls += dev_urls.urls
def load_backend(path):
return import_string(path)()
def template_context_processors(self):
context_processors = _builtin_context_processors
context_processors += tuple(self.context_processors)
return tuple(import_string(path) for path in context_processors)
def get_form():
from django_comments_xtd.conf import settings
return import_string(settings.COMMENTS_XTD_FORM_CLASS)
