コード例 #1
0
ファイル: storage.py プロジェクト: jphalip/django
 def __init__(self, location=None, base_url=None, file_permissions_mode=None,
              directory_permissions_mode=None):
     self._location = location
     self._base_url = base_url
     self._file_permissions_mode = file_permissions_mode
     self._directory_permissions_mode = directory_permissions_mode
     setting_changed.connect(self._clear_cached_properties)
コード例 #2
0
ファイル: apps.py プロジェクト: KeithPYC/django
 def ready(self):
     setting_changed.connect(uninstall_if_needed)
     # Connections may already exist before we are called.
     for conn in connections.all():
         if conn.vendor == 'postgresql':
             conn.introspection.data_types_reverse.update({
                 3904:
                 'django.contrib.postgres.fields.IntegerRangeField',
                 3906:
                 'django.contrib.postgres.fields.DecimalRangeField',
                 3910:
                 'django.contrib.postgres.fields.DateTimeRangeField',
                 3912:
                 'django.contrib.postgres.fields.DateRangeField',
                 3926:
                 'django.contrib.postgres.fields.BigIntegerRangeField',
             })
             if conn.connection is not None:
                 register_type_handlers(conn)
     connection_created.connect(register_type_handlers)
     CharField.register_lookup(Unaccent)
     TextField.register_lookup(Unaccent)
     CharField.register_lookup(SearchLookup)
     TextField.register_lookup(SearchLookup)
     CharField.register_lookup(TrigramSimilar)
     TextField.register_lookup(TrigramSimilar)
     CharField.register_lookup(TrigramWordSimilar)
     TextField.register_lookup(TrigramWordSimilar)
     MigrationWriter.register_serializer(RANGE_TYPES, RangeSerializer)
     IndexExpression.register_wrappers(OrderBy, OpClass, Collate)
コード例 #3
0
 def __init__(self, location=None, base_url=None, file_permissions_mode=None,
              directory_permissions_mode=None):
     self._location = location
     self._base_url = base_url
     self._file_permissions_mode = file_permissions_mode
     self._directory_permissions_mode = directory_permissions_mode
     setting_changed.connect(self._clear_cached_properties)
コード例 #4
0
ファイル: config.py プロジェクト: unicef/etools-datamart
 def __init__(self, prefix):
     """
     Loads our settings from django.conf.settings, applying defaults for any
     that are omitted.
     """
     self.prefix = prefix
     setting_changed.connect(self._handler)
コード例 #5
0
ファイル: storage.py プロジェクト: tech-pill/django
 def __init__(self, location=None, base_url=None, file_permissions_mode=None, directory_permissions_mode=None):
     self._location = location
     if base_url is not None and not base_url.endswith("/"):
         base_url += "/"
     self._base_url = base_url
     self._file_permissions_mode = file_permissions_mode
     self._directory_permissions_mode = directory_permissions_mode
     setting_changed.connect(self._clear_cached_properties)
コード例 #6
0
    def ready(self):
        set_read_only()

        for alias in connections:
            connection = connections[alias]
            install_hook(connection)
        connection_created.connect(install_hook)

        setting_changed.connect(reset_read_only)
コード例 #7
0
ファイル: storage.py プロジェクト: snkhokh/django_sn
 def __init__(self,
              location=None,
              base_url=None,
              file_permissions_mode=None,
              directory_permissions_mode=None):
     self._location = location
     if base_url is not None and not base_url.endswith('/'):
         base_url += '/'
     self._base_url = base_url
     self._file_permissions_mode = file_permissions_mode
     self._directory_permissions_mode = directory_permissions_mode
     setting_changed.connect(self._clear_cached_properties)
コード例 #8
0
    def __init__(self, prefix):
        self.prefix = prefix
        from django.conf import settings

        self.django_settings = settings

        for name, default in six.iteritems(self.defaults):
            prefix_name = (self.prefix + '_' + name).upper()
            value = getattr(self.django_settings, prefix_name, default)
            self._set_attr(prefix_name, value)

        setting_changed.connect(self._handler)
コード例 #9
0
    def __init__(self):
        """
        Initialization method.

        The ``invalidate_cache`` method will be connected to the Django
        ``setting_changed`` signal in this method, with the dispatch UID
        being the id of this very object (``id(self)``).
        """
        if self.__class__ == AppSettings:
            raise RuntimeError("Do not use AppSettings class as itself, " "use it as a base for subclasses")
        setting_changed.connect(self.invalidate_cache, dispatch_uid=id(self))
        self._cache = {}
コード例 #10
0
 def __init__(self, **kwargs):
     # Check for unknown kwargs.
     for kwarg_key in kwargs.keys():
         if (kwarg_key.upper() not in self.default_auth_settings
                 and kwarg_key.upper() not in self.default_s3_settings):
             raise ImproperlyConfigured(
                 "Unknown S3Storage parameter: {}".format(kwarg_key))
     # Set up the storage.
     self._kwargs = kwargs
     self._setup()
     # Re-initialize the storage if an AWS setting changes.
     setting_changed.connect(self._setting_changed_received)
     # All done!
     super(S3Storage, self).__init__()
コード例 #11
0
    def ready(self):
        # import at ready time to prevent model loading before app ready
        from dynamic_logging.scheduler import main_scheduler
        try:
            main_scheduler.reload(
                2
            )  # 2 sec to prevent unit-tests to load the production database
        except OperationalError:  # pragma: nocover
            pass  # no trigger table exists atm. we don't care since there is no Trigger to pull.
        # setup signals for Trigger changes. it will reload the current trigger and next one

        self.auto_signal_handler.apply(get_setting('signals_auto'))
        self.setup_propagator()

        setting_changed.connect(self.on_settings_changed)
コード例 #12
0
    def __init__(self):
        self.__module_path_split = self.__class__.__module__.split('.')
        self._set_prefix()

        # Load values from defaults module
        self._load_defaults()

        # Load deprecation data
        self._prepare_deprecation_data()

        # This will create the dictionaries if they don't already exist
        self.reset_caches()

        # Define 'attribute reference' shortcuts
        self.models = AttrReferToMethodHelper(self, 'get_model')
        self.modules = AttrReferToMethodHelper(self, 'get_module')
        self.objects = AttrReferToMethodHelper(self, 'get_object')

        setting_changed.connect(self.reset_caches, dispatch_uid=id(self))
コード例 #13
0
ファイル: layers.py プロジェクト: andrewgodwin/channels
 def __init__(self):
     self.backends = {}
     setting_changed.connect(self._reset_backends)
コード例 #14
0
from typing import Any
import uuid

import django.test.signals
from django.contrib.auth import authenticate, get_user_model
from django.contrib.auth.hashers import MD5PasswordHasher
from django.core.signals import setting_changed
from django.test import TestCase, override_settings

from fd_dj_accounts.auth_backends import AuthUserModelAuthBackend
from . import utils

# warning: this is critical for being able to mess with 'AUTH_USER_MODEL' in the tests.
setting_changed.disconnect(receiver=django.test.signals.user_model_swapped)
setting_changed.connect(receiver=utils.auth_user_model_swapped_receiver)


class CountingMD5PasswordHasher(MD5PasswordHasher):
    """Hasher that counts how many times it computes a hash."""

    calls = 0

    def encode(self, *args, **kwargs):  # type: ignore
        type(self).calls += 1
        return super().encode(*args, **kwargs)


class AuthUserModelAuthBackendTestMixin:
    """
    Base class for test cases of ``AuthUserModelAuthBackend``.
コード例 #15
0
 def ready(self):
     setting_changed.connect(update_level_tags)
コード例 #16
0
ファイル: settings.py プロジェクト: alaminopu/django-hesab
    def __getattr__(self, attr):
        if attr not in self.defaults:
            raise AttributeError('Invalid Elasticsearch backend setting: \'%s\'' % attr)

        try:
            value = self.user_settings[attr]
        except KeyError:
            value = self.defaults[attr]

        # Cache the setting
        setattr(self, attr, value)
        return value

    @property
    def user_settings(self):
        if not getattr(self, '_user_settings'):
            self._user_settings = getattr(settings, 'ES_BACKEND_SETTINGS', {})
        return self._user_settings

es_settings = ESSettings(None, DEFAULTS)


def reload_es_settings(*args, **kwargs):
    global es_settings
    setting, value = kwargs['setting'], kwargs['value']
    if setting == 'ES_BACKEND_SETTINGS':
        es_settings = ESSettings(value, DEFAULTS)

setting_changed.connect(reload_es_settings)
コード例 #17
0
        self.defaults = defaults
        self.user_settings = user_settings

    def __getattr__(self, attr):
        if attr not in self.defaults:
            raise AttributeError("Invalid JSON API setting: '%s'" % attr)

        value = getattr(self.user_settings, JSON_API_SETTINGS_PREFIX + attr,
                        self.defaults[attr])

        # Cache the result
        setattr(self, attr, value)
        return value


json_api_settings = JSONAPISettings()


def reload_json_api_settings(*args, **kwargs):
    django_setting = kwargs['setting']
    setting = django_setting.replace(JSON_API_SETTINGS_PREFIX, '')
    value = kwargs['value']
    if setting in DEFAULTS.keys():
        if value is not None:
            setattr(json_api_settings, setting, value)
        elif hasattr(json_api_settings, setting):
            delattr(json_api_settings, setting)


setting_changed.connect(reload_json_api_settings)
コード例 #18
0
ファイル: conftest.py プロジェクト: sncap/shuup
def pytest_configure(config):
    setting_changed.connect(clear_caches, dispatch_uid="shuup_test_clear_caches")
    settings.SHUUP_TELEMETRY_ENABLED = False
コード例 #19
0
ファイル: conf.py プロジェクト: nvmanh/plant
        # Cache the result
        setattr(self, name, value)
        return value

    def get_setting(self, setting):
        django_setting = 'FILTERS_%s' % setting

        if setting in DEPRECATED_SETTINGS and hasattr(dj_settings, django_setting):
            deprecate("The '%s' setting has been deprecated." % django_setting)

        return getattr(dj_settings, django_setting, DEFAULTS[setting])

    def change_setting(self, setting, value, enter, **kwargs):
        if not setting.startswith('FILTERS_'):
            return
        setting = setting[8:]  # strip 'FILTERS_'

        # ensure a valid app setting is being overridden
        if setting not in DEFAULTS:
            return

        # if exiting, delete value to repopulate
        if enter:
            setattr(self, setting, value)
        else:
            delattr(self, setting)


settings = Settings()
setting_changed.connect(settings.change_setting)
コード例 #20
0

class Settings(object):
    FIXED_SETTINGS = ('VIEW_NAME', )

    def __init__(self, default):
        setattr(self, 'default', default)
        user_settings = getattr(django_settings, 'TAGGIT_FORMS', {})
        self._update(user_settings)

    def _update(self, user_settings):
        for key in self.default:
            if key in user_settings and key not in self.FIXED_SETTINGS:
                self.default[key] = user_settings[key]

    def __getattr__(self, name):
        if name in self.default:
            return self.default[name]
        raise AttributeError

settings = Settings(TAGGIT_FORMS)


def update_settings(*args, **kwargs):
    if kwargs['setting'] == 'TAGGIT_FORMS':
        value = kwargs['value']
        if value:
            settings._update(value)

setting_changed.connect(update_settings)
コード例 #21
0
ファイル: apps.py プロジェクト: charettes/django-syzygy
 def ready(self):
     _configure()
     checks.register(check_migrations, "migrations")
     setting_changed.connect(_watch_settings)
コード例 #22
0
 def ready(self):
     # Connect the settings_changed signal so that we can
     # pick up changes from django settings.
     setting_changed.connect(load_settings)
コード例 #23
0
ファイル: extra.py プロジェクト: cuberskulk/shoop
# This source code is licensed under the AGPLv3 license found in the
# LICENSE file in the root directory of this source tree.
from django.core.exceptions import ImproperlyConfigured
from django.core.signals import setting_changed
from django.http.response import HttpResponseNotFound

from shoop.xtheme.theme import get_current_theme

_VIEW_CACHE = {}


def clear_view_cache(**kwargs):
    _VIEW_CACHE.clear()


setting_changed.connect(clear_view_cache, dispatch_uid="shoop.xtheme.views.extra.clear_view_cache")


def _get_view_by_name(theme, view_name):
    view = theme.get_view(view_name)
    if hasattr(view, "as_view"):  # Handle CBVs
        view = view.as_view()
    if view and not callable(view):
        raise ImproperlyConfigured("View %r not callable" % view)
    return view


def get_view_by_name(theme, view_name):
    if not theme:
        return None
    cache_key = (theme.identifier, view_name)
コード例 #24
0
ファイル: apps.py プロジェクト: isabella232/django-email-pal
 def ready(self):
     self.configure_sendable_emails()
     setting_changed.connect(self._on_setting_changed)
コード例 #25
0
 def __init__(self):
     self.backends = {}
     setting_changed.connect(self._reset_backends)
コード例 #26
0
ファイル: conftest.py プロジェクト: gurch101/shuup
def pytest_configure(config):
    setting_changed.connect(clear_caches, dispatch_uid="shuup_test_clear_caches")
    settings.SHUUP_TELEMETRY_ENABLED = False
コード例 #27
0
ファイル: conf.py プロジェクト: LPgenerator/django-cacheops
    FILE_CACHE_DIR = '/tmp/cacheops_file_cache'
    FILE_CACHE_TIMEOUT = 60*60*24*30


class Settings(object):
    def __getattr__(self, name):
        res = getattr(base_settings, name, getattr(Defaults, name))
        if name == 'CACHEOPS_PREFIX':
            res = res if callable(res) else import_string(res)
        # Save to dict to speed up next access, __getattr__ won't be called
        self.__dict__[name] = res
        return res

settings = Settings()
setting_changed.connect(lambda setting, **kw: settings.__dict__.pop(setting, None), weak=False)


@memoize
def prepare_profiles():
    """
    Prepares a dict 'app.model' -> profile, for use in model_profile()
    """
    profile_defaults = {
        'ops': (),
        'local_get': False,
        'db_agnostic': True,
        'lock': False,
    }
    profile_defaults.update(settings.CACHEOPS_DEFAULTS)
コード例 #28
0
ファイル: config.py プロジェクト: domdinicola/django-crashlog
# -*- coding: utf-8 -*-
from django.conf import settings
from django.core.signals import setting_changed
from django.utils.module_loading import import_string

IGNORE_EXCEPTIONS = []


class Config(object):
    _ignore_exceptions = []


def update_config(sender=None, setting=None, value=None, enter=False, **kwargs):
    conf._ignore_exceptions = [import_string(a) for a in (getattr(settings, 'CRASHLOG_IGNORE_EXCEPTIONS',
                                      IGNORE_EXCEPTIONS))]


conf = Config()
update_config()

setting_changed.connect(update_config)
コード例 #29
0
# This source code is licensed under the OSL-3.0 license found in the
# LICENSE file in the root directory of this source tree.
from django.core.exceptions import ImproperlyConfigured
from django.core.signals import setting_changed
from django.http.response import HttpResponseNotFound

from shuup.xtheme._theme import get_current_theme

_VIEW_CACHE = {}


def clear_view_cache(**kwargs):
    _VIEW_CACHE.clear()


setting_changed.connect(clear_view_cache, dispatch_uid="shuup.xtheme.views.extra.clear_view_cache")


def _get_view_by_name(theme, view_name):
    view = theme.get_view(view_name)
    if hasattr(view, "as_view"):  # Handle CBVs
        view = view.as_view()
    if view and not callable(view):
        raise ImproperlyConfigured("Error! View `%r` is not callable." % view)
    return view


def get_view_by_name(theme, view_name):
    if not theme:
        return None
    cache_key = (theme.identifier, view_name)
コード例 #30
0
        value = getattr(self.user_settings, JSON_API_SETTINGS_PREFIX + attr, self.defaults[attr])

        # Cache the result
        setattr(self, attr, value)
        return value

    @property
    def format_type(self):
        if self.FORMAT_KEYS is not None:
            return self.FORMAT_KEYS

        return self.FORMAT_FIELD_NAMES


json_api_settings = JSONAPISettings()


def reload_json_api_settings(*args, **kwargs):
    django_setting = kwargs['setting']
    setting = django_setting.replace(JSON_API_SETTINGS_PREFIX, '')
    value = kwargs['value']
    if setting in DEFAULTS.keys():
        if value is not None:
            setattr(json_api_settings, setting, value)
        elif hasattr(json_api_settings, setting):
            delattr(json_api_settings, setting)


setting_changed.connect(reload_json_api_settings)
コード例 #31
0
        user_settings=None,
        defaults=None,
        import_strings=None,
        removed_settings=None
        settings_key=None,
        settings_doc=None
    ):
        self._settings_doc = settings_doc or 'https://www.django-rest-framework.org/api-guide/settings/'
        self._removed_settings = removed_settings or REMOVED_SETTINGS
        if user_settings:
            self._user_settings = self.__check_user_settings(user_settings)
        self.defaults = defaults or DEFAULTS
        self.import_strings = import_strings or IMPORT_STRINGS
        self._settings_key = settings_key or 'REST_FRAMEWORK'
        self._cached_attrs = set()        
        setting_changed.connect(self.reload_api_settings)
        
    def __del__(self):
        setting_changed.disconnect(self.reload_api_settings)        

    @property
    def user_settings(self):
        if not hasattr(self, '_user_settings'):
            self._user_settings = getattr(settings, self._settings_key, {})
        return self._user_settings

    def __getattr__(self, attr):
        if attr not in self.defaults:
            raise AttributeError("Invalid API setting: '%s'" % attr)

        try:
コード例 #32
0
ファイル: conf.py プロジェクト: scuml/django-cacheops
            res = res if callable(res) else import_string(res)

        # Convert old list of classes to list of strings
        if name == 'CACHEOPS_SKIP_FIELDS':
            [
                f if isinstance(f, str) else f.get_internal_type(res)
                for f in res
            ]

        # Save to dict to speed up next access, __getattr__ won't be called
        self.__dict__[name] = res
        return res


settings = Settings()
setting_changed.connect(
    lambda setting, **kw: settings.__dict__.pop(setting, None), weak=False)


@memoize
def prepare_profiles():
    """
    Prepares a dict 'app.model' -> profile, for use in model_profile()
    """
    profile_defaults = {
        'ops': (),
        'local_get': False,
        'db_agnostic': True,
        'lock': False,
    }
    profile_defaults.update(settings.CACHEOPS_DEFAULTS)
コード例 #33
0
            msg = "'%s' object has no attribute '%s'"
            raise AttributeError(msg % (self.__class__.__name__, name))

        value = self.get_setting(name)
        setattr(self, name, value)
        return value

    def get_setting(self, setting):
        django_setting = self.prefix + setting
        return getattr(dj_settings, django_setting, DEFAULTS[setting])

    def change_setting(self, setting, value, enter, **kwargs):
        if not setting.startswith(self.prefix):
            return
        setting = setting.replace(self.prefix, '')

        if setting not in DEFAULTS:
            return

        if enter:
            setattr(self, setting, value)
        else:
            delattr(self, setting)


if not hasattr(dj_settings, 'SIMPLE_LOG_MODEL'):
    setattr(dj_settings, 'SIMPLE_LOG_MODEL', DEFAULTS['MODEL'])

settings = Settings()
setting_changed.connect(settings.change_setting)
コード例 #34
0
ファイル: policy.py プロジェクト: kcsry/infotv
    def can_post_datum(self, request):
        return True

    def can_edit_slides(self, request):
        user = getattr(request, "user", None)
        if user:
            return bool(getattr(user, "is_staff", False))
        return False


_POLICY_CLASS = None


def get_policy():
    """
    :rtype: infotv.policy.BasePolicy
    """
    global _POLICY_CLASS
    if not _POLICY_CLASS:
        policy_class_name = getattr(settings, "INFOTV_POLICY_CLASS", "infotv.policy.DefaultPolicy")
        _POLICY_CLASS = import_string(policy_class_name)
    return _POLICY_CLASS()


def _sig_clear_cached_policy(**kwargs):
    global _POLICY_CLASS
    _POLICY_CLASS = None


setting_changed.connect(_sig_clear_cached_policy)
コード例 #35
0
ファイル: conftest.py プロジェクト: if413019/ShoopDevelopment
def pytest_configure(config):
    setting_changed.connect(clear_caches, dispatch_uid="shoop_test_clear_caches")
コード例 #36
0
 def __init__(self, *args, **kwargs):
     self._dispatch_uid = uuid.uuid4()
     super(LDAPBackend, self).__init__(*args, **kwargs)
     setting_changed.connect(self._on_setting_changed,
                             dispatch_uid=self._dispatch_uid)
コード例 #37
0
 def __init__(self, location=None, base_url=None, options=None):
     self._base_location = location
     self._base_url = base_url
     setting_changed.connect(self._clear_cached_properties)
コード例 #38
0
ファイル: conftest.py プロジェクト: DemOneEh/shoop
def pytest_configure(config):
    setting_changed.connect(clear_caches, dispatch_uid="shoop_test_clear_caches")
コード例 #39
0
        raise ImproperlyConfigured("Missing host_patterns in '%s'" % hostconf)


def clear_host_caches():
    get_hostconf.cache_clear()
    get_hostconf_module.cache_clear()
    get_host.cache_clear()
    get_host_patterns.cache_clear()


def setting_changed_receiver(setting, enter, **kwargs):
    if setting in {'ROOT_HOSTCONF', 'DEFAULT_HOST'}:
        clear_host_caches()


setting_changed.connect(setting_changed_receiver)


def reverse_host(host, args=None, kwargs: dict = None):
    """
    Given the host name and the appropriate parameters,
    reverses the host, e.g.::

        >>> from django.conf import settings
        >>> settings.ROOT_HOSTCONF = 'mysite.hosts'
        >>> settings.PARENT_HOST = 'example.com'
        >>> from django_hosts.resolvers import reverse_host
        >>> reverse_host('with_username', args=('jezdez',))
        'jezdez.example.com'

    :param name: the name of the host as specified in the hostconf
コード例 #40
0
            self._user_settings = getattr(settings, SETTING_NAMESPACE, {})
        return self._user_settings

    def __getattr__(self, attr):
        if attr not in self.defaults:
            raise AttributeError("Invalid 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]

        # Cache the result
        setattr(self, attr, val)
        return val


surveys_settings = AppSettings(None, DEFAULTS)


def reload_settings(*args, **kwargs):  # pylint:disable=unused-argument
    global surveys_settings
    setting, value = kwargs['setting'], kwargs['value']
    if setting == SETTING_NAMESPACE:
        surveys_settings = AppSettings(value, DEFAULTS)


setting_changed.connect(reload_settings)
コード例 #41
0
def clear_settings_cache():
    global settings_cache
    settings_cache = None


def get_cached_setting_key(key):
    setup_settings_cache()
    return settings_cache[key]


def settings_changed_handler(setting, **kwargs):
    if setting == settings_attr:
        clear_settings_cache()


setting_changed.connect(settings_changed_handler)


class CachedSettingsMixin(object):
    def __init__(self, *args, **kwargs):
        self.update_patterns()
        super(CachedSettingsMixin, self).__init__(*args, **kwargs)

    def update_patterns(self):
        if not self.js_assets_repl_enabled:
            return

        esc_tag = re.escape(self.js_assets_repl_tag)
        self.patterns += (("*.js", ((
            r"""(/\*!\s*%s(?:\((.*?)\))?\s*\*/\s*['"](.*?)['"]\s*/\*!\s*end%s\s*\*/(\n)?)"""
            % (esc_tag, esc_tag), """'%s'"""), )), )
コード例 #42
0
ファイル: resolvers.py プロジェクト: jazzband/django-hosts
        raise ImproperlyConfigured("Missing host_patterns in '%s'" % hostconf)


def clear_host_caches():
    get_hostconf.cache_clear()
    get_hostconf_module.cache_clear()
    get_host.cache_clear()
    get_host_patterns.cache_clear()


def setting_changed_receiver(setting, enter, **kwargs):
    if setting in {'ROOT_HOSTCONF', 'DEFAULT_HOST'}:
        clear_host_caches()


setting_changed.connect(setting_changed_receiver)


def reverse_host(host, args=None, kwargs=None):
    """
    Given the host name and the appropriate parameters,
    reverses the host, e.g.::

        >>> from django.conf import settings
        >>> settings.ROOT_HOSTCONF = 'mysite.hosts'
        >>> settings.PARENT_HOST = 'example.com'
        >>> from django_hosts.resolvers import reverse_host
        >>> reverse_host('with_username', args=('jezdez',))
        'jezdez.example.com'

    :param name: the name of the host as specified in the hostconf
コード例 #43
0
def pytest_configure(config):
    setting_changed.connect(clear_caches, dispatch_uid="E-Commerce_test_clear_caches")
    settings.E-Commerce_TELEMETRY_ENABLED = False