Пример #1
0
    def __getattr__(self, attr):

        if attr not in self.defaults:
            raise AttributeError("Invalid API setting: '%s'" % attr)
        try:
            # Check if present in user settings
            val = self.user_settings[attr]
        except KeyError:
            # Fall back to defaults
            val = self.defaults[attr]

        # Coerce import strings into classes
        if attr in self.import_strings:
            val = perform_import(val, attr)

        # Validations for attrs
        if attr == 'BACKUP_CODES_CHARACTERS' and ',' in val:
            raise ImproperlyConfigured(
                'Cannot use , as a character for {}.'.format(attr), )
        if attr == 'MFA_METHODS':
            for method_name, method_config in val.items():
                if 'HANDLER' not in method_config:
                    raise ImproperlyConfigured(
                        'Missing handler in {} configuration.'.format(
                            method_name), )
                method_config['HANDLER'] = perform_import(
                    method_config.get('HANDLER'),
                    'HANDLER',
                )
        # Cache the result
        self._cached_attrs.add(attr)
        setattr(self, attr, val)
        return val
Пример #2
0
 def _validate(self, attribute: str, value: Any) -> None:
     if attribute == self._FIELD_MFA_METHODS:
         for method_name, method_config in value.items():
             if self._FIELD_HANDLER not in method_config:
                 raise MethodHandlerMissingError(method_name=method_name)
             for k, v in self.defaults[
                     self._FIELD_MFA_METHODS][method_name].items():
                 method_config[k] = method_config.get(k, v)
             method_config[self._FIELD_HANDLER] = perform_import(
                 method_config[self._FIELD_HANDLER], self._FIELD_HANDLER)
Пример #3
0
    def __new__(mcls, name, bases, attrs):

        if 'permission_classes' not in attrs:
            settings_key = attrs.get(
                'settings_permission_key', 'FORMIDABLE_DEFAULT_PERMISSION'
            )

            # If the settings key define is not present in the settings
            # The ``NoOne`` permission is loaded.
            modules = getattr(settings, settings_key,
                      getattr(settings, 'FORMIDABLE_DEFAULT_PERMISSION',  # noqa
                      ['formidable.permissions.NoOne']))                  # noqa

            permissions_classes = perform_import(modules, None)
            attrs['permission_classes'] = permissions_classes
        return super(MetaClassView, mcls).__new__(mcls, name, bases, attrs)
Пример #4
0
    def __getattr__(self, attr):
        if attr not in self.defaults:
            raise AttributeError("Invalid setting: '%s'" % attr)  # pragma: no cover

        try:
            # Check if present in user settings
            val = self.user_settings[attr]
        except KeyError:
            # Fall back to defaults
            val = self.defaults[attr]

        # Coerce import strings into classes
        if attr in self.import_strings:
            val = perform_import(val, attr)

        return val
Пример #5
0
    def __getattr__(self, attr):
        if attr not in self.defaults.keys():
            raise AttributeError("Invalid registration setting: '%s'" % attr)

        try:
            # Check if present in user settings
            val = self.user_settings[attr]
        except KeyError:
            # Fall back to defaults
            val = self.defaults[attr]

        # Coerce import strings into classes
        if attr in self.import_strings:
            val = perform_import(val, attr)

        # Cache the result
        setattr(self, attr, val)
        return val
Пример #6
0
    def __new__(mcls, name, bases, attrs):

        if 'permission_classes' not in attrs:
            settings_key = attrs.get('settings_permission_key',
                                     'FORMIDABLE_DEFAULT_PERMISSION')

            # If the settings key define is not present in the settings
            # The ``NoOne`` permission is loaded.
            modules = getattr(
                settings,
                settings_key,
                getattr(
                    settings,
                    'FORMIDABLE_DEFAULT_PERMISSION',  # noqa
                    ['formidable.permissions.NoOne']))  # noqa

            permissions_classes = perform_import(modules, None)
            attrs['permission_classes'] = permissions_classes
        return super().__new__(mcls, name, bases, attrs)
    def __getattr__(self, attr: str) -> Any:
        if attr not in self.defaults.keys():
            raise AttributeError(
                "Invalid {self.root_setting_name} setting: '{attr}'".format(
                    self=self, attr=attr))

        try:
            # Check if present in user settings
            val = self.user_settings[attr]
        except KeyError:
            # Fall back to defaults
            val = self.defaults[attr]

        # Coerce import strings into classes
        if attr in self.import_strings:
            val = perform_import(val, attr)

        # Cache the result
        setattr(self, attr, val)
        return val
Пример #8
0
from django.conf import settings

from rest_framework import generics
from rest_framework import permissions
from rest_framework import views
from rest_framework import viewsets
from rest_framework.settings import perform_import


GALAXY_EXCEPTION_HANDLER = perform_import(
    settings.GALAXY_EXCEPTION_HANDLER,
    'GALAXY_EXCEPTION_HANDLER'
)
GALAXY_AUTHENTICATION_CLASSES = perform_import(
    settings.GALAXY_AUTHENTICATION_CLASSES,
    'GALAXY_AUTHENTICATION_CLASSES'
)
GALAXY_PAGINATION_CLASS = perform_import(
    settings.GALAXY_PAGINATION_CLASS,
    'GALAXY_PAGINATION_CLASS'
)


class _MustImplementPermission(permissions.BasePermission):
    def has_permission(self, request, view):
        raise NotImplementedError("subclass must implement permission_classes")


class LocalSettingsMixin:
    authentication_classes = GALAXY_AUTHENTICATION_CLASSES
    pagination_class = GALAXY_PAGINATION_CLASS
Пример #9
0
 def get_token_model():
     return perform_import(
         oauth2_client_settings.OAUTH2_CLIENT_TOKEN_MODEL,
         oauth2_client_settings.OAUTH2_CLIENT_TOKEN_MODEL_NAME)
Пример #10
0
if PANDAS_RENDERERS is None:
    PANDAS_RENDERERS = (
        "rest_pandas.renderers.PandasCSVRenderer",
        "rest_pandas.renderers.PandasTextRenderer",
        "rest_pandas.renderers.PandasJSONRenderer",
        "rest_pandas.renderers.PandasExcelRenderer",
        "rest_pandas.renderers.PandasOldExcelRenderer",
        "rest_pandas.renderers.PandasPNGRenderer",
        "rest_pandas.renderers.PandasSVGRenderer",
    )
    if "rest_pandas" in settings.INSTALLED_APPS:
        DEFAULT_TEMPLATE = True
        PANDAS_RENDERERS = (
            "rest_pandas.renderers.PandasHTMLRenderer", ) + PANDAS_RENDERERS

PANDAS_RENDERERS = perform_import(PANDAS_RENDERERS, "PANDAS_RENDERERS")


class PandasMixin(object):
    pandas_serializer_class = PandasSerializer

    def with_list_serializer(self, cls):
        meta = getattr(cls, 'Meta', object)
        if getattr(meta, 'list_serializer_class', None):
            return cls

        class SerializerWithListSerializer(cls):
            class Meta(meta):
                list_serializer_class = self.pandas_serializer_class

        return SerializerWithListSerializer
Пример #11
0
def init_checkers():
    checker_classes = perform_import(TOKEN_CHECKERS, 'TOKEN_CHECKERS')
    return map(lambda klass: klass(), checker_classes)
Пример #12
0
    SimpleSerializer, PandasSerializer, USE_LIST_SERIALIZERS
)

PANDAS_RENDERERS = getattr(settings, "PANDAS_RENDERERS", None)
if PANDAS_RENDERERS is None:
    PANDAS_RENDERERS = (
        "rest_pandas.renderers.PandasCSVRenderer",
        "rest_pandas.renderers.PandasTextRenderer",
        "rest_pandas.renderers.PandasJSONRenderer",
        "rest_pandas.renderers.PandasExcelRenderer",
        "rest_pandas.renderers.PandasOldExcelRenderer",
        "rest_pandas.renderers.PandasPNGRenderer",
        "rest_pandas.renderers.PandasSVGRenderer",
    )

PANDAS_RENDERERS = perform_import(PANDAS_RENDERERS, "PANDAS_RENDERERS")


class PandasMixin(object):
    renderer_classes = PANDAS_RENDERERS
    pandas_serializer_class = PandasSerializer

    paginate_by = None  # DRF 2
    pagination_class = None  # DRF 3

    def with_list_serializer(self, cls):
        if not USE_LIST_SERIALIZERS:
            # Django REST Framework 2 used the instance serializer for lists
            class SerializerWithListSerializer(
                    self.pandas_serializer_class, cls):
                pass
Пример #13
0
        "unicef_rest_export.renderers.ExportCSVRenderer",
        "unicef_rest_export.renderers.ExportJSONRenderer",
        "unicef_rest_export.renderers.ExportOpenXMLRenderer",
        "unicef_rest_export.renderers.ExportExcelRenderer",
        "unicef_rest_export.renderers.ExportPDFRenderer",
        "unicef_rest_export.renderers.ExportPDFTableRenderer",
        "unicef_rest_export.renderers.ExportDocxRenderer",
        "unicef_rest_export.renderers.ExportDocxTableRenderer",
    )
    if "unicef_rest_export" in settings.INSTALLED_APPS:
        DEFAULT_TEMPLATE = True
        EXPORT_RENDERERS = (
            "unicef_rest_export.renderers.ExportHTMLRenderer",
        ) + EXPORT_RENDERERS

EXPORT_RENDERERS = perform_import(EXPORT_RENDERERS, "EXPORT_RENDERERS")


class ExportMixin(object):
    export_serializer_class = ExportSerializer

    def with_list_serializer(self, cls):
        meta = getattr(cls, 'Meta', object)
        if getattr(meta, 'list_serializer_class', None):
            return cls

        class SerializerWithListSerializer(cls):
            class Meta(meta):
                list_serializer_class = self.export_serializer_class

        return SerializerWithListSerializer
Пример #14
0
def init_checkers():
    checker_classes = perform_import(token_settings.TOKEN_CHECKERS,
                                     'TOKEN_CHECKERS')
    return list(map(lambda klass: klass(), checker_classes))