igs-slm 0.1.0b0__py3-none-any.whl

slm/receivers/event_loggers.py

@@ -0,0 +1,175 @@
+import logging
+
+from django.contrib.contenttypes.models import ContentType
+from django.dispatch import receiver
+from django.utils.timezone import now
+from ipware import get_client_ip
+
+from slm import signals as slm_signals
+
+logger = logging.getLogger(__name__)
+
+
+@receiver(slm_signals.site_published)
+def log_publish(sender, site, user, timestamp, request, section, **kwargs):
+    from slm.defines import LogEntryType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=LogEntryType.PUBLISH,
+        site=site,
+        section=(ContentType.objects.get_for_model(section) if section else None),
+        subsection=getattr(section, "subsection", None),
+        timestamp=timestamp or now(),
+        defaults={"user": user, "ip": get_client_ip(request)[0] if request else None},
+    )
+
+
+@receiver(slm_signals.site_proposed)
+def log_propose(sender, site, user, timestamp, request, agencies, **kwargs):
+    from slm.defines import LogEntryType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=LogEntryType.SITE_PROPOSED,
+        site=site,
+        timestamp=timestamp or now(),
+        defaults={"user": user, "ip": get_client_ip(request)[0] if request else None},
+    )
+
+
+@receiver(slm_signals.section_edited)
+def log_edit(sender, site, user, timestamp, request, section, fields, **kwargs):
+    from slm.defines import LogEntryType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=LogEntryType.UPDATE,
+        site=site,
+        section=(ContentType.objects.get_for_model(section) if section else None),
+        subsection=getattr(section, "subsection", None),
+        timestamp=timestamp or now(),
+        defaults={
+            "user": user,
+            "ip": get_client_ip(request)[0] if request else None,
+        },
+    )
+
+
+@receiver(slm_signals.section_added)
+def log_add(sender, site, user, timestamp, request, section, **kwargs):
+    from slm.defines import LogEntryType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=LogEntryType.ADD,
+        site=site,
+        section=(ContentType.objects.get_for_model(section) if section else None),
+        subsection=getattr(section, "subsection", None),
+        timestamp=timestamp or now(),
+        defaults={"user": user, "ip": get_client_ip(request)[0] if request else None},
+    )
+
+
+@receiver(slm_signals.section_deleted)
+def log_delete(sender, site, user, timestamp, request, section, **kwargs):
+    from slm.defines import LogEntryType
+    from slm.models import LogEntry
+
+    entry_type = LogEntryType.DELETE
+    if not getattr(section, "published", True):
+        entry_type = LogEntryType.REVERT
+    LogEntry.objects.get_or_create(
+        type=entry_type,
+        site=site,
+        section=(ContentType.objects.get_for_model(section) if section else None),
+        subsection=getattr(section, "subsection", None),
+        timestamp=timestamp or now(),
+        defaults={"user": user, "ip": get_client_ip(request)[0] if request else None},
+    )
+
+
+@receiver(slm_signals.site_file_uploaded)
+def log_file_upload(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import LogEntryType, SLMFileType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=(
+            {
+                SLMFileType.SITE_IMAGE: LogEntryType.IMAGE_UPLOAD,
+                SLMFileType.SITE_LOG: LogEntryType.LOG_UPLOAD,
+                SLMFileType.ATTACHMENT: LogEntryType.ATTACHMENT_UPLOAD,
+            }.get(upload.file_type, LogEntryType.LOG_UPLOAD)
+        ),
+        site=site,
+        timestamp=timestamp or now(),
+        defaults={
+            "user": user,
+            "ip": get_client_ip(request)[0] if request else None,
+            "file": upload,
+        },
+    )
+
+
+@receiver(slm_signals.site_file_published)
+def log_file_published(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import LogEntryType, SLMFileType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=(
+            LogEntryType.IMAGE_PUBLISH
+            if upload.file_type == SLMFileType.SITE_IMAGE
+            else LogEntryType.ATTACHMENT_PUBLISH
+        ),
+        site=site,
+        timestamp=timestamp or now(),
+        defaults={
+            "user": user,
+            "file": upload,
+            "ip": get_client_ip(request)[0] if request else None,
+        },
+    )
+
+
+@receiver(slm_signals.site_file_unpublished)
+def log_file_unpublished(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import LogEntryType, SLMFileType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=(
+            LogEntryType.IMAGE_UNPUBLISH
+            if upload.file_type == SLMFileType.SITE_IMAGE
+            else LogEntryType.ATTACHMENT_UNPUBLISH
+        ),
+        site=site,
+        timestamp=timestamp or now(),
+        defaults={
+            "user": user,
+            "file": upload,
+            "ip": get_client_ip(request)[0] if request else None,
+        },
+    )
+
+
+@receiver(slm_signals.site_file_deleted)
+def log_file_deleted(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import LogEntryType, SLMFileType
+    from slm.models import LogEntry
+
+    LogEntry.objects.get_or_create(
+        type=(
+            LogEntryType.IMAGE_DELETE
+            if upload.file_type == SLMFileType.SITE_IMAGE
+            else LogEntryType.ATTACHMENT_DELETE
+        ),
+        site=site,
+        timestamp=timestamp or now(),
+        defaults={
+            "user": user,
+            "file": None,
+            "ip": get_client_ip(request)[0] if request else None,
+        },
+    )

slm/receivers/index.py

@@ -0,0 +1,67 @@
+from django.dispatch import receiver
+
+from slm import signals as slm_signals
+from slm.defines import SiteLogStatus
+
+
+@receiver(slm_signals.site_status_changed)
+def index_site(sender, site, previous_status, new_status, **kwargs):
+    from slm.models import ArchiveIndex
+
+    if site.last_publish and (
+        previous_status in SiteLogStatus.active_states()
+        and new_status not in SiteLogStatus.active_states()
+    ):
+        ArchiveIndex.objects.close_index(site)
+    elif (
+        site.last_publish
+        and previous_status in SiteLogStatus.active_states()
+        and previous_status is not SiteLogStatus.PUBLISHED
+        and new_status is SiteLogStatus.PUBLISHED
+    ):
+        # catch an edge case where a section publish triggers a whole log publish
+        # these signals/edit state diagram needs to be cleaned up. this code is
+        # too hard to follow.
+        ArchiveIndex.objects.add_index(site)
+
+
+@receiver(slm_signals.site_published)
+def publish_site(sender, site, **kwargs):
+    from slm.models import ArchiveIndex
+
+    ArchiveIndex.objects.add_index(site)
+
+
+# for image and file attachment changes we simply regenerate the GeodesyML file
+# at the current index. This can lead to some GeodesyML files with different
+# attachment lists but the same file name in circulation. An alternative
+# approach would be to generate a new index for each attachment change but this
+# would produce lots of identical legacy logs with different timestamps/names.
+# The current approach is fine for now - the attachments are largely of
+# ancillary benefit.
+@receiver(slm_signals.site_file_published)
+def log_file_published(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import SiteLogFormat
+    from slm.models import ArchiveIndex
+
+    ArchiveIndex.objects.regenerate(site, log_format=SiteLogFormat.GEODESY_ML)
+
+
+@receiver(slm_signals.site_file_unpublished)
+def log_file_unpublished(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import SiteLogFormat
+    from slm.models import ArchiveIndex
+
+    ArchiveIndex.objects.regenerate(site, log_format=SiteLogFormat.GEODESY_ML)
+
+
+@receiver(slm_signals.site_file_deleted)
+def log_file_deleted(sender, site, user, timestamp, request, upload, **kwargs):
+    from slm.defines import SiteFileUploadStatus, SiteLogFormat, SLMFileType
+    from slm.models import ArchiveIndex
+
+    if upload.status is SiteFileUploadStatus.PUBLISHED and upload.file_type in [
+        SLMFileType.SITE_IMAGE,
+        SLMFileType.ATTACHMENT,
+    ]:
+        ArchiveIndex.objects.regenerate(site, log_format=SiteLogFormat.GEODESY_ML)

slm/settings/__init__.py

@@ -0,0 +1,55 @@
+import sys
+
+import importlib_resources
+
+
+class _NotGiven:
+    pass
+
+
+def set_default(var_name, default, set_if_none=True):
+    """
+    Set the value of the given variable in the calling scope to a default value if it has been not been previously
+    defined.
+
+    :param var_name: The name of the variable to set in the calling scope.
+    :param default: The value to set the variable to if its undefined
+    :param set_if_none: Treat the variable as undefined if it is None, default: True
+    :return: the variable that was set
+    """
+    scope = sys._getframe(1).f_globals
+    if var_name not in scope or set_if_none and scope[var_name] is None:
+        scope[var_name] = default
+    return scope[var_name]
+
+
+def is_defined(var_name):
+    """
+    Returns true if the given variable has been defined in the calling scope.
+
+    :param var_name: The name of the variable to check for
+    :return: True if the variable is defined, false otherwise
+    """
+    return var_name in sys._getframe(1).f_globals
+
+
+def get_setting(var_name, default=_NotGiven):
+    """
+    Returns the value of the setting if it exists, if it does not exist the value
+    given to default is returned. If no default value is given and the setting
+    does not exist a NameError is raised
+
+    :param var_name: The name of the variable to check for
+    :param default: The default value to return if the variable does not exist
+    :raises NameError: if the name is undefined and no default is given.
+    """
+    value = sys._getframe(1).f_globals.get(var_name, default)
+    if value is _NotGiven:
+        raise NameError(f"{var_name} setting variable is not defined.", name=var_name)
+    return value
+
+
+def resource(package, file):
+    profile2 = importlib_resources.files(package) / file
+    with importlib_resources.as_file(profile2) as profile2_path:
+        return str(profile2_path)

slm/settings/auth.py

@@ -0,0 +1,15 @@
+ACCOUNT_LOGIN_ON_PASSWORD_RESET = True
+ACCOUNT_UNIQUE_EMAIL = True
+ACCOUNT_USER_MODEL_USERNAME_FIELD = None
+ACCOUNT_EMAIL_REQUIRED = True
+ACCOUNT_USERNAME_REQUIRED = False
+ACCOUNT_AUTHENTICATION_METHOD = "email"
+LOGIN_URL = "/accounts/login/"
+LOGIN_REDIRECT_URL = "/"
+
+AUTHENTICATION_BACKENDS = [
+    # Needed to login by username in Django admin, regardless of `allauth`
+    "django.contrib.auth.backends.ModelBackend",
+    # `allauth` specific authentication methods, such as login by e-mail
+    "allauth.account.auth_backends.AuthenticationBackend",
+]

slm/settings/ckeditor.py

@@ -0,0 +1,14 @@
+from slm.settings import get_setting, set_default
+
+# your webserver should be configured to bypass Django and server
+# MEDIA_ROOT / CKEDITOR_UPLOAD_PATH directly
+CKEDITOR_UPLOAD_PATH = get_setting("MEDIA_ROOT") / "public/"
+
+CKEDITOR_CONFIGS = {
+    "richtextinput": {
+        "width": "100%",
+    },
+    "default": {},
+}
+
+set_default("SILENCED_SYSTEM_CHECKS", []).append("ckeditor.W001")

slm/settings/debug.py

@@ -0,0 +1,47 @@
+from importlib.util import find_spec
+
+from django.core.exceptions import ImproperlyConfigured
+
+from slm.settings import get_setting, set_default
+
+if get_setting("DJANGO_DEBUG_TOOLBAR", None):
+    if not find_spec("debug_toolbar"):
+        raise ImproperlyConfigured(
+            "DJANGO_DEBUG_TOOLBAR is True, but django-debug-toolbar is not" "installed."
+        )
+
+    # list any middlewares that might be encountered on the stack that must
+    # have higher precedence than debug middelware
+
+    MIDDLEWARE = get_setting("MIDDLEWARE", [])
+    if "debug_toolbar.middleware.DebugToolbarMiddleware" not in MIDDLEWARE:
+        must_come_after = ["django.middleware.gzip.GZipMiddleware"]
+        position = None
+        for middleware in must_come_after:
+            try:
+                middleware_idx = MIDDLEWARE.index(middleware)
+                if position is None or middleware_idx > position:
+                    position = middleware_idx
+            except ValueError:
+                pass
+        MIDDLEWARE.insert(
+            position or 0, "debug_toolbar.middleware.DebugToolbarMiddleware"
+        )
+
+    INSTALLED_APPS = get_setting("INSTALLED_APPS", [])
+    if "debug_toolbar" not in INSTALLED_APPS:
+        INSTALLED_APPS.append("debug_toolbar")
+
+    import socket  # only if you haven't already imported this
+
+    try:
+        _, _, ips = socket.gethostbyname_ex(socket.gethostname())
+    except OSError:
+        _, _, ips = socket.gethostbyname_ex("localhost")
+
+    INTERNAL_IPS = get_setting("INTERNAL_IPS", [])
+    INTERNAL_IPS.extend(
+        [ip[: ip.rfind(".")] + ".1" for ip in ips] + ["127.0.0.1", "10.0.2.2"]
+    )
+
+    set_default("DEBUG_TOOLBAR_CONFIG", {"SHOW_TOOLBAR_CALLBACK": lambda _: True})

slm/settings/internationalization.py

@@ -0,0 +1,12 @@
+# Internationalization
+# https://docs.djangoproject.com/en/stable/topics/i18n/
+
+LANGUAGE_CODE = "en"
+
+# ALL TIMES IN THE DB SHOULD BE STORED IN UTC - The web interface can then
+# reliably translate this into browser local time
+TIME_ZONE = "UTC"
+
+USE_I18N = False
+
+USE_TZ = True

slm/settings/logging.py

@@ -0,0 +1,113 @@
+import os
+from logging import Filter
+
+from slm.settings import get_setting
+
+DEBUG = get_setting("DEBUG", False)
+DEFAULT_LOG_LEVEL = "DEBUG" if DEBUG else "INFO"
+LOG_DIR = get_setting("LOG_DIR", get_setting("SITE_DIR") / "logs")
+SLM_MANAGEMENT_MODE = get_setting("SLM_MANAGEMENT_MODE", False)
+
+
+class SquelchStackTraces(Filter):
+    def filter(self, record):
+        record.exc_info = None
+        return super().filter(record)
+
+
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "handlers": {
+        "file": {
+            "level": DEFAULT_LOG_LEVEL,  # set in deployment routine
+            "class": "logging.handlers.TimedRotatingFileHandler",
+            "formatter": "verbose" if DEBUG else "simple",  # set in deployment routine
+            "filename": LOG_DIR
+            / f'{get_setting("SLM_SITE_NAME", "").lower()}{"_manage" if SLM_MANAGEMENT_MODE else ""}.log',
+            "when": "midnight",
+            "interval": 1,
+            "backupCount": 14,
+        },
+        "mail_admins": {
+            "level": "ERROR",
+            "class": "django.utils.log.AdminEmailHandler",
+            "include_html": True,
+        },
+    },
+    "formatters": {
+        "verbose": {
+            "format": "%(levelname)s %(process)d  %(asctime)s %(name)s %(process)d %(thread)d %(message)s"
+        },
+        "simple": {
+            "format": "%(levelname)s %(process)d  %(asctime)s %(name)s %(message)s"
+        },
+        "management": {"format": "%(message)s"},
+    },
+    "filters": {
+        "squelch_traces": {
+            "()": SquelchStackTraces,
+        },
+    },
+    "loggers": {
+        "django.request": {
+            "handlers": ["mail_admins"],
+            "level": "ERROR",
+            "propagate": True,
+        },
+        "django": {
+            "handlers": ["file"],
+            "level": DEFAULT_LOG_LEVEL,
+            "propagate": False,
+        },
+        "django.db.backends": {
+            "handlers": ["file"],
+            "level": "INFO",  # super noisy
+            "propagate": False,
+        },
+        "django.template": {
+            "handlers": ["file"],
+            "filters": ["squelch_traces"],
+            "level": "INFO",
+            "propagate": False,
+        },
+        "django.utils.autoreload": {
+            "handlers": ["file"],
+            "level": "WARNING",  # this logger got really noisy in django 2.2
+            "propagate": False,
+        },
+        "django_auth_ldap": {"level": DEFAULT_LOG_LEVEL, "propagate": True},
+    },
+    "root": {
+        "handlers": ["file", "mail_admins"],
+        "level": DEFAULT_LOG_LEVEL,  # set in deployment routine
+    },
+}
+
+if DEBUG and not SLM_MANAGEMENT_MODE:
+    LOGGING["loggers"]["core.middleware.RequestLogger"] = {
+        "handlers": ["file"],
+        "level": "DEBUG",
+        "propagate": False,
+    }
+
+if SLM_MANAGEMENT_MODE:
+    LOGGING.setdefault("handlers", {})["console"] = {
+        "level": "INFO",
+        "class": "logging.StreamHandler",
+        "formatter": "management",
+    }
+
+    if "root" in LOGGING:
+        if "console" not in LOGGING["root"]["handlers"]:
+            LOGGING["root"]["handlers"].append("console")
+
+    for name, config in LOGGING.get("loggers", {}).items():
+        if "handlers" in config and "console" not in config["handlers"]:
+            config["handlers"].append("console")
+
+# create logging dirs if necessary
+for name, handler_spec in LOGGING["handlers"].items():
+    filename = handler_spec.get("filename", None)
+    if filename:
+        os.makedirs(os.path.dirname(filename), exist_ok=True)

slm/settings/platform/darwin.py

@@ -0,0 +1,10 @@
+# this is the default location Postgres.app with postgres will install the postgis libraries to
+# if your system is different, or you use a different postgres package you will have to
+# override these
+
+GDAL_LIBRARY_PATH = (
+    "/Applications/Postgres.app/Contents/Versions/latest/lib/libgdal.dylib"
+)
+GEOS_LIBRARY_PATH = (
+    "/Applications/Postgres.app/Contents/Versions/latest/lib/libgeos_c.dylib"
+)

slm/settings/rest.py

@@ -0,0 +1,21 @@
+"""
+Django rest framework configuration parameters
+
+https://www.django-rest-framework.org/
+"""
+
+REST_FRAMEWORK = {
+    "DEFAULT_AUTHENTICATION_CLASSES": [
+        "rest_framework.authentication.SessionAuthentication",
+        #'slm.authentication.SignatureAuthentication', TODO library authentication
+    ],
+    "DEFAULT_PERMISSION_CLASSES": [
+        "rest_framework.permissions.IsAuthenticatedOrReadOnly"
+    ],
+    "DEFAULT_RENDERER_CLASSES": [
+        "rest_framework.renderers.JSONRenderer",
+        "rest_framework.renderers.BrowsableAPIRenderer",
+        #'drf_renderer_xlsx.renderers.XLSXRenderer',
+        #'rest_framework_csv.renderers.CSVRenderer'
+    ],
+}

slm/settings/root.py

@@ -0,0 +1,152 @@
+"""
+Django settings for SLM.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/stable/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/stable/ref/settings/
+"""
+
+import platform
+from pathlib import Path
+
+from django.contrib.messages import constants as message_constants
+from split_settings.tools import include, optional
+
+from slm.settings import get_setting, set_default
+
+DEBUG = get_setting("DEBUG", False)
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = get_setting("BASE_DIR", Path(__file__).resolve().parent.parent)
+SITE_DIR = get_setting("SITE_DIR", BASE_DIR)
+DJANGO_DEBUG_TOOLBAR = get_setting("DJANGO_DEBUG_TOOLBAR", False)
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
+
+ALLOWED_HOSTS = get_setting("ALLOWED_HOSTS", [])
+if ALLOWED_HOSTS:
+    set_default("SERVER_EMAIL", f"noreply@{ALLOWED_HOSTS[0]}")
+
+# Application definition
+
+# django.contrib.___ gives us useful tools for authentication, etc.
+INSTALLED_APPS = [
+    # "slm.map",
+    "slm",
+    "crispy_forms",
+    "crispy_bootstrap5",
+    "ckeditor_uploader",
+    "ckeditor",
+    "polymorphic",
+    "rest_framework",
+    "rest_framework_gis",
+    "render_static",
+    "django_routines",
+    "django_typer",
+    "django_filters",
+    "compressor",
+    "widget_tweaks",
+    #'django.contrib.postgres',
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "django.contrib.sites",
+    "django.contrib.gis",
+    "allauth",
+    "allauth.account",
+]
+
+CRISPY_ALLOWED_TEMPLATE_PACKS = "bootstrap5"
+CRISPY_TEMPLATE_PACK = "bootstrap5"
+
+STATICFILES_FINDERS = (
+    "django.contrib.staticfiles.finders.FileSystemFinder",
+    "django.contrib.staticfiles.finders.AppDirectoriesFinder",
+    "compressor.finders.CompressorFinder",
+)
+
+# this statement was added during creation of custom user model
+AUTH_USER_MODEL = "slm.User"
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "allauth.account.middleware.AccountMiddleware",
+    "slm.middleware.SetLastVisitMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+]
+
+ROOT_URLCONF = "slm.settings.urls"
+
+# Password validation
+# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
+    },
+]
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/3.2/howto/static-files/
+
+# Following two statements added to assist with handling of static files
+STATIC_URL = "/static/"
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+
+set_default("SITE_ID", 1)
+
+STATIC_ROOT = get_setting("STATIC_ROOT", SITE_DIR / "static")
+
+COMPRESS_OFFLINE = True
+COMPRESS_ROOT = STATIC_ROOT
+COMPRESS_URL = STATIC_URL
+
+
+include("internationalization.py")
+include("slm.py")
+include("secrets.py")
+include("logging.py")
+include("templates.py")
+include("static_templates.py")
+include("routines.py")
+include("auth.py")
+include("rest.py")
+include("debug.py")
+include("uploads.py")
+include("ckeditor.py")
+include("security.py")
+include("validation.py")
+
+# will either be darwin, windows or linux
+include(optional(f"./platform/{platform.system().lower()}.py"))
+
+
+# Path(STATIC_ROOT).mkdir(parents=True, exist_ok=True)
+# Path(MEDIA_ROOT).mkdir(parents=True, exist_ok=True)
+
+MESSAGE_LEVEL = message_constants.DEBUG if DEBUG else message_constants.INFO