django-environment-config 0.0.2__tar.gz

django_environment_config-0.0.2/LICENSE

@@ -0,0 +1,51 @@
+MIT License
+
+Copyright (c) Matti Lamppu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---------------- Original Licence for `django-configurations` ----------------
+
+Copyright (c) 2012-2023, Jannis Leidel and other contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of django-configurations nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

django_environment_config-0.0.2/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: django-environment-config
+Version: 0.0.2
+Summary: Configure django settings for multiple environments.
+Home-page: https://mrthearman.github.io/django-environment-config
+License: MIT
+Keywords: django,configuration,settings,environment,env,config
+Author: Matti Lamppu
+Author-email: lamppu.matti.akseli@gmail.com
+Requires-Python: >=3.10,<4
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Provides-Extra: cache
+Provides-Extra: db
+Requires-Dist: Django (>=4.2)
+Requires-Dist: dj-database-url (>=2.1.0,<3.0.0) ; extra == "db"
+Requires-Dist: django-cache-url (>=3.4.5,<4.0.0) ; extra == "cache"
+Requires-Dist: python-dotenv (>=1.0.1)
+Requires-Dist: typing-extensions (>=4.11.0) ; python_version < "3.12"
+Project-URL: Bug Tracker, https://github.com/MrThearMan/django-environment-config/issues
+Project-URL: Repository, https://github.com/MrThearMan/django-environment-config
+Description-Content-Type: text/markdown
+
+# Django Environment Config
+
+[![Coverage Status][coverage-badge]][coverage]
+[![GitHub Workflow Status][status-badge]][status]
+[![PyPI][pypi-badge]][pypi]
+[![GitHub][licence-badge]][licence]
+[![GitHub Last Commit][repo-badge]][repo]
+[![GitHub Issues][issues-badge]][issues]
+[![Downloads][downloads-badge]][pypi]
+[![Python Version][version-badge]][pypi]
+
+```shell
+pip install django-environment-config
+```
+
+---
+
+**Documentation**: [https://mrthearman.github.io/django-environment-config/](https://mrthearman.github.io/django-environment-config/)
+
+**Source Code**: [https://github.com/MrThearMan/django-environment-config/](https://github.com/MrThearMan/django-environment-config/)
+
+**Contributing**: [https://github.com/MrThearMan/django-environment-config/blob/main/CONTRIBUTING.md](https://github.com/MrThearMan/django-environment-config/blob/main/CONTRIBUTING.md)
+
+---
+
+Configure django settings for multiple environments.
+
+[coverage-badge]: https://coveralls.io/repos/github/MrThearMan/django-environment-config/badge.svg?branch=main
+[status-badge]: https://img.shields.io/github/actions/workflow/status/MrThearMan/django-environment-config/test.yml?branch=main
+[pypi-badge]: https://img.shields.io/pypi/v/django-environment-config
+[licence-badge]: https://img.shields.io/github/license/MrThearMan/django-environment-config
+[repo-badge]: https://img.shields.io/github/last-commit/MrThearMan/django-environment-config
+[issues-badge]: https://img.shields.io/github/issues-raw/MrThearMan/django-environment-config
+[version-badge]: https://img.shields.io/pypi/pyversions/django-environment-config
+[downloads-badge]: https://img.shields.io/pypi/dm/django-environment-config
+
+[coverage]: https://coveralls.io/github/MrThearMan/django-environment-config?branch=main
+[status]: https://github.com/MrThearMan/django-environment-config/actions/workflows/test.yml
+[pypi]: https://pypi.org/project/django-environment-config
+[licence]: https://github.com/MrThearMan/django-environment-config/blob/main/LICENSE
+[repo]: https://github.com/MrThearMan/django-environment-config/commits/main
+[issues]: https://github.com/MrThearMan/django-environment-config/issues
+

django_environment_config-0.0.2/README.md

@@ -0,0 +1,42 @@
+# Django Environment Config
+
+[![Coverage Status][coverage-badge]][coverage]
+[![GitHub Workflow Status][status-badge]][status]
+[![PyPI][pypi-badge]][pypi]
+[![GitHub][licence-badge]][licence]
+[![GitHub Last Commit][repo-badge]][repo]
+[![GitHub Issues][issues-badge]][issues]
+[![Downloads][downloads-badge]][pypi]
+[![Python Version][version-badge]][pypi]
+
+```shell
+pip install django-environment-config
+```
+
+---
+
+**Documentation**: [https://mrthearman.github.io/django-environment-config/](https://mrthearman.github.io/django-environment-config/)
+
+**Source Code**: [https://github.com/MrThearMan/django-environment-config/](https://github.com/MrThearMan/django-environment-config/)
+
+**Contributing**: [https://github.com/MrThearMan/django-environment-config/blob/main/CONTRIBUTING.md](https://github.com/MrThearMan/django-environment-config/blob/main/CONTRIBUTING.md)
+
+---
+
+Configure django settings for multiple environments.
+
+[coverage-badge]: https://coveralls.io/repos/github/MrThearMan/django-environment-config/badge.svg?branch=main
+[status-badge]: https://img.shields.io/github/actions/workflow/status/MrThearMan/django-environment-config/test.yml?branch=main
+[pypi-badge]: https://img.shields.io/pypi/v/django-environment-config
+[licence-badge]: https://img.shields.io/github/license/MrThearMan/django-environment-config
+[repo-badge]: https://img.shields.io/github/last-commit/MrThearMan/django-environment-config
+[issues-badge]: https://img.shields.io/github/issues-raw/MrThearMan/django-environment-config
+[version-badge]: https://img.shields.io/pypi/pyversions/django-environment-config
+[downloads-badge]: https://img.shields.io/pypi/dm/django-environment-config
+
+[coverage]: https://coveralls.io/github/MrThearMan/django-environment-config?branch=main
+[status]: https://github.com/MrThearMan/django-environment-config/actions/workflows/test.yml
+[pypi]: https://pypi.org/project/django-environment-config
+[licence]: https://github.com/MrThearMan/django-environment-config/blob/main/LICENSE
+[repo]: https://github.com/MrThearMan/django-environment-config/commits/main
+[issues]: https://github.com/MrThearMan/django-environment-config/issues

django_environment_config-0.0.2/env_config/__init__.py

@@ -0,0 +1,5 @@
+from .base import Environment
+
+__all__ = [
+    "Environment",
+]

django_environment_config-0.0.2/env_config/base.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import inspect
+import os
+from typing import TYPE_CHECKING
+
+from django.utils.functional import classproperty
+from dotenv import dotenv_values
+
+from .constants import Undefined
+
+if TYPE_CHECKING:
+    from dotenv.main import StrPath
+
+    from .typing import Any
+
+__all__ = [
+    "Environment",
+]
+
+
+class Environment:
+    """Configures a single environment."""
+
+    def __init_subclass__(
+        cls,
+        *,
+        dotenv_path: StrPath | None | Undefined = Undefined,
+    ) -> None:
+        env: str | None = os.environ.get("DJANGO_SETTINGS_ENVIRONMENT")
+        if env is None:  # pragma: no cover
+            msg = f"Environment variable 'DJANGO_SETTINGS_ENVIRONMENT' is not set before subclassing {cls.__name__!r}"
+            raise ValueError(msg)
+
+        if cls.__name__ != env:
+            return
+
+        # If not given, set it to `None` so that `python-dotenv` will use
+        # `dotenv.main.find_dotenv` to find the `.env` file automatically.
+        if dotenv_path is Undefined:
+            dotenv_path = None
+        # If set to `None` explicitly, do not load a `.env` file.
+        elif dotenv_path is None:
+            dotenv_path = Undefined
+
+        dotenv = cls.load_dotenv(dotenv_path=dotenv_path) if dotenv_path is not Undefined else Undefined
+
+        # Do name mangling to avoid overriding the attribute from a parent class.
+        # This way, we can have multiple environments with different `.env` files,
+        # and allow using values from a parent `.env` file as defaults (if desired).
+        setattr(cls, f"_{cls.__name__}__dotenv", dotenv)
+        setattr(cls, f"_{cls.__name__}__dotenv_path", dotenv_path)
+
+        cls.setup(stack_level=2)
+        cls.post_setup()
+
+    @staticmethod
+    def load_dotenv(*, dotenv_path: StrPath | None = None) -> dict[str, str]:
+        """Load the `.env` file and return the values."""
+        return dotenv_values(dotenv_path=dotenv_path)
+
+    @classmethod
+    def setup(cls, *, stack_level: int = 1) -> None:
+        """Load settings and set them in the module globals where the environment is defined."""
+        settings = cls.load_settings()
+        stack = inspect.stack()
+        caller_globals: dict[str, Any] = stack[stack_level].frame.f_globals
+        caller_globals.update(**settings)
+
+    @classmethod
+    def post_setup(cls) -> None:
+        """Hook for doing additional setup after the settings have been loaded."""
+
+    @classmethod
+    def load_settings(cls) -> dict[str, Any]:
+        """Load the settings from the environment, validating and returning them."""
+        return {name: getattr(cls, name) for name in dir(cls) if name.isupper() and not name.startswith("_")}
+
+    @classproperty
+    def dotenv(cls) -> dict[str, str] | Undefined:  # noqa: N805
+        return getattr(cls, f"_{cls.__name__}__dotenv", Undefined)
+
+    @classproperty
+    def dotenv_path(cls) -> str | None | Undefined:  # noqa: N805
+        return getattr(cls, f"_{cls.__name__}__dotenv_path", Undefined)

django_environment_config-0.0.2/env_config/constants.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+__all__ = [
+    "Undefined",
+]
+
+
+class Undefined:  # pragma: no cover
+    """Value to represent an undefined value."""
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__
+
+    def __bool__(self) -> bool:
+        return False
+
+
+Undefined = Undefined()

django_environment_config-0.0.2/env_config/errors.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from env_config.constants import Undefined
+
+if TYPE_CHECKING:
+    from env_config import Environment
+
+
+__all__ = [
+    "DjangoEnvConfigError",
+    "MissingEnvValueError",
+]
+
+
+class DjangoEnvConfigError(Exception):
+    """Base class for all Django Environment Config errors."""
+
+
+class MissingEnvValueError(DjangoEnvConfigError):
+    """Error raised when a value is not found in the .env file, and a default is not provided."""
+
+    def __init__(self, *, name: str, env: type[Environment]) -> None:
+        msg = f"Value {name!r} in environment {env.__name__!r}"
+        if env.dotenv_path is not Undefined:
+            msg += " not defined in the .env file and value does not have a default"
+        else:
+            msg += " needs a default value since environment does not define a `dotenv_path`"
+
+        super().__init__(msg)

django_environment_config-0.0.2/env_config/typing.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Callable, Generator, Generic, Mapping, ParamSpec, Sequence, TypedDict, TypeVar
+
+if sys.version_info < (3, 12):  # pragma: no cover
+    from typing_extensions import Unpack
+else:
+    from typing import Unpack
+
+__all__ = [
+    "Any",
+    "CacheConfig",
+    "Callable",
+    "DBConfig",
+    "DBConfigExtra",
+    "Generator",
+    "Generic",
+    "Mapping",
+    "ParamSpec",
+    "Sequence",
+    "TypeVar",
+    "Unpack",
+]
+
+
+class DBConfig(TypedDict, total=False):
+    ATOMIC_REQUESTS: bool
+    AUTOCOMMIT: bool
+    CONN_MAX_AGE: int | None
+    CONN_HEALTH_CHECKS: bool
+    DISABLE_SERVER_SIDE_CURSORS: bool
+    ENGINE: str
+    HOST: str
+    NAME: str
+    OPTIONS: dict[str, Any] | None
+    PASSWORD: str
+    PORT: str | int
+    TEST: dict[str, Any]
+    TIME_ZONE: str
+    USER: str
+
+
+class DBConfigExtra(TypedDict, total=False):
+    engine: str | None
+    conn_max_age: int | None
+    conn_health_checks: bool
+    ssl_require: bool
+    test_options: dict | None
+
+
+class CacheConfig(TypedDict, total=False):
+    BACKEND: str
+    KEY_FUNCTION: str
+    KEY_PREFIX: str
+    LOCATION: str
+    OPTIONS: dict[str, Any]
+    TIMEOUT: int
+    VERSION: int

django_environment_config-0.0.2/env_config/values.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from django.utils.module_loading import import_string
+
+from .constants import Undefined
+from .errors import MissingEnvValueError
+from .typing import Any, CacheConfig, DBConfig, DBConfigExtra, Generator, Generic, Mapping, Sequence, TypeVar, Unpack
+
+if TYPE_CHECKING:
+    from .base import Environment
+
+
+__all__ = [
+    "BooleanValue",
+    "CacheURLValue",
+    "DatabaseURLValue",
+    "DecimalValue",
+    "DictValue",
+    "EmailValue",
+    "FloatValue",
+    "IPValue",
+    "ImportStringValue",
+    "IntegerValue",
+    "JsonValue",
+    "ListValue",
+    "MappingValue",
+    "PathValue",
+    "PositiveIntegerValue",
+    "RegexValue",
+    "SequenceValue",
+    "SetValue",
+    "StringValue",
+    "TupleValue",
+    "URLValue",
+    "Value",
+]
+
+
+T = TypeVar("T")
+
+
+class Value(ABC, Generic[T]):
+    def __init__(
+        self,
+        *,
+        default: T | None = Undefined,
+        env_name: str | Undefined = Undefined,
+        nullable: bool = False,
+    ) -> None:
+        """
+        Value descriptor for an environment variable.
+
+        :param default: The default value to use if the environment variable is not set.
+        :param env_name: The name of the environment variable to use. If not given, the name of the field is used.
+        """
+        self.default: T | None = default
+        self.name: str = env_name
+        self.nullable: bool = nullable
+
+        # Use a map to store the value per environment so that we can have
+        # different values for environments what inherit from each other.
+        self.value_by_environment: dict[type[Environment], Any] = defaultdict(lambda: Undefined)
+        super().__init__()
+
+    def __set_name__(self, env: type[Environment], name: str) -> None:
+        """Called after the owner Environment-class is created with this field as a class attribute."""
+        if self.name is Undefined:
+            self.name = name
+
+    def __get__(self, _: Environment | None, env: type[Environment]) -> T:
+        """Called when accessing the field on the class or an instance of the class."""
+        if self.value_by_environment[env] is not Undefined:
+            return self.value_by_environment[env]
+
+        self.value_by_environment[env] = self.get_for_environment(env)
+        return self.value_by_environment[env]
+
+    def get_for_environment(self, env: type[Environment]) -> T:
+        value = self.default if env.dotenv is Undefined else env.dotenv.get(self.name, self.default)
+        if value is Undefined:
+            raise MissingEnvValueError(name=self.name, env=env)
+
+        if value is None:
+            if self.nullable:
+                return None
+            msg = f"Value for {self.name!r} cannot be None"
+            raise ValueError(msg)
+
+        return self.convert(value)
+
+    @abstractmethod
+    def convert(self, value: str | T) -> T:  # pragma: no cover
+        """Convert the given value into the proper representation."""
+        raise NotImplementedError
+
+
+class StringValue(Value[str]):
+    """Parses env variables into a string value."""
+
+    def convert(self, value: str) -> str:
+        return value
+
+
+class BooleanValue(Value[bool]):
+    """Parses env variables into a boolean value."""
+
+    def convert(self, value: str | bool) -> bool:  # noqa: FBT001
+        if isinstance(value, bool):
+            return value
+        normalized_value = value.strip().lower()
+        if normalized_value in ("yes", "y", "true", "1"):
+            return True
+        if normalized_value in ("no", "n", "false", "0", ""):
+            return False
+        msg = f"Cannot interpret {value!r} as a boolean value"
+        raise ValueError(msg)
+
+
+class IntegerValue(Value[int]):
+    """Parses env variables into an integer value."""
+
+    def convert(self, value: str | int) -> int:
+        return int(value)
+
+
+class PositiveIntegerValue(IntegerValue):
+    """Parses env variables into an integer value, and validates that the value is positive."""
+
+    def convert(self, value: str | int) -> int:
+        val = super().convert(value)
+        if val < 0:
+            msg = f"Value must be positive, got {val}"
+            raise ValueError(msg)
+        return val
+
+
+class FloatValue(Value[float]):
+    """Parses env variables into a float value."""
+
+    def convert(self, value: str | float) -> float:
+        return float(value)
+
+
+class DecimalValue(Value[Decimal], Decimal):
+    """Parses env variables into a Decimal value."""
+
+    def convert(self, value: str | Decimal) -> Decimal:
+        return Decimal(value)
+
+
+class ImportStringValue(Value[str]):
+    """Parses env variables into a string value, and validates that the value is an importable string."""
+
+    def convert(self, value: str) -> str:
+        import_string(value)
+        return value
+
+
+class SequenceValue(Value, ABC, Generic[T]):
+    def __init__(  # noqa: PLR0913
+        self,
+        child: Value[T] | None = None,
+        *,
+        default: Sequence[T] | None = Undefined,
+        env_name: str | Undefined = Undefined,
+        nullable: bool = False,
+        delimiter: str = ",",
+    ) -> None:
+        self.child = child or StringValue()
+        self.delimiter = delimiter
+        super().__init__(default=default, env_name=env_name, nullable=nullable)
+
+    def iterate(self, value: str | Sequence[Any]) -> Generator[T, None, None]:
+        seq = value.split(self.delimiter) if isinstance(value, str) else value
+        for item in seq:
+            if not item:
+                continue
+
+            yield self.child.convert(item.strip())
+
+
+class ListValue(SequenceValue):
+    """Parses env variables like `item1,item2,item3` into a list."""
+
+    def convert(self, value: str | list[Any]) -> list[Any]:
+        return list(self.iterate(value))
+
+
+class TupleValue(SequenceValue):
+    """Parses env variables like `item1,item2,item3` into a tuple."""
+
+    def convert(self, value: str | tuple[Any, ...]) -> tuple[Any, ...]:
+        return tuple(self.iterate(value))
+
+
+class SetValue(SequenceValue):
+    """Parses env variables like `item1,item2,item3` into a set."""
+
+    def convert(self, value: str | set[str]) -> set[Any]:
+        return set(self.iterate(value))
+
+
+class MappingValue(Value, ABC, Generic[T]):
+    def __init__(  # noqa: PLR0913
+        self,
+        child: Value[T] | None = None,
+        *,
+        default: Mapping[str, T] | None = Undefined,
+        env_name: str | Undefined = Undefined,
+        nullable: bool = False,
+        kv_delimiter: str = "=",
+        item_delimiter: str = ";",
+    ) -> None:
+        self.child = child or StringValue()
+        self.kv_delimiter = kv_delimiter
+        self.item_delimiter = item_delimiter
+        super().__init__(default=default, env_name=env_name, nullable=nullable)
+
+    def iterate(self, value: str | Mapping[str, Any]) -> Generator[tuple[str, Any], None, None]:
+        seq = value.split(self.item_delimiter) if isinstance(value, str) else value.items()
+
+        for item in seq:
+            if not item:
+                continue
+
+            if isinstance(item, str):
+                kv = item.split(self.kv_delimiter, 1)
+                if len(kv) != 2:  # noqa: PLR2004
+                    msg = f"Cannot split key-value pair from {item!r}"
+                    raise ValueError(msg)
+            else:
+                kv = item
+
+            yield kv[0].strip(), self.child.convert(kv[1].strip())
+
+
+class DictValue(MappingValue):
+    """Parses env variables like `key1=value1;key2=value2` into a dict."""
+
+    def convert(self, value: str | dict[str, Any]) -> dict[str, Any]:
+        return dict(self.iterate(value))
+
+
+class JsonValue(Value[dict | list]):
+    """Parses env variables from a json string to a python list or dict."""
+
+    def convert(self, value: str | list | dict) -> list | dict:
+        if isinstance(value, (list, dict)):
+            return value
+        return json.loads(value)
+
+
+class EmailValue(StringValue):
+    """Parses env variables into a string value, and validates that it's a valid email address."""
+
+    def convert(self, value: str) -> str:
+        from django.core.validators import validate_email
+
+        validate_email(value)
+        return value
+
+
+class URLValue(StringValue):
+    """Parses env variables into a string value, and validates that it's a valid URL."""
+
+    def convert(self, value: str) -> str:
+        from django.core.validators import URLValidator
+
+        URLValidator()(value)
+        return value
+
+
+class IPValue(StringValue):
+    """Parses env variables into a string value, and validates that it's a valid IP address."""
+
+    def convert(self, value: str) -> str:
+        from django.core.validators import validate_ipv46_address
+
+        validate_ipv46_address(value)
+        return value
+
+
+class RegexValue(StringValue):
+    """Parses env variables into a string value, and validates that it matches the given regex."""
+
+    def __init__(
+        self,
+        *,
+        regex: str,
+        default: str | None = Undefined,
+        nullable: bool = False,
+        env_name: str | Undefined = Undefined,
+    ) -> None:
+        self.regex = regex
+        super().__init__(default=default, env_name=env_name, nullable=nullable)
+
+    def convert(self, value: str) -> str:
+        from django.core.validators import RegexValidator
+
+        RegexValidator(regex=self.regex)(value)
+        return value
+
+
+class PathValue(StringValue):
+    """Parses env variable into a string value, and can optionally validate that the path exists."""
+
+    def __init__(
+        self,
+        *,
+        default: str | None = Undefined,
+        env_name: str | Undefined = Undefined,
+        nullable: bool = False,
+        check_exists: bool = True,
+    ) -> None:
+        self.check_exists = check_exists
+        super().__init__(default=default, env_name=env_name, nullable=nullable)
+
+    def convert(self, value: str) -> str:
+        path = Path(value).absolute()
+        if self.check_exists and not path.exists():
+            msg = f"Path '{path}' does not exist"
+            raise ValueError(msg)
+
+        return str(path)
+
+
+class DatabaseURLValue(Value[DBConfig | str]):
+    """Load a database configuration from a URL."""
+
+    def __init__(
+        self,
+        *,
+        db_alias: str = "default",
+        default: DBConfig | str = Undefined,
+        env_name: str = "DATABASE_URL",
+        **params: Unpack[DBConfigExtra],
+    ) -> None:
+        self.db_alias = db_alias
+        self.params = params
+        super().__init__(default=default, env_name=env_name)
+
+    def convert(self, value: str | DBConfig) -> dict[str, DBConfig]:
+        if not isinstance(value, str):
+            return {self.db_alias: value}
+
+        from dj_database_url import parse
+
+        config = parse(value, **self.params)
+        return {self.db_alias: config}
+
+
+class CacheURLValue(Value[CacheConfig | str]):
+    """Load a cache configuration from a URL."""
+
+    def __init__(
+        self,
+        *,
+        cache_alias: str = "default",
+        default: CacheConfig | str = Undefined,
+        env_name: str = "CACHE_URL",
+    ) -> None:
+        self.cache_alias = cache_alias
+        super().__init__(default=default, env_name=env_name)
+
+    def convert(self, value: str | CacheConfig) -> dict[str, CacheConfig]:
+        if not isinstance(value, str):
+            return {self.cache_alias: value}
+
+        from django_cache_url import parse
+
+        config = parse(value)
+        return {self.cache_alias: config}

django_environment_config-0.0.2/pyproject.toml

@@ -0,0 +1,314 @@
+[tool.poetry]
+name = "django-environment-config"
+version = "0.0.2"
+description = "Configure django settings for multiple environments."
+authors = [
+    "Matti Lamppu <lamppu.matti.akseli@gmail.com>",
+]
+packages = [
+    { include = "env_config" },
+]
+license = "MIT"
+readme = "README.md"
+homepage = "https://mrthearman.github.io/django-environment-config"
+repository = "https://github.com/MrThearMan/django-environment-config"
+keywords = [
+    "django",
+    "configuration",
+    "settings",
+    "environment",
+    "env",
+    "config",
+]
+classifiers = [
+    "Environment :: Web Environment",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+]
+include = [
+    "README.md",
+    "LICENSE",
+]
+exclude = [
+    "tests",
+]
+
+[tool.poetry.urls]
+"Bug Tracker" = "https://github.com/MrThearMan/django-environment-config/issues"
+
+[tool.poetry.dependencies]
+python = ">=3.10,<4"
+Django = ">=4.2"
+python-dotenv = ">=1.0.1"
+typing-extensions = { version = ">=4.11.0", python = "<3.12" }
+dj-database-url = { version = "^2.1.0", optional = true }
+django-cache-url = { version = "^3.4.5", optional = true }
+
+[tool.poetry.group.test.dependencies]
+pytest = "8.2.0"
+coverage = "7.5.0"
+pytest-django = "4.8.0"
+pre-commit = "3.7.0"
+tox = "4.15.0"
+tox-gh-actions = "3.2.0"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "1.6.0"
+pymdown-extensions = "10.8.1"
+mkdocs-mermaid2-plugin = "1.1.1"
+
+[tool.poetry.group.lint.dependencies]
+mypy = "1.10.0"
+django-stubs = "4.2.7"
+
+[tool.poetry.extras]
+db = ["dj-database-url"]
+cache = ["django-cache-url"]
+
+[tool.ruff]
+fix = true
+unsafe-fixes = true
+line-length = 120
+extend-exclude = [
+    "tests/*",
+]
+lint.typing-modules = [
+    "env_config.typing",
+]
+lint.explicit-preview-rules = true
+lint.preview = true
+lint.select = [
+    "A",        # flake8-builtins
+    "ANN",      # flake8-annotations
+    "ARG",      # flake8-unused-arguments
+    "B",        # flake8-bugbear
+    "BLE",      # flake8-blind-except
+    "C90",      # mccabe
+    "C4",       # flake8-comprehensions
+    "COM",      # flake8-commas
+    "D200",     # pydocstyle: One-line docstring should fit on one line
+    "D201",     # pydocstyle: No blank lines allowed before function docstring (found {num_lines})
+    "D202",     # pydocstyle: No blank lines allowed after function docstring (found {num_lines})
+    "D209",     # pydocstyle: Multi-line docstring closing quotes should be on a separate line
+    "D213",     # pydocstyle: Multi-line docstring summary should start at the second line
+    "DJ",       # flake8-django
+    "DTZ",      # flake8-datetimez
+    "E",        # pycodestyle errors
+    "EM",       # flake8-errmsg
+    "F",        # pyflakes
+    "FA",       # flake8-future-annotations
+    "FBT",      # flake8-boolean-trap
+    "FLY",      # flynt
+    "G",        # flake8-logging-format
+    "I",        # isort
+    "ICN",      # flake8-import-conventions
+    "INP",      # flake8-no-pep420
+    "INT",      # flake8-gettext
+    "ISC",      # flake8-implicit-str-concat
+    "LOG",      # flake8-logging
+    "N",        # pep8-naming
+    "PERF",     # perflint
+    "PGH",      # pygrep-hooks
+    "PIE",      # flake8-pie
+    "PL",       # pylint
+    "PT",       # flake8-pytest-style
+    "PTH",      # flake8-use-pathlib
+    "PYI",      # flake8-pyi
+    "Q",        # flake8-quotes
+    "R",        # Refactor
+    "RET",      # flake8-return
+    "RSE",      # flake8-raise
+    "RUF",      # ruff-specific rules
+    "S",        # flake8-bandit
+    "SIM",      # flake8-simplify
+    "SLF",      # flake8-self
+    "T20",      # flake8-print
+    "TCH",      # flake8-type-checking
+    "TID",      # flake8-tidy-imports
+    "TRY",      # tryceratops
+    "UP",       # pyupgrade
+    "W",        # pycodestyle warnings
+]
+# Preview rules
+lint.extend-select = [
+    "B909",     # loop-iterator-mutation
+    "FURB110",  # if-exp-instead-of-or-operator
+    "FURB142",  # for-loop-set-mutations
+    "FURB145",  # slice-copy
+    "FURB171",  # single-item-membership-test
+    "FURB187",  # list-reverse-copy
+    "PLE0307",  # invalid-str-return-type
+    "PLR0916",  # too-many-boolean-expressions
+    "PLR1730",  # if-stmt-min-max
+    "PLR1733",  # unnecessary-dict-index-lookup
+    "PLR1736",  # unnecessary-list-index-lookup
+    "PLR6104",  # non-augmented-assignment
+    "PLW0211",  # bad-staticmethod-argument
+    "PLW0642",  # self-or-cls-assignment
+    "RUF021",   # parenthesize-chained-operators
+    "RUF022",   # unsorted-dunder-all
+    "UP042",    # replace-str-enum
+]
+lint.ignore = [
+    "ANN101",   # Missing type annotation for `self` in method
+    "ANN102",   # Missing type annotation for `cls` in method
+    "ANN401",   # Any-typing allowed
+    "ARG001",   # Unused function argument
+    "ARG002",   # Unused method argument
+    "ARG003",   # Unused class method argument
+    "RUF012",   # No need for ClassVar
+    "G004",     # Logging statement uses f-string
+    #
+    # Conflicting with ruff-format
+    #
+    "COM812",   # missing-trailing-comma
+    "COM819",   # prohibited-trailing-comma
+    "D206",     # indent-with-spaces
+    "D300",     # triple-single-quotes
+    "E111",     # indentation-with-invalid-multiple
+    "E114",     # indentation-with-invalid-multiple-comment
+    "E117",     # over-indented
+    "ISC001",   # single-line-implicit-string-concatenation
+    "ISC002",   # multi-line-implicit-string-concatenation
+    "Q000",     # bad-quotes-inline-string
+    "Q001",     # bad-quotes-multiline-string
+    "Q002",     # bad-quotes-docstring
+    "Q003",     # avoidable-escaped-quote
+    "W191",     # tab-indentation
+]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"test_*.py" = [
+    "ANN",      # No need to annotate tests
+    "N801",     # Allow whatever class names in tests
+    "N802",     # Allow whatever function names in tests
+    "N815",     # Allow whatever variable names in tests
+    "PLR0915",  # Can have as many statements as needed
+    "PLR2004",  # Magic value comparisons are allowed in tests
+    "S101",     # Assert is fine
+    "S105",     # Hardcoded passwords are fine in tests
+    "S106",     # Hardcoded passwords are fine in tests
+    "S108",     # No need to care about insecure temp file usages in tests
+    "S311",     # Pseudo-random generators are fine here
+    "SLF",      # Allow accessing private members in tests
+    "UP",       # No upgrade rules
+]
+"conftest.py" = [
+    "ARG",      # Fixtures can be unused
+    "ANN",      # No need to annotate tests
+    "UP",       # No upgrade rules
+]
+
+[tool.ruff.lint.isort]
+combine-as-imports = false
+split-on-trailing-comma = false
+known-third-party = [
+    "django",
+]
+known-first-party = [
+    "env_config",
+]
+
+[tool.ruff.lint.flake8-import-conventions]
+banned-from = [
+    "base64",
+    "csv",
+    "datetime",
+    "hashlib",
+    "hmac",
+    "json",
+    "logging",
+    "math",
+    "os",
+    "pickle",
+    "random",
+    "re",
+    "shutil",
+    "subprocess",
+    "sys",
+    "tempfile",
+    "time",
+    "uuid",
+    "xml",
+    "yaml",
+]
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = "True"
+warn_unused_configs = "True"
+ignore_missing_imports = "True"
+plugins = [
+    "mypy_django_plugin.main",
+]
+
+[tool.django-stubs]
+django_settings_module = "tests.project.settings"
+
+[tool.coverage.run]
+relative_files = true
+
+[tool.coverage.report]
+omit = [
+    "tests/*",
+    "docs/*",
+    ".venv/*",
+    ".tox/*",
+]
+exclude_lines = [
+    "if TYPE_CHECKING:",
+    "except ImportError:",
+    "pragma: no cover",
+    "pass",
+]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "tests.project.settings"
+addopts = "-vv -s --disable-warnings"
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+envlist = py{310, 311, 312}-django{42, 50}
+isolated_build = true
+
+[gh-actions]
+python =
+    3.10: py310
+    3.11: py311
+    3.12: py312
+
+[testenv]
+allowlist_externals =
+    poetry
+setenv =
+    PYTHONPATH = {toxinidir}
+    DJANGO_SETTINGS_MODULE = tests.project.settings
+deps =
+    django42: Django >=4.2,<4.3
+    django50: Django >=5.0,<5.1
+
+    python-dotenv
+    dj-database-url
+    django-cache-url
+    typing-extensions
+
+    pytest
+    coverage
+    pytest-django
+commands =
+    coverage run -m pytest -vv -s --disable-warnings
+"""
+
+[build-system]
+requires = ["poetry-core>=1.7.0"]
+build-backend = "poetry.core.masonry.api"