def setup(cls):
        super(Base, cls).setup()

        cls.RAVEN_CONFIG = {
            'dsn': cls.SENTRY_DSN,
            'release': raven.fetch_git_sha(cls.PROJECT_PATH),
        }

    def RAVEN_CONFIG(self):
        import raven

        return {
            'dsn': str(super().SENTRY_DSN),
            'release': raven.fetch_git_sha(super().BASE_DIR),
        }

def get_release_name(base_dir, server_env):
    release_dir = base_dir.split('/')[-1]
    if re.match('\d{4}-\d{2}-\d{2}_\d{2}.\d{2}', release_dir):
        release = "{}-{}-deploy".format(release_dir, server_env)
    else:
        release = fetch_git_sha(base_dir)
    return release

def get_odoo_commit(odoo_dir):
    '''Attempts to get Odoo git commit from :param:`odoo_dir`.'''
    if not odoo_dir:
        return
    try:
        return fetch_git_sha(odoo_dir)
    except InvalidGitRepository:
        pass

    def on_configure(self):
        if settings.PDB_ENABLE_SENTRY: # ignore for coverage
            client = raven.Client(settings.PDB_SENTRY_DSN)
            client.release = raven.fetch_git_sha(os.path.dirname(os.pardir))

            # register a custom filter to filter out duplicate logs
            register_logger_signal(client)

            # hook into the Celery error handler
            register_signal(client)

 def RAVEN_CONFIG(self):
     if not hasattr(self, 'RAVEN_SECRET_KEY'):
         return {}
     return {
         'dsn': 'https://{public_key}:{secret_key}@app.getsentry.com/{project_id}'.format(
             public_key=self.RAVEN_PUBLIC_KEY,
             secret_key=self.RAVEN_SECRET_KEY,
             project_id=self.RAVEN_PROJECT_ID
         ),
         'release': raven.fetch_git_sha(self.TOP_DIR),
     }

def get_release():
    config = get_raven_config()
    if config.project_dist:
        try:
            return get_distribution(config.project_dist).version
        except DistributionNotFound:
            LOG.error('The distribution "{}" could not be found.'.format(config.project_dist))
            return None

    if config.buildout_root:
        try:
            return fetch_git_sha(config.buildout_root)
        except InvalidGitRepository:
            LOG.error("The path {} does not exist or is not" " a git repository".format(config.buildout_root))
            return None

    return None

def create_update_sentry_release():
    from settingshelper import get_release_name
    from raven import fetch_git_sha
    release = get_release_name(settings.BASE_DIR, settings.SERVER_ENVIRONMENT)
    headers = {'Authorization': 'Bearer {}'.format(settings.SENTRY_API_KEY), }
    payload = {
        'version': release,
        'refs': [{
            'repository': 'dimagi/commcare-hq',
            'commit': fetch_git_sha(settings.BASE_DIR)
        }],
        'projects': ['commcarehq']
    }
    releases_url = 'https://sentry.io/api/0/organizations/dimagi/releases/'
    response = requests.post(releases_url, headers=headers, json=payload)
    if response.status_code == 208:
        # already created so update
        payload.pop('version')
        requests.put('{}{}/'.format(releases_url, release), headers=headers, json=payload)

def init(args):
    if args.log_config:
        log_config = json.load(args.log_config)
        logging.config.dictConfig(log_config)
    else:
        logging.basicConfig(level=args.log_level,
                            format='%(asctime)s %(levelname)8s [%(name)s] %(message)s')

    log.info('--- Starting ---')
    git_sha = raven.fetch_git_sha(os.path.dirname(os.path.dirname(__file__)))
    log.info('Git commit: %s', git_sha)

    # Log errors to Sentry
    client = raven.Client(
        # dsn=os.environ.get('SENTRY_DSN'),
        include_paths=['fewerror'],
        release=git_sha,
        ignore_exceptions=[
            KeyboardInterrupt,
        ],
    )
    handler = SentryHandler(client)
    handler.setLevel(logging.WARNING)
    raven.conf.setup_logging(handler)

        'backupCount': 5
    }
    LOGGING['loggers']['wagtail']['handlers'].append('wagtail_file')

    # Error log
    LOGGING['handlers']['errors_file'] = {
        'level': 'ERROR',
        'class': 'cloghandler.ConcurrentRotatingFileHandler',
        'filename': os.path.join(env['LOG_DIR'], 'error.log'),
        'maxBytes': 5242880,  # 5MB
        'backupCount': 5
    }
    LOGGING['loggers']['django.request']['handlers'].append('errors_file')
    LOGGING['loggers']['django.security']['handlers'].append('errors_file')


try:
    from .local import *  # noqa
except ImportError:
    pass


# Raven (sentry error logging)

# This must be after the .local import as RAVEN_DSN is set in local.py
if 'RAVEN_DSN' in os.environ:
    RAVEN_CONFIG = {
        'dsn': os.environ['RAVEN_DSN'],
        'release': raven.fetch_git_sha(os.path.dirname(os.path.abspath(PROJECT_ROOT))),
    }

ACCOUNT_DEFAULT_HTTP_PROTOCOL = 'https'
ACCOUNT_USERNAME_MIN_LENGTH = 5
ACCOUNT_USERNAME_BLACKLIST = ['admin', 'owner', 'user']
ACCOUNT_USERNAME_REQUIRED = True
ACCOUNT_PASSWORD_MIN_LENGTH = 6
ACCOUNT_LOGIN_ON_EMAIL_CONFIRMATION = True
ACCOUNT_LOGIN_ON_PASSWORD_RESET = True
ACCOUNT_SESSION_REMEMBER = True

SOCIALACCOUNT_QUERY_EMAIL = ACCOUNT_EMAIL_REQUIRED
SOCIALACCOUNT_PROVIDERS = {'google': {
    'SCOPE': ['profile', 'email'],
    'AUTH_PARAMS': {'access_type': 'online'}
}}

RAVEN_CONFIG = {'dsn': '', 'release': raven.fetch_git_sha(BASE_DIR)}
ENTREZ_TERMS = ['chordoma', 'breast cancer', 'diabetes']
ENTREZ_MAX_COUNT = 10

NCBO_API_KEY = '5dbf6de8-fda5-4ef7-a3a8-bcea293f3715'
STOP_WORDS = 'protein,gene,disease,disorder,syndrome,chromosome,receptor,cell,\
        orphan,thumb,center,with,involved,image,type,known,encoded,this,both,\
        human,second,near,observed,from,family,width,name,caption,state,\
        structure,MEROPS,Pfam,domain,Symbol,SMART,crystal,analogue,\
        protein family,SCOP,InterPro,EC number,Name,group,related,then,Some,\
        form,http,abstract,content,liter,levels,enzyme,drugs,into,slow,\
        intermediate,bound,Citation,when,down,After'

POSTIVE_FLATTER = ['Bravo', 'Wow', 'Super', 'Terrific', 'Cool', 'Amazing', 'Superb', 'Brilliant', 'Fantastic', 'Fabulous', 'You\'re a Champion', 'Well done', 'You rock', 'Great job', 'Tip top', 'Good thinking', 'Keep it up', 'Way to go', 'Right on', 'Top stuff', 'Take a bow', 'Unreal', 'Impressed', 'Great stuff', 'Awesome', 'Nice going', 'Very Creative', 'Thank You', 'Beautiful', 'Very proud', 'Good for you', 'Give me five', 'You make me happy', 'A+', 'A++', 'AA+', 'Fab', 'Rad', 'A+++', 'AAA+', 'A-OK', 'Best', 'Cool', 'Deal', 'Fast', 'Fine', 'Item', 'Nice', 'Safe', 'Thx!', 'WOW!', 'Prime', 'Solid', 'Super', 'Sweet', 'Thanx', 'Whoa!', 'Groovy', 'Honest', 'Speedy', 'Superb', 'Sweeet', 'Thanks', 'Zowie!', 'Amazing', 'Awesome', 'Quality', 'Service', 'Sweeeet', 'Glorious', 'Stunning', 'Superior', 'The Best', 'The Bomb', 'Thrilled', 'Way Cool', 'Brilliant', 'Competent', 'Delighted', 'Excellent', 'Exquisite', 'Marvelous', 'Overjoyed', 'Satisfied', 'Thank You', 'Top Notch', 'Unrivaled', 'Wonderful', 'A Home Run', 'Astounding', 'Delightful', 'Impressive', 'Incredible', 'Super Cool', 'Super Fast', 'Supersonic', 'Astonishing', 'Fascinating', 'Interesting', 'Magnificent', 'No Problems', 'Outstanding', 'Splendorous', 'Trustworthy', 'Unsurpassed', 'Wicked Cool', 'Breathtaking', 'Looking Good', 'Overwhelming!', 'Unbelievable!', 'Awe Inspiring', 'Lickety Split', 'Splendiferous', 'Thanks A Ton!', 'Extremely Cool', 'Satisfied 100%', 'Extremely Happy', 'Great Condition', 'Above And Beyond', 'State Of The Art', 'Thanks A Million!', 'Unbelievably Cool', 'Expertly Described', 'Extremely Satisfied', 'Great Communication', 'Greatly Appreciated', 'Beyond My Wildest Dreams', 'Supercalifragilisticexpialidocious', 'Thank You! Thank You! Thank You!']
SUPPORT_FLATTER = ['You can do it', 'Nice Try', 'Don\'t give up', 'Every bit counts', 'Thank you', 'Keep going', 'You can do better than that']

        'django': {
            'handlers': [
{%- if cookiecutter.use_sentry == 'y' %}
                'sentry',
{%- endif %}
                'console',
            ],
            'level': 'ERROR',
            'propagate': True,
        },
    },
}

{%- if cookiecutter.use_sentry == 'y' %}
try:
    release = raven.fetch_git_sha(root())
except raven.exceptions.InvalidGitRepository:
    release = 'unknown'

RAVEN_CONFIG = {
    'dsn': env('SENTRY_DSN'),
    'release': release,
}
{%- endif %}

# if 'test' in sys.argv:
#     DATABASES['default'] = {'ENGINE': 'django.db.backends.sqlite3'}

if DEBUG:
    import socket

}

MIDDLEWARE_CLASSES = tuple([pair[1] for pair in sorted(MIDDLEWARE_GLOBAL + MIDDLEWARE_LOCAL)])

# set tempdir so that we don't have to worry about collision
if not getattr(tempfile, 'alreadytwiddled', False): # Python appears to run this multiple times
    tempdir = os.path.join(tempfile.gettempdir(), "esptmp__" + CACHE_PREFIX)
    if not os.path.exists(tempdir):
        os.makedirs(tempdir)
    tempfile.tempdir = tempdir
    tempfile.alreadytwiddled = True

# change csrf cookie name from default to prevent collisions with misbehaving sites
# that set a cookie on the top-level domain
# NOTE: don't change this value; it's hard coded into various JavaScript files
CSRF_COOKIE_NAME = 'esp_csrftoken'

if SENTRY_DSN:
    # If SENTRY_DSN is set, send errors to Sentry via the Raven exception
    # handler. Note that our exception middleware (i.e., ESPErrorMiddleware)
    # will remain enabled and will receive exceptions before Raven does.
    import raven

    INSTALLED_APPS += (
        'raven.contrib.django.raven_compat',
    )
    RAVEN_CONFIG = {
        'dsn': SENTRY_DSN,
        'release': raven.fetch_git_sha(os.path.join(PROJECT_ROOT, '..')),
    }

    'easy_thumbnails.processors.autocrop',
    'filer.thumbnail_processors.scale_and_crop_with_subject_location',
    'easy_thumbnails.processors.filters'
)

SITE_ID = 1


# Sentry.io
# https://docs.sentry.io/clients/python/integrations/django/

RAVEN_CONFIG = {
    'dsn': os.getenv('SENTRY_DSN', ''),
    # If you are using git, you can also automatically configure the
    # release based on the git info.
    'release': raven.fetch_git_sha(BASE_DIR),
}

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'root': {
        'level': 'WARNING',
        'handlers': ['sentry'],
    },
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s '
                      '%(process)d %(thread)d %(message)s'
        },
    },

COMPRESS_OFFLINE = True

# media settings
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

LOGIN_URL = '/'

# sentry.io
if not DEBUG:
    RAVEN_CONFIG = {
        'dsn': JSON_DATA['sentry_dsn'],
        # If you are using git, you can also automatically configure the
        #  release based on the git info.
        'release': raven.fetch_git_sha(os.path.dirname(os.pardir)),
    }

# cache
CACHEOPS_REDIS = {
    'host': 'localhost',  # redis-server is on same machine
    'port': 6379,         # default redis port
    'db': 14,             # SELECT non-default redis database
    }

CACHEOPS = {
    # Automatically cache any User.objects.get() calls for 15 minutes
    # This includes request.user or post.author access,
    # where Post.author is a foreign key to auth.User
    'auth.user': {'ops': 'all', 'timeout': 60*60*24*30},
    '*.*': {'ops': 'all', 'timeout': 60*60*24*2},  # enable cache for all model for 2 days

    addr='[email protected]',
)

# Securiy related settings
SECURE_HSTS_SECONDS = 2592000
SECURE_BROWSER_XSS_FILTER = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
CSRF_COOKIE_HTTPONLY = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
X_FRAME_OPTIONS = 'DENY'


# Setting for sentry

INSTALLED_APPS += (
    'raven.contrib.django.raven_compat',
)

import raven    # noqa

RAVEN_CONFIG = {
    'dsn': env('DSN_URL'),
    'release': raven.fetch_git_sha(os.path.dirname(BASE_DIR)),
}

GA_TRACK_ID = env('GA_TRACK_ID', default=None)
GTM_TRACK_ID = env('GTM_TRACK_ID', default=None)

DJANGO_Q_DEBUG = False

DAYS_TO_STALE_REGISTER = config('DAYS_TO_STALE_REGISTER', default=90, cast=int)

SOCIAL_AUTH_FACEBOOK_KEY = config('SOCIAL_AUTH_FACEBOOK_KEY', default='')
SOCIAL_AUTH_FACEBOOK_SECRET = config('SOCIAL_AUTH_FACEBOOK_SECRET', default='')

SOCIAL_AUTH_TWITTER_KEY = config('SOCIAL_AUTH_TWITTER_KEY', default='')
SOCIAL_AUTH_TWITTER_SECRET = config('SOCIAL_AUTH_TWITTER_SECRET', default='')

FACEBOOK_SHARE_GRAPH_API_VERSION = config('FACEBOOK_SHARE_GRAPH_API_VERSION', default='3.1')
FACEBOOK_SHARE_URL = 'https://www.facebook.com/sharer.php?u=https://cademeubicho.com/pets/{}/'
TWITTER_SHARE_URL = 'https://twitter.com/share?url=https://cademeubicho.com/pets/{}/'

REPO_ROOT = config('REPO_ROOT', default=os.path.abspath(os.pardir))
RAVEN_CONFIG = {
    'dsn': config('RAVEN_DSN', default=''),
    'release': raven.fetch_git_sha(REPO_ROOT),
}

SENDGRID_API_KEY = config('SENDGRID_API_KEY', default='')
DEFAULT_FROM_EMAIL = config('EMAIL_HOST_USER', default='[email protected]')

CORS_ORIGIN_ALLOW_ALL = True
CORS_URLS_REGEX = r'^/api/.*$'

REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
    'PAGE_SIZE': 20
}

GOOGLE_API_KEY = config('GOOGLE_API_KEY', default='')
HOTJAR_TRACKING_KEY = config('HOTJAR_TRACKING_KEY', default='')

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
)

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "dist")
]

STATICFILES_STORAGE = "django.contrib.staticfiles.storage.CachedStaticFilesStorage"

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.9/howto/static-files/

STATIC_URL = '/static/'
MEDIA_URL = '/media/'

import raven
if "RAVEN_DNS_WHATIS" in os.environ and not DEBUG:
    RAVEN_CONFIG = {
        'dsn': os.environ['RAVEN_DNS_WHATIS'],
        'release': raven.fetch_git_sha(os.path.join(os.path.dirname(__file__), "../")),
    }

import sys

import raven
from raven import Client, os

SENTRY_DSN = os.getenv("SENTRY_DSN", "https://000000:[email protected]/10000")
GIT_SHA = raven.fetch_git_sha(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir)))
client = Client(dsn=SENTRY_DSN, release=GIT_SHA)


def write_stdout(s):
    # only eventlistener protocol messages may be sent to stdout
    sys.stdout.write(s)
    sys.stdout.flush()


def write_stderr(s):
    sys.stderr.write(s)
    sys.stderr.flush()


def main():
    while 1:
        # transition from ACKNOWLEDGED to READY
        write_stdout("READY\n")

        # read header line and print it to stderr
        line = sys.stdin.readline()
        write_stderr(line)

        # read event payload and print it to stderr

def init_web_settings(app_name, debug, sentry_dsn, early_middleware=(), late_middleware=()):
    """
    Appends extra Django settings useful specifically for web apps, such as static files handling, etc.

    :param sentry_dsn: a string containing the DSN to configure the raven client. Projects defining
                       this parameter MUST add `raven` to their pip requirements.

    settings: dict
    return: dict
    """

    # Load settings dict into local scope for concision and coherence

    settings = init_settings(app_name, debug)

    staticfiles_dirs = (os.path.join(settings["APP_ROOT_DIR"], "static"),)

    # Needs its own line to avoid pragma no cover bleeding into other statements
    staticfiles_storage = (
        "whitenoise.storage.CompressedManifestStaticFilesStorage"
        if not settings["TESTING"]
        else "django.contrib.staticfiles.storage.StaticFilesStorage"
    )  # pragma: no cover

    template_context_processors = settings.get("TEMPLATE_CONTEXT_PROCESSORS", ()) + (
        ("django.core.context_processors.debug",) if debug else ()
    )  # pragma: no cover

    settings.update(
        {
            # Installed apps
            "INSTALLED_APPS": ("whitenoise.runserver_nostatic", "django.contrib.staticfiles")
            + settings["INSTALLED_APPS"],
            # Routing
            "ROOT_URLCONF": app_name + ".urls",
            # Static files, templates
            "STATIC_ROOT": "staticfiles",
            "STATIC_URL": "/static/",
            "STATICFILES_DIRS": staticfiles_dirs,
            # Don't use Whitenoise's static files storage in testing as it requires running collectstatic
            "STATICFILES_STORAGE": staticfiles_storage,
            "WHITENOISE_ROOT": staticfiles_dirs[0] + "/files",
            "WHITENOISE_ALLOW_ALL_ORIGINS": False,
            "TEMPLATE_CONTEXT_PROCESSORS": template_context_processors,
        }
    )

    ##########
    # SENTRY #
    ##########

    if sentry_dsn:  # pragma: no cover
        settings["INSTALLED_APPS"] = ("raven.contrib.django.raven_compat",) + settings["INSTALLED_APPS"]

        settings["LOGGING"]["handlers"]["sentry"] = {
            "level": "ERROR",
            "class": "raven.contrib.django.raven_compat.handlers.SentryHandler",
        }
        settings["LOGGING"]["root"]["handlers"].append("sentry")

        # import-error disabled: Raven shall only be a dependency of projects that define sentry_dsn
        import raven  # pylint: disable=wrong-import-position, wrong-import-order, import-error

        settings["RAVEN_CONFIG"] = {"dsn": sentry_dsn}

        try:
            settings["RAVEN_CONFIG"]["release"] = raven.fetch_git_sha(settings["PROJECT_ROOT_DIR"])
        except raven.exceptions.InvalidGitRepository:
            # Probably not a git repo (on heroku?)
            pass

    settings["MIDDLEWARE_CLASSES"] = _compute_middleware_settings(
        early_middleware, late_middleware, use_sentry=bool(sentry_dsn)
    )

    return settings