igs-slm 0.1.4b0__py3-none-any.whl → 0.1.5b1__py3-none-any.whl

slm/settings/__init__.py

@@ -1,13 +1,125 @@
+"""
+These settings utilities help us compose settings across multiple files.
+
+.. warning::
+
+    These functions only work when called from a settings file because
+    they operate on the calling scope. Do not call these functions from
+    any other location.
+"""
+
+import re
 import sys
+import typing as t
+from functools import partial
+from os import PathLike
+from pathlib import Path
 
+import environ
 import importlib_resources
+from django.core.exceptions import ImproperlyConfigured
+
+re.Pattern
 
 
 class _NotGiven:
     pass
 
 
-def set_default(var_name, default, set_if_none=True):
+_environ: t.Optional[environ.FileAwareEnv] = None
+_base_dir: t.Optional[Path] = None
+_email_rgx: t.Optional[re.Pattern] = None
+
+
+def split_email_str(email: str) -> t.Tuple[str, str]:
+    """
+    Split an email string into display name and email address.
+
+    If there is no display name it will be the empty string.
+
+    :param email: An email string. E.g.:
+        * ``name@example.com``
+        * ``Last, First <name@example.com>``
+        * ``"First Last" <name@example.com>``
+
+    :return: A 2-tuple of (display name, email address)
+    """
+    global _email_rgx
+    if "<" not in email:
+        return ("", email)
+    if not _email_rgx:
+        _email_rgx = re.compile(r"\s+[\"']?(?P<display>.*)[\"']?\s+<(?P<email>.*)>")
+    if not (match := _email_rgx.search(email)):
+        raise ImproperlyConfigured(f"{email} is not a valid email string.")
+    return match.groupdict["display"].strip(), match.groupdict["email"].strip()
+
+
+def _is_relative_to(parent: Path, child: Path) -> bool:
+    # TODO remove when python >=3.9
+    if sys.version_info[:2] < (3, 9):
+        try:
+            child.relative_to(parent)
+            return True
+        except ValueError:
+            return False
+    return child.is_relative_to(parent)
+
+
+def env(**kwargs) -> environ.FileAwareEnv:
+    """
+    Fetch the :class:`environ.Env` object that should be used to configure settings.
+    If an environment file exists it will be read in. The environment file precendence
+    is:
+
+        1. The path in the environment variable SLM_ENV
+        2. BASE_DIR / .env
+
+    :return: The :class:`~environ.FileAwareEnv` object configured to read our
+        environment variables and files.
+    """
+    global _environ
+    if _environ is None:
+        scope = sys._getframe(1).f_globals
+        default_env = scope.get("BASE_DIR", "")
+        if default_env:
+            default_env = str(Path(default_env) / ".env")
+
+        DEBUG = kwargs.pop("DEBUG", (bool, False))
+        _environ = environ.FileAwareEnv(DEBUG=DEBUG, **kwargs)
+        override_env = _environ.str("SLM_ENV", scope.get("SLM_ENV", default_env))
+        if override_env and Path(override_env).is_file():
+            _environ.read_env(str(override_env))
+    return _environ
+
+
+def base_dir(scope=None) -> Path:
+    """
+    Fetch the :setting:`BASE_DIR`, this will raise an
+    :exc:`~django.core.exceptions.ImproperlyConfigured` exception if it does not exist yet.
+
+    :param scope: The settings scope (do not pass if calling from a settings file)
+    :return: The :setting:`BASE_DIR` as a :class:`pathlib.Path` object.
+    :raises: :exc:`~django.core.exceptions.ImproperlyConfigured` if :setting:`BASE_DIR` is not
+        defined.
+    """
+    global _base_dir
+    if not _base_dir:
+        scope = scope or sys._getframe(1).f_globals
+        _base_dir = scope.get("BASE_DIR", None)
+        if _base_dir is None:
+            raise ImproperlyConfigured("BASE_DIR was needed before it was defined!")
+        _base_dir = Path(_base_dir)
+        if not _base_dir.is_dir():
+            if scope.get("DEBUG", False):
+                _base_dir.mkdir(mode=0o775, parents=True, exist_ok=True)
+            else:
+                raise ImproperlyConfigured(
+                    f"BASE_DIR: {_base_dir} is not a directory that exists."
+                )
+    return _base_dir
+
+
+def set_default(var_name: str, default: t.Any, set_if_none: bool = True) -> t.Any:
     """
     Set the value of the given variable in the calling scope to a default value if it has been not been previously
     defined.
@@ -23,7 +135,7 @@ def set_default(var_name, default, set_if_none=True):
     return scope[var_name]
 
 
-def is_defined(var_name):
+def is_defined(var_name: str) -> bool:
     """
     Returns true if the given variable has been defined in the calling scope.
 
@@ -33,7 +145,7 @@ def is_defined(var_name):
     return var_name in sys._getframe(1).f_globals
 
 
-def get_setting(var_name, default=_NotGiven):
+def get_setting(var_name: str, default: t.Any = _NotGiven) -> t.Any:
     """
     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
@@ -49,7 +161,83 @@ def get_setting(var_name, default=_NotGiven):
     return value
 
 
-def resource(package, file):
+def slm_path(
+    value: str, must_exist: bool = False, mk_dirs: bool = False
+) -> t.Optional[str]:
+    """
+    Resolve a configuration path. If the path is relative it will be resolved under
+    :setting:`BASE_DIR`. If the value is falsey it will be returned as-is even if
+    ``must_exist`` is set.
+
+    :param value: The path as a string
+    :param must_exist: If True, raise an
+        :exc:`~django.core.exceptions.ImproperlyConfigured` if the path does not exist.
+    :param mk_dirs: If True and the path is relative to :setting:`BASE_DIR` create the
+        path as a directory if it does not already exist.
+    :raises: :exc:`~django.core.exceptions.ImproperlyConfigured` if :setting:`BASE_DIR` is
+        needed but not defined, or does not exist or if ``must_exist`` is ``True`` but the
+        path does not exist.
+    """
+    if not value:
+        return value
+    pth = Path(str(value))
+
+    if relative := not pth.is_absolute():
+        pth = base_dir(sys._getframe(1).f_globals) / pth
+
+    if not pth.exists() and mk_dirs:
+        relative = relative or _is_relative_to(
+            base_dir(sys._getframe(1).f_globals), pth
+        )
+        if relative:
+            pth.mkdir(
+                mode=0o775 if sys._getframe(1).f_globals.get("DEBUG", False) else 0o770,
+                parents=True,
+                exist_ok=True,
+            )
+
+    if must_exist and not pth.exists():
+        raise ImproperlyConfigured(f"{pth} does not exist!")
+    return str(pth)
+
+
+slm_path_must_exist = partial(slm_path, must_exist=True)
+"""
+A shortcut for :func:`~slm.settings.slm_path` with ``must_exist=True``.
+"""
+
+slm_path_mk_dirs_must_exist = partial(slm_path, must_exist=True, mk_dirs=True)
+"""
+A shortcut for :func:`~slm.settings.slm_path` with ``must_exist=True`` and
+``mk_dirs=True``.
+"""
+
+
+def unset(var_name: str):
+    """
+    Unset the value of the given variable in the calling scope.
+
+    :param var_name: The name of the variable to unset in the calling scope.
+    """
+    scope = sys._getframe(1).f_globals
+    if var_name in scope:
+        del scope[var_name]
+
+
+def resource(package: str, file: PathLike):
+    """
+    Use a packaged resource file as a settings file include. If you are
+    including a settings file from another package you should pass this to
+    split_settings.tools.include:
+
+        .. code-block:: python
+
+            include(resource("slm.settings", "root.py"))
+
+    :param package: The string import path of the package containing the module
+    :param file: The name of the python settings module
+    :return: The full string path to the resource.
+    """
     profile2 = importlib_resources.files(package) / file
     with importlib_resources.as_file(profile2) as profile2_path:
         return str(profile2_path)

slm/settings/assets.py

@@ -0,0 +1,26 @@
+"""
+Defines settings that control how assets are compressed and bundled using django-compressor.
+
+https://django-compressor.readthedocs.io
+"""
+
+from slm.settings import get_setting, set_default
+
+set_default("COMPRESS_OFFLINE", True)
+set_default("COMPRESS_ROOT", get_setting("STATIC_ROOT"))
+set_default("COMPRESS_URL", get_setting("STATIC_URL"))
+set_default("COMPRESS_OUTPUT_DIR", "assets")
+
+set_default(
+    "COMPRESS_PRECOMPILERS",
+    (
+        (
+            "text/javascript",
+            "npx -yes esbuild@latest {infile} --bundle --minify --outfile={outfile}",
+        ),
+        (
+            "module",
+            "npx -yes esbuild@latest {infile} --bundle --minify --outfile={outfile}",
+        ),
+    ),
+)

slm/settings/auth.py

@@ -1,15 +1,19 @@
-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 = "/"
+from slm.settings import set_default
 
-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",
-]
+set_default("ACCOUNT_LOGIN_ON_PASSWORD_RESET", True)
+set_default("ACCOUNT_UNIQUE_EMAIL", True)
+set_default("ACCOUNT_USER_MODEL_USERNAME_FIELD", None)
+set_default("ACCOUNT_LOGIN_METHODS", {"email"})
+set_default("ACCOUNT_SIGNUP_FIELDS", ["email*", "password1*", "password2*"])
+set_default("LOGIN_URL", "/accounts/login/")
+set_default("LOGIN_REDIRECT_URL", "/")
+
+set_default(
+    "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

@@ -2,13 +2,19 @@ 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/"
+set_default("CKEDITOR_UPLOAD_PATH", get_setting("MEDIA_ROOT") / "public/")
 
-CKEDITOR_CONFIGS = {
-    "richtextinput": {
-        "width": "100%",
+set_default(
+    "CKEDITOR_CONFIGS",
+    {
+        "richtextinput": {
+            "width": "100%",
+        },
+        "default": {
+            # exportpdf is not included but still getting the api key warning in js console??
+            "removePlugins": "exportpdf",
+        },
     },
-    "default": {},
-}
+)
 
 set_default("SILENCED_SYSTEM_CHECKS", []).append("ckeditor.W001")

slm/settings/debug.py

@@ -4,10 +4,10 @@ from django.core.exceptions import ImproperlyConfigured
 
 from slm.settings import get_setting, set_default
 
-if get_setting("DJANGO_DEBUG_TOOLBAR", None):
+if get_setting("SLM_DEBUG_TOOLBAR", False):
     if not find_spec("debug_toolbar"):
         raise ImproperlyConfigured(
-            "DJANGO_DEBUG_TOOLBAR is True, but django-debug-toolbar is not" "installed."
+            "SLM_DEBUG_TOOLBAR is True, but django-debug-toolbar is notinstalled."
         )
 
     # list any middlewares that might be encountered on the stack that must

slm/settings/emails.py

@@ -0,0 +1,50 @@
+from slm.settings import env as settings_environment
+from slm.settings import (
+    get_setting,
+    slm_path_mk_dirs_must_exist,
+    slm_path_must_exist,
+    split_email_str,
+)
+
+env = settings_environment()
+
+_email_config = env.email_url(
+    "SLM_EMAIL_SERVER", default=get_setting("SLM_EMAIL_SERVER", "smtp://localhost:25")
+)
+if EMAIL_FILE_PATH := _email_config.pop("EMAIL_FILE_PATH", None):
+    EMAIL_FILE_PATH = slm_path_mk_dirs_must_exist(EMAIL_FILE_PATH)
+
+if not EMAIL_FILE_PATH:
+    del EMAIL_FILE_PATH
+
+vars().update(_email_config)
+
+SERVER_EMAIL = env("SERVER_EMAIL", default=get_setting("SERVER_EMAIL", None))
+if SERVER_EMAIL is None:
+    domain = (
+        get_setting("SLM_SITE_NAME", None)
+        or get_setting("ALLOWED_HOSTS", ["localhost"])[0]
+    )
+    SERVER_EMAIL = f"noreply@{domain}"
+
+DEFAULT_FROM_EMAIL = env("DEFAULT_FROM_EMAIL", default=SERVER_EMAIL)
+
+
+EMAIL_SSL_CERTFILE = env(
+    "EMAIL_SSL_CERTFILE",
+    slm_path_must_exist,
+    default=get_setting("EMAIL_SSL_CERTFILE", None),
+)
+EMAIL_SSL_KEYFILE = env(
+    "EMAIL_SSL_KEYFILE",
+    slm_path_must_exist,
+    default=get_setting("EMAIL_SSL_KEYFILE", None),
+)
+
+
+# these emails will receive email reports when 500 HTTP messages are returned
+# TODO - on Django 6+ change this from email_str -> tuple to tuple -> email str
+ADMINS = [
+    split_email_str(email) if isinstance(email, str) else email
+    for email in env.list("ADMINS", default=get_setting("ADMINS", []))
+]

slm/settings/internationalization.py

@@ -1,12 +1,14 @@
 # Internationalization
 # https://docs.djangoproject.com/en/stable/topics/i18n/
+from slm.settings import env as settings_environment
+from slm.settings import get_setting, set_default
 
-LANGUAGE_CODE = "en"
+env = settings_environment()
+
+LANGUAGE_CODE = env("LANGUAGE_CODE", default=get_setting("LANGUAGE_CODE", "en-us"))
 
 # 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
+set_default("TIME_ZONE", "UTC")
+set_default("USE_I18N", not bool(LANGUAGE_CODE.startswith("en")))
+set_default("USE_TZ", True)

slm/settings/logging.py

@@ -1,11 +1,20 @@
 import os
 from logging import Filter
 
-from slm.settings import get_setting
+from slm.settings import env as settings_environment
+from slm.settings import get_setting, is_defined, slm_path_mk_dirs_must_exist
+
+env = settings_environment()
 
 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_LOG_LEVEL = env(
+    "SLM_LOG_LEVEL", default=get_setting("SLM_LOG_LEVEL", "DEBUG" if DEBUG else "INFO")
+)
+SLM_LOG_DIR = env(
+    "SLM_LOG_DIR",
+    slm_path_mk_dirs_must_exist,
+    default=get_setting("SLM_LOG_DIR", get_setting("BASE_DIR") / "logs"),
+)
 SLM_MANAGEMENT_MODE = get_setting("SLM_MANAGEMENT_MODE", False)
 
 
@@ -15,99 +24,102 @@ class SquelchStackTraces(Filter):
         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"
+if not is_defined("LOGGING"):
+    LOGGING = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "handlers": {
+            "file": {
+                "level": SLM_LOG_LEVEL,  # set in deployment routine
+                "class": "logging.handlers.TimedRotatingFileHandler",
+                "formatter": "verbose"
+                if DEBUG
+                else "simple",  # set in deployment routine
+                "filename": SLM_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,
+            },
         },
-        "simple": {
-            "format": "%(levelname)s %(process)d  %(asctime)s %(name)s %(message)s"
+        "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"},
         },
-        "management": {"format": "%(message)s"},
-    },
-    "filters": {
-        "squelch_traces": {
-            "()": SquelchStackTraces,
+        "filters": {
+            "squelch_traces": {
+                "()": SquelchStackTraces,
+            },
         },
-    },
-    "loggers": {
-        "django.request": {
-            "handlers": ["mail_admins"],
-            "level": "ERROR",
-            "propagate": True,
-        },
-        "django": {
-            "handlers": ["file"],
-            "level": DEFAULT_LOG_LEVEL,
-            "propagate": False,
+        "loggers": {
+            "django.request": {
+                "handlers": ["mail_admins"],
+                "level": "ERROR",
+                "propagate": True,
+            },
+            "django": {
+                "handlers": ["file"],
+                "level": SLM_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": SLM_LOG_LEVEL, "propagate": True},
         },
-        "django.db.backends": {
-            "handlers": ["file"],
-            "level": "INFO",  # super noisy
-            "propagate": False,
+        "root": {
+            "handlers": ["file", "mail_admins"],
+            "level": SLM_LOG_LEVEL,  # set in deployment routine
         },
-        "django.template": {
-            "handlers": ["file"],
-            "filters": ["squelch_traces"],
-            "level": "INFO",
-            "propagate": False,
-        },
-        "django.utils.autoreload": {
+    }
+
+    if DEBUG and not SLM_MANAGEMENT_MODE:
+        LOGGING["loggers"]["core.middleware.RequestLogger"] = {
             "handlers": ["file"],
-            "level": "WARNING",  # this logger got really noisy in django 2.2
+            "level": "DEBUG",
             "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 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")
+        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")
+        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)
+    # 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

@@ -1,10 +1,20 @@
 # 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
+from pathlib import Path
 
-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"
-)
+from slm.settings import get_setting
+
+if not get_setting("GDAL_LIBRARY_PATH"):
+    gdal_postgres_app_path = Path(
+        "/Applications/Postgres.app/Contents/Versions/latest/lib/libgdal.dylib"
+    )
+    if gdal_postgres_app_path.is_file():
+        GDAL_LIBRARY_PATH = str(gdal_postgres_app_path)
+
+if not get_setting("GEOS_LIBRARY_PATH"):
+    geos_postgres_app_path = Path(
+        "/Applications/Postgres.app/Contents/Versions/latest/lib/libgeos_c.dylib"
+    )
+    if geos_postgres_app_path.is_file():
+        GEOS_LIBRARY_PATH = str(geos_postgres_app_path)