django-stack 0.1.0__tar.gz → 0.3.0__tar.gz

{django_stack-0.1.0 → django_stack-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: django-stack
-Version: 0.1.0
+Version: 0.3.0
 Summary: The backend glue of DjangoStack: settings from environment variables, API defaults, health checks and system checks.
 Project-URL: Homepage, https://github.com/dwarsbit/django-stack
 Project-URL: Source, https://github.com/dwarsbit/django-stack/tree/main/python/django-stack

{django_stack-0.1.0 → django_stack-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-stack"
-version = "0.1.0"
+version = "0.3.0"
 description = "The backend glue of DjangoStack: settings from environment variables, API defaults, health checks and system checks."
 readme = "README.md"
 license = "MIT"

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/__init__.py

@@ -1,3 +1,3 @@
 """The backend glue of DjangoStack."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/backup.py

@@ -1,10 +1,12 @@
 """
-Database backups: ``pg_dump`` to a directory and, optionally, to a private
-S3 bucket, with retention.
+Backups: the database with ``pg_dump`` and, when uploads are stored on
+disk, the media directory as a ``.tar.gz``, to a directory and, optionally,
+to a private S3 bucket, with retention.
 
 The ``backup`` service of a project runs ``run_backups``, which calls
-:func:`create_backup` once a day. ``backup_database`` makes one now and
-``restore_database`` restores one.
+:func:`create_backup` and :func:`create_media_backup` once a day.
+``backup_database`` makes them now, ``restore_database`` and
+``restore_media`` restore them.
 """
 
 from __future__ import annotations
@@ -13,6 +15,7 @@ import os
 import re
 import shutil
 import subprocess
+import tarfile
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
@@ -23,6 +26,8 @@ from django.core.exceptions import ImproperlyConfigured
 from . import conf
 
 NAME_PATTERN = re.compile(r"^(?P<prefix>.+)-(?P<stamp>\d{8}T\d{6}Z)\.dump$")
+MEDIA_PATTERN = re.compile(r"^(?P<prefix>.+)-(?P<stamp>\d{8}T\d{6}Z)\.media\.tar\.gz$")
+MEDIA_SUFFIX = ".media.tar.gz"
 
 
 @dataclass
@@ -69,6 +74,11 @@ def backup_name(now: datetime | None = None) -> str:
     return f"{prefix}-{now.strftime('%Y%m%dT%H%M%SZ')}.dump"
 
 
+def media_name(database_name: str) -> str:
+    """The media archive that belongs to a database dump: same name and time."""
+    return database_name.removesuffix(".dump") + MEDIA_SUFFIX
+
+
 def s3_client():
     """A boto3 client for the backup bucket, with the S3_* credentials."""
     import boto3
@@ -91,13 +101,13 @@ def _s3_target() -> tuple[str, str] | None:
     return bucket, f"{prefix}/" if prefix else ""
 
 
-def create_backup(*, keep: int | None = None) -> Backup:
+def create_backup(*, keep: int | None = None, name: str | None = None) -> Backup:
     """Dump the database, upload it when a backup bucket is set, and apply the retention."""
     pg_dump = shutil.which("pg_dump")
     if pg_dump is None:
         raise ImproperlyConfigured("pg_dump is not installed; install the Postgres client.")
     directory = backup_dir()
-    name = backup_name()
+    name = name or backup_name()
     path = directory / name
     partial = path.with_suffix(".partial")
     subprocess.run(  # noqa: S603 (fixed arguments, no shell)
@@ -110,28 +120,60 @@ def create_backup(*, keep: int | None = None) -> Backup:
     path.chmod(0o600)
     backup = Backup(name=name, path=path)
 
+    _upload(backup)
+    prune(keep if keep is not None else conf.get("BACKUP_KEEP"))
+    return backup
+
+
+def _upload(backup: Backup) -> None:
     target = _s3_target()
     if target:
         bucket, prefix = target
-        s3_client().upload_file(str(path), bucket, f"{prefix}{name}")
+        s3_client().upload_file(str(backup.path), bucket, f"{prefix}{backup.name}")
         backup.uploaded = True
 
-    prune(keep if keep is not None else conf.get("BACKUP_KEEP"))
+
+def media_on_disk() -> bool:
+    """Whether uploads are stored in MEDIA_ROOT, not in S3: only then the media needs a backup."""
+    backend = settings.STORAGES.get("default", {}).get("BACKEND", "")
+    return backend == "django.core.files.storage.FileSystemStorage"
+
+
+def media_backups_enabled() -> bool:
+    return bool(conf.get("BACKUP_MEDIA")) and media_on_disk()
+
+
+def create_media_backup(database_name: str, *, keep: int | None = None) -> Backup:
+    """Archive MEDIA_ROOT next to a database dump, upload it, and apply the retention."""
+    root = Path(settings.MEDIA_ROOT)
+    name = media_name(database_name)
+    path = backup_dir() / name
+    partial = path.with_name(f"{name}.partial")
+    with tarfile.open(partial, "w:gz") as archive:
+        if root.is_dir():
+            for entry in sorted(root.iterdir()):
+                if not entry.name.startswith(".restoring"):
+                    archive.add(entry, arcname=entry.name)
+    partial.rename(path)
+    path.chmod(0o600)
+    backup = Backup(name=name, path=path)
+    _upload(backup)
+    prune(keep if keep is not None else conf.get("BACKUP_KEEP"), pattern=MEDIA_PATTERN)
     return backup
 
 
-def _sorted_names(names) -> list[str]:
+def _sorted_names(names, pattern: re.Pattern = NAME_PATTERN) -> list[str]:
     return sorted(
-        (name for name in names if NAME_PATTERN.match(name)),
-        key=lambda name: NAME_PATTERN.match(name)["stamp"],
+        (name for name in names if pattern.match(name)),
+        key=lambda name: pattern.match(name)["stamp"],
     )
 
 
-def local_backups() -> list[str]:
-    return _sorted_names(path.name for path in backup_dir().iterdir())
+def local_backups(pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    return _sorted_names((path.name for path in backup_dir().iterdir()), pattern)
 
 
-def remote_backups() -> list[str]:
+def remote_backups(pattern: re.Pattern = NAME_PATTERN) -> list[str]:
     target = _s3_target()
     if not target:
         return []
@@ -139,22 +181,22 @@ def remote_backups() -> list[str]:
     names = []
     for page in s3_client().get_paginator("list_objects_v2").paginate(Bucket=bucket, Prefix=prefix):
         names += [item["Key"][len(prefix) :] for item in page.get("Contents", [])]
-    return _sorted_names(names)
+    return _sorted_names(names, pattern)
 
 
-def prune(keep: int) -> list[str]:
-    """Delete all but the ``keep`` newest backups, locally and in the bucket."""
+def prune(keep: int, pattern: re.Pattern = NAME_PATTERN) -> list[str]:
+    """Delete all but the ``keep`` newest backups of a kind, locally and in the bucket."""
     removed = []
     if keep is None or keep <= 0:
         return removed
-    for name in local_backups()[:-keep]:
+    for name in local_backups(pattern)[:-keep]:
         (backup_dir() / name).unlink(missing_ok=True)
         removed.append(name)
     target = _s3_target()
     if target:
         bucket, prefix = target
         client = s3_client()
-        for name in remote_backups()[:-keep]:
+        for name in remote_backups(pattern)[:-keep]:
             client.delete_object(Bucket=bucket, Key=f"{prefix}{name}")
             removed.append(f"s3://{bucket}/{prefix}{name}")
     return removed
@@ -169,7 +211,7 @@ def fetch_backup(name: str) -> Path:
     if local.is_file():
         return local
     target = _s3_target()
-    if target and NAME_PATTERN.match(path.name):
+    if target and (NAME_PATTERN.match(path.name) or MEDIA_PATTERN.match(path.name)):
         bucket, prefix = target
         s3_client().download_file(bucket, f"{prefix}{path.name}", str(local))
         return local
@@ -197,3 +239,30 @@ def restore_backup(path: Path) -> None:
         check=True,
         capture_output=True,
     )
+
+
+def restore_media(path: Path) -> None:
+    """Replace the contents of MEDIA_ROOT with a media archive."""
+    root = Path(settings.MEDIA_ROOT)
+    root.mkdir(parents=True, exist_ok=True)
+    # Extract next to the current files first, so a broken archive changes nothing.
+    staging = root / ".restoring"
+    if staging.exists():
+        shutil.rmtree(staging)
+    staging.mkdir()
+    try:
+        with tarfile.open(path, "r:gz") as archive:
+            archive.extractall(staging, filter="data")
+    except Exception:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    for entry in root.iterdir():
+        if entry == staging:
+            continue
+        if entry.is_dir() and not entry.is_symlink():
+            shutil.rmtree(entry)
+        else:
+            entry.unlink()
+    for entry in staging.iterdir():
+        entry.rename(root / entry.name)
+    staging.rmdir()

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/conf.py

@@ -21,6 +21,8 @@ DEFAULTS = {
     "BACKUP_S3_BUCKET": None,
     "BACKUP_S3_PREFIX": "backups/",
     "BACKUP_S3": {},
+    "BACKUP_MEDIA": True,
+    "BACKUP_DAILY": False,
 }
 
 

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/management/commands/backup_database.py

@@ -7,18 +7,23 @@ from django_stack import backup
 
 
 class Command(BaseCommand):
-    help = "Back up the database with pg_dump, to BACKUP_DIR and the backup bucket, and apply the retention."
+    help = (
+        "Back up the database with pg_dump and, when uploads are on disk, the media directory, "
+        "to BACKUP_DIR and the backup bucket, and apply the retention."
+    )
 
     def add_arguments(self, parser):
         parser.add_argument("--keep", type=int, help="How many backups to keep (default: BACKUP_KEEP).")
         parser.add_argument("--list", action="store_true", help="List the backups instead of making one.")
+        parser.add_argument("--no-media", action="store_true", help="Back up only the database.")
 
-    def handle(self, *args, keep=None, list=False, **options):
+    def handle(self, *args, keep=None, list=False, no_media=False, **options):
         if list:
-            for name in backup.local_backups():
-                self.stdout.write(f"local  {name}")
-            for name in backup.remote_backups():
-                self.stdout.write(f"bucket {name}")
+            for pattern in (backup.NAME_PATTERN, backup.MEDIA_PATTERN):
+                for name in backup.local_backups(pattern):
+                    self.stdout.write(f"local  {name}")
+                for name in backup.remote_backups(pattern):
+                    self.stdout.write(f"bucket {name}")
             return
         try:
             result = backup.create_backup(keep=keep)
@@ -28,3 +33,8 @@ class Command(BaseCommand):
             raise CommandError(f"pg_dump failed: {error.stderr.decode(errors='replace').strip()}") from error
         where = " and the backup bucket" if result.uploaded else ""
         self.stdout.write(self.style.SUCCESS(f"Backed up the database to {result.path}{where}."))
+        if no_media or not backup.media_backups_enabled():
+            return
+        media = backup.create_media_backup(result.name, keep=keep)
+        where = " and the backup bucket" if media.uploaded else ""
+        self.stdout.write(self.style.SUCCESS(f"Backed up the media to {media.path}{where}."))

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/management/commands/restore_database.py

@@ -12,14 +12,21 @@ class Command(BaseCommand):
     def add_arguments(self, parser):
         parser.add_argument("backup", help="A file name from `backup_database --list`, or a path to a dump.")
         parser.add_argument("--yes", action="store_true", help="Don't ask for confirmation.")
+        parser.add_argument(
+            "--media", action="store_true", help="Also restore the media archive made with this backup."
+        )
 
-    def handle(self, *args, yes=False, **options):
+    def handle(self, *args, yes=False, media=False, **options):
         try:
             path = backup.fetch_backup(options["backup"])
+            media_path = backup.fetch_backup(backup.media_name(path.name)) if media else None
         except FileNotFoundError as error:
             raise CommandError(str(error)) from error
+        if media and not backup.media_on_disk():
+            raise CommandError("Uploads are stored in S3, not on disk; restore them from the bucket.")
         if not yes:
-            answer = input(f"Restore {path.name}? Content saved since the backup is lost. Type 'yes': ")
+            what = f"{path.name} and its media" if media_path else path.name
+            answer = input(f"Restore {what}? Content saved since the backup is lost. Type 'yes': ")
             if answer.strip().lower() != "yes":
                 raise CommandError("Not restored.")
         try:
@@ -31,3 +38,6 @@ class Command(BaseCommand):
                 f"pg_restore failed: {error.stderr.decode(errors='replace').strip()}"
             ) from error
         self.stdout.write(self.style.SUCCESS(f"Restored {path.name}."))
+        if media_path:
+            backup.restore_media(media_path)
+            self.stdout.write(self.style.SUCCESS(f"Restored the media from {media_path.name}."))

django_stack-0.3.0/src/django_stack/management/commands/restore_media.py

@@ -0,0 +1,28 @@
+from django.core.management.base import BaseCommand, CommandError
+
+from django_stack import backup
+
+
+class Command(BaseCommand):
+    help = "Replace the media directory with an archive made by backup_database."
+
+    def add_arguments(self, parser):
+        parser.add_argument("backup", help="A .media.tar.gz name from `backup_database --list`, or a path.")
+        parser.add_argument("--yes", action="store_true", help="Don't ask for confirmation.")
+
+    def handle(self, *args, yes=False, **options):
+        if not backup.media_on_disk():
+            raise CommandError("Uploads are stored in S3, not on disk; restore them from the bucket.")
+        try:
+            path = backup.fetch_backup(options["backup"])
+        except FileNotFoundError as error:
+            raise CommandError(str(error)) from error
+        if not yes:
+            answer = input(f"Replace the media with {path.name}? Files uploaded since are lost. Type 'yes': ")
+            if answer.strip().lower() != "yes":
+                raise CommandError("Not restored.")
+        try:
+            backup.restore_media(path)
+        except Exception as error:
+            raise CommandError(f"Could not restore {path.name}: {error}") from error
+        self.stdout.write(self.style.SUCCESS(f"Restored the media from {path.name}."))

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/management/commands/run_backups.py

@@ -21,7 +21,10 @@ def next_run(at: str, now: datetime) -> datetime:
 
 
 class Command(BaseCommand):
-    help = "Back up the database every day at BACKUP_TIME (UTC). The backup service runs this."
+    help = (
+        "Back up the database, and the media when it is on disk, every day at BACKUP_TIME (UTC). "
+        "The backup service runs this."
+    )
 
     def handle(self, *args, **options):
         at = conf.get("BACKUP_TIME")
@@ -37,6 +40,11 @@ class Command(BaseCommand):
                     result.path,
                     " and the bucket" if result.uploaded else "",
                 )
+                if backup.media_backups_enabled():
+                    media = backup.create_media_backup(result.name)
+                    logger.info(
+                        "Backed up the media to %s%s", media.path, " and the bucket" if media.uploaded else ""
+                    )
             except subprocess.CalledProcessError as error:
                 logger.error("pg_dump failed: %s", error.stderr.decode(errors="replace").strip())
             except Exception:

{django_stack-0.1.0 → django_stack-0.3.0}/src/django_stack/settings.py

@@ -27,7 +27,8 @@ to ``SITE_URL``), ``ALLOWED_HOSTS`` (extra hosts, comma separated),
 ``API_SECRET_KEY`` (full access), ``API_READ_KEY`` (read-only),
 ``PREVIEW_SECRET``, ``REVALIDATE_URL``, ``REVALIDATE_SECRET``,
 ``NUM_PROXIES``, ``PROJECT_NAME``, and the backup variables ``BACKUP_DIR``,
-``BACKUP_KEEP``, ``BACKUP_TIME``, ``BACKUP_S3_BUCKET`` and ``BACKUP_S3_PREFIX``.
+``BACKUP_KEEP``, ``BACKUP_TIME``, ``BACKUP_MEDIA``, ``BACKUP_S3_BUCKET`` and
+``BACKUP_S3_PREFIX``.
 """
 
 from __future__ import annotations
@@ -299,6 +300,8 @@ def configure(
             # A private bucket: never the public media bucket.
             "BACKUP_S3_BUCKET": e.str("BACKUP_S3_BUCKET"),
             "BACKUP_S3_PREFIX": e.str("BACKUP_S3_PREFIX", "backups/"),
+            "BACKUP_MEDIA": e.bool("BACKUP_MEDIA", True),
+            "BACKUP_DAILY": e.bool("BACKUP_DAILY", False),
             "BACKUP_S3": {
                 "endpoint_url": e.str("BACKUP_S3_ENDPOINT_URL", e.str("S3_ENDPOINT_URL")),
                 "region_name": e.str("BACKUP_S3_REGION", e.str("S3_REGION")),

django_stack-0.3.0/src/django_stack/tasks.py

@@ -0,0 +1,83 @@
+"""
+The daily backup as a Huey periodic task, run by the worker.
+
+The task runs every hour at the minute of ``BACKUP_TIME`` (UTC) and backs
+up when it is the hour of ``BACKUP_TIME``, or when the newest backup is
+older than a day: that catches up a backup missed while the server or the
+worker was down. The worker also checks once when it starts. It only runs where
+``BACKUP_DAILY`` is on, which the production worker sets.
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime, timedelta
+
+from huey import crontab
+from huey.contrib.djhuey import db_periodic_task, lock_task, on_startup
+
+from . import backup, conf
+
+logger = logging.getLogger("django_stack.backup")
+
+#: A backup older than this is due, whatever the time.
+STALE_AFTER = timedelta(hours=25)
+
+
+def _backup_time() -> tuple[int, int]:
+    value = conf.get("BACKUP_TIME") or "03:00"
+    try:
+        hour, minute = (int(part) for part in value.split(":"))
+    except ValueError:
+        logger.error("BACKUP_TIME must be HH:MM, not %r; using 03:00.", value)
+        return 3, 0
+    return hour, minute
+
+
+def newest_backup_time() -> datetime | None:
+    """The time of the newest database backup, in the volume or the bucket."""
+    names = backup.local_backups()
+    try:
+        names += backup.remote_backups()
+    except Exception:
+        logger.exception("Could not list the backup bucket")
+    stamps = [backup.NAME_PATTERN.match(name)["stamp"] for name in names]
+    if not stamps:
+        return None
+    return datetime.strptime(max(stamps), "%Y%m%dT%H%M%SZ").replace(tzinfo=UTC)
+
+
+def backup_due(now: datetime, newest: datetime | None, hour: int) -> bool:
+    """Whether to back up now: at the hour of BACKUP_TIME, or when the newest backup is stale."""
+    if newest is None or now - newest >= STALE_AFTER:
+        return True
+    return now.hour == hour and now - newest > timedelta(hours=1)
+
+
+def run_daily_backup(now: datetime | None = None) -> bool:
+    """Back up the database and the media when due. Returns whether it backed up."""
+    if not conf.get("BACKUP_DAILY"):
+        return False
+    now = now or datetime.now(UTC)
+    hour, _ = _backup_time()
+    if not backup_due(now, newest_backup_time(), hour):
+        return False
+    result = backup.create_backup()
+    logger.info("Backed up the database to %s%s", result.path, " and the bucket" if result.uploaded else "")
+    if backup.media_backups_enabled():
+        media = backup.create_media_backup(result.name)
+        logger.info("Backed up the media to %s%s", media.path, " and the bucket" if media.uploaded else "")
+    return True
+
+
+@db_periodic_task(crontab(minute=str(_backup_time()[1])), retries=3, retry_delay=600)
+@lock_task("django-stack-backup")
+def daily_backup():
+    run_daily_backup()
+
+
+@on_startup("django-stack-backup-catch-up")
+def catch_up_backup():
+    """When the worker starts, queue the backup; it only runs when one is due."""
+    if conf.get("BACKUP_DAILY"):
+        daily_backup()

{django_stack-0.1.0 → django_stack-0.3.0}/tests/test_backup.py

@@ -1,4 +1,5 @@
 import subprocess
+import tarfile
 from datetime import UTC, datetime
 
 import pytest
@@ -83,3 +84,62 @@ def test_next_run():
     now = datetime(2026, 11, 4, 2, 30, tzinfo=UTC)
     assert next_run("03:00", now) == datetime(2026, 11, 4, 3, 0, tzinfo=UTC)
     assert next_run("02:00", now) == datetime(2026, 11, 5, 2, 0, tzinfo=UTC)
+
+
+@pytest.fixture
+def media(tmp_path, settings, backups):
+    root = tmp_path / "media-root"
+    (root / "images").mkdir(parents=True)
+    (root / "images" / "a.jpg").write_bytes(b"a")
+    (root / "b.pdf").write_bytes(b"b")
+    settings.MEDIA_ROOT = str(root)
+    disk = {"BACKEND": "django.core.files.storage.FileSystemStorage"}
+    settings.STORAGES = {**settings.STORAGES, "default": disk}
+    return root
+
+
+def test_media_name():
+    assert backup.media_name("site-20261104T030000Z.dump") == "site-20261104T030000Z.media.tar.gz"
+
+
+def test_media_backup_and_restore(media, backups):
+    result = backup.create_media_backup("site-20261104T030000Z.dump", keep=5)
+    assert result.path == backups / "site-20261104T030000Z.media.tar.gz"
+    assert backup.local_backups(backup.MEDIA_PATTERN) == [result.name]
+    assert backup.local_backups() == []
+
+    (media / "b.pdf").unlink()
+    (media / "new.txt").write_bytes(b"new")
+    backup.restore_media(backup.fetch_backup(result.name))
+    files = sorted(str(path.relative_to(media)) for path in media.rglob("*"))
+    assert files == ["b.pdf", "images", "images/a.jpg"]
+    assert (media / "images" / "a.jpg").read_bytes() == b"a"
+
+
+def test_broken_media_archive_changes_nothing(media, tmp_path):
+    broken = tmp_path / "broken.media.tar.gz"
+    broken.write_bytes(b"not a tar")
+    with pytest.raises(tarfile.ReadError):
+        backup.restore_media(broken)
+    assert (media / "b.pdf").exists()
+    assert not (media / ".restoring").exists()
+
+
+def test_media_retention_is_separate(media, backups):
+    for day in range(1, 4):
+        (backups / f"site-2026110{day}T030000Z.dump").write_bytes(b"")
+        backup.create_media_backup(f"site-2026110{day}T030000Z.dump", keep=2)
+    assert backup.local_backups(backup.MEDIA_PATTERN) == [
+        "site-20261102T030000Z.media.tar.gz",
+        "site-20261103T030000Z.media.tar.gz",
+    ]
+    assert len(backup.local_backups()) == 3
+
+
+def test_media_backups_only_on_disk(media, settings):
+    assert backup.media_backups_enabled()
+    settings.DJANGO_STACK = {**settings.DJANGO_STACK, "BACKUP_MEDIA": False}
+    assert not backup.media_backups_enabled()
+    settings.DJANGO_STACK = {**settings.DJANGO_STACK, "BACKUP_MEDIA": True}
+    settings.STORAGES = {**settings.STORAGES, "default": {"BACKEND": "storages.backends.s3.S3Storage"}}
+    assert not backup.media_backups_enabled()

django_stack-0.3.0/tests/test_tasks.py

@@ -0,0 +1,49 @@
+from datetime import UTC, datetime, timedelta
+
+import pytest
+
+from django_stack import backup, tasks
+
+NOW = datetime(2026, 11, 5, 3, 0, tzinfo=UTC)
+
+
+def test_backup_due_at_the_hour_or_when_stale():
+    assert tasks.backup_due(NOW, None, 3)
+    assert tasks.backup_due(NOW, NOW - timedelta(hours=24), 3)
+    assert not tasks.backup_due(NOW, NOW - timedelta(minutes=30), 3)
+    assert not tasks.backup_due(NOW.replace(hour=10), NOW - timedelta(hours=7), 3)
+    assert tasks.backup_due(NOW.replace(hour=10), NOW - timedelta(hours=26), 3)
+
+
+@pytest.fixture
+def daily(tmp_path, settings, monkeypatch):
+    settings.DJANGO_STACK = {
+        **settings.DJANGO_STACK,
+        "BACKUP_DIR": str(tmp_path),
+        "BACKUP_S3_BUCKET": None,
+        "BACKUP_DAILY": True,
+        "BACKUP_MEDIA": False,
+    }
+    made = []
+
+    def fake_backup():
+        name = backup.backup_name()
+        (tmp_path / name).write_bytes(b"")
+        made.append(name)
+        return backup.Backup(name=name, path=tmp_path / name)
+
+    monkeypatch.setattr(backup, "create_backup", fake_backup)
+    return made
+
+
+def test_daily_backup_catches_up_and_then_waits(daily):
+    assert tasks.run_daily_backup(NOW.replace(hour=10))
+    assert len(daily) == 1
+    assert not tasks.run_daily_backup(datetime.now(UTC))
+    assert len(daily) == 1
+
+
+def test_daily_backup_is_off_by_default(daily, settings):
+    settings.DJANGO_STACK = {**settings.DJANGO_STACK, "BACKUP_DAILY": False}
+    assert not tasks.run_daily_backup(NOW)
+    assert daily == []

{django_stack-0.1.0 → django_stack-0.3.0}/uv.lock

@@ -144,7 +144,7 @@ schema = [
 
 [[package]]
 name = "django-stack"
-version = "0.1.0"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "django" },