lino 25.7.3__tar.gz → 25.8.0__tar.gz

{lino-25.7.3 → lino-25.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lino
-Version: 25.7.3
+Version: 25.8.0
 Summary: A framework for writing desktop-like web applications using Django and ExtJS or React
 Project-URL: Homepage, https://www.lino-framework.org
 Project-URL: Repository, https://gitlab.com/lino-framework/lino

{lino-25.7.3 → lino-25.8.0}/lino/__init__.py

@@ -31,7 +31,7 @@ from django import VERSION
 from django.apps import AppConfig
 from django.conf import settings
 import warnings
-__version__ = '25.7.3'
+__version__ = '25.8.0'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

{lino-25.7.3 → lino-25.8.0}/lino/core/actions.py

@@ -233,7 +233,7 @@ class Action(Parametrizable, Permittable):
 
     def full_name(self, actor=None):
         if self.action_name is None:
-            raise Exception("Tried to full_name() on %r" % self)
+            raise Exception(f"Tried to full_name() on {repr(self)}")
             # ~ return repr(self)
         if actor is None or (self.parameters and not self.no_params_window):
             return self.defining_actor.actor_id + "." + self.action_name
@@ -362,6 +362,7 @@ class ShowDetail(Action):
     ui5_icon_name = "sap-icon://detail-view"
     opens_a_window = True
     window_type = constants.WINDOW_TYPE_DETAIL
+    show_in_toolbar = False
     show_in_workflow = False
     save_action_name = "submit_detail"
     callable_from = "t"

{lino-25.7.3 → lino-25.8.0}/lino/core/dbtables.py

@@ -440,7 +440,10 @@ class Table(AbstractTable):
 
             # if self.master is not None:
             #     self.master = resolve_model(self.master)
-            if self.master_key:
+
+            # For abstract tables  we don't check the master key, e.g.
+            # tickets.TicketsByGroup
+            if self.master_key and not self.abstract:
                 master_model = None
                 try:
                     fk = self.model.get_data_elem(self.master_key)

{lino-25.7.3 → lino-25.8.0}/lino/core/site.py

@@ -670,18 +670,16 @@ class Site(object):
                         "formatter": "verbose",
                     }
             elif self.use_systemd:
-                handlers["file"] = {
-                    "class": "systemd.journal.JournalHandler",
-                    "SYSLOG_IDENTIFIER": str(self.project_name),
-                }
-                # try:
-                #     from systemd.journal import JournalHandler
-                #     handlers["file"] = {
-                #         "class": "systemd.journal.JournalHandler",
-                #         "SYSLOG_IDENTIFIER": str(self.project_name),
-                #     }
-                # except ImportError:
-                #     pass
+                try:
+                    from systemd.journal import JournalHandler
+                    handlers["file"] = {
+                        "class": "systemd.journal.JournalHandler",
+                        "SYSLOG_IDENTIFIER": str(self.project_name),
+                    }
+                except ImportError:
+                    # Silenly ignore. Can happen when use_systemd is True but
+                    # `pm install` hasn't yet been run.
+                    pass
 
         # when a file handler exists, we have the loggers use it even if this
         # instance didn't create it:
@@ -919,8 +917,6 @@ class Site(object):
             extends_models = pc.__dict__.get("extends_models")
             if extends_models is not None:
                 for m in extends_models:
-                    if "." in m:
-                        raise Exception("extends_models in %s still uses '.'" % pc)
                     for pp in plugin_parents(pc):
                         if pp is pc:
                             continue

{lino-25.7.3 → lino-25.8.0}/lino/help_texts.py

@@ -232,7 +232,7 @@ help_texts = {
     'lino.utils.djangotest.RestoreTestCase' : _("""Used for testing migrations from previous versions."""),
     'lino.utils.djangotest.RestoreTestCase.tested_versions' : _("""A list of strings, each string is a version for which there must be a migration dump created by makemigdump."""),
     'lino.utils.dpy.FakeDeserializedObject' : _("""Imitates DeserializedObject required by loaddata."""),
-    'lino.utils.dpy.FakeDeserializedObject.try_save' : _("""Try to save the specified Model instance obj. Return True on success, False if this instance wasn’t saved and should be deferred."""),
+    'lino.utils.dpy.FakeDeserializedObject.try_save' : _("""Try to save this Model instance."""),
     'lino.utils.dpy.Serializer' : _("""Serializes a QuerySet to a py stream."""),
     'lino.utils.dpy.FlushDeferredObjects' : _("""Indicator class object. Fixture may yield a FlushDeferredObjects to indicate that all deferred objects should get saved before going on."""),
     'lino.utils.dpy.DpyLoader' : _("""Instantiated by restore.py."""),

lino-25.8.0/lino/management/commands/ddt.py

@@ -0,0 +1,60 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2025 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+# import shutil
+from click import confirm
+import subprocess
+from django.db import DEFAULT_DB_ALIAS
+from django.core.management import call_command
+from django.core.management.base import BaseCommand, CommandError
+from django.conf import settings
+
+
+class Command(BaseCommand):
+    help = "Run a double-dump test on this site."
+
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        (
+            parser.add_argument(
+                "-b", "--batch", "--noinput",
+                action="store_false",
+                dest="interactive",
+                default=True,
+                help="Do not prompt for input of any kind.",
+            ),
+        )
+
+    def runcmd(self, cmd, **options):
+        bashopts = dict(shell=True, universal_newlines=True)
+        cp = subprocess.run(cmd, **bashopts)
+        if cp.returncode != 0:
+            # subprocess.run("sudo journalctl -xe", **kw)
+            raise CommandError(f"{cmd} ended with return code {cp.returncode}")
+
+    def handle(self, *args, **options):
+        if len(args) > 0:
+            raise CommandError("This command takes no arguments (got %r)" % args)
+
+        using = options.get("database", DEFAULT_DB_ALIAS)
+        dbname = settings.DATABASES[using]["NAME"]
+        interactive = options.get("interactive")
+        if interactive:
+            msg = f"WARNING: running this test can break your database ({dbname})."
+            msg += "\nAre you sure?"
+            if not confirm(msg, default=True):
+                raise CommandError("User abort.")
+
+        kwargs = dict()
+        kwargs["interactive"] = False
+        kwargs["verbosity"] = options.get("verbosity")
+        tmpdir = settings.SITE.site_dir / "tmp"
+        # call_command("prep", '--keepmedia', **kwargs)
+        call_command("dump2py", '-o', tmpdir / "a", **kwargs)
+        self.runcmd(f"python manage.py run {str(tmpdir / 'a' / 'restore.py')} -b")
+        call_command("dump2py", '-o', tmpdir / "b", **kwargs)
+        self.runcmd(f"diff {tmpdir / 'a'} {tmpdir / 'b'}")
+        print(f"Successfully ran double-dump test in {tmpdir}.")
+        # print(f"The double-dump test was successful, we can remove {tmpdir}.")
+        # shutil.rmtree(tmpdir)

{lino-25.7.3 → lino-25.8.0}/lino/management/commands/dump2py.py

@@ -300,7 +300,7 @@ def bv2kw(fieldname, values):
             """
 
 def main(args):
-    loader = DpyLoader(globals(), quick=args.quick)
+    loader = DpyLoader(globals(), quick=args.quick, strict=True)
     from django.core.management import call_command
     call_command('initdb', interactive=args.interactive)
     os.chdir(os.path.dirname(__file__))
@@ -449,35 +449,23 @@ if __name__ == '__main__':
                     hope = True
                     break
 
-                # ~ ok = True
-                # ~ for d in deps:
-                # ~ if d in unsorted:
-                # ~ ok = False
-                # ~ if ok:
-                # ~ sorted.append(model)
-                # ~ unsorted.remove(model)
-                # ~ hope = True
-                # ~ break
-                # ~ else:
-                # ~ guilty[model] = deps
-                # ~ print model.__name__, "depends on", [m.__name__ for m in deps]
-        if unsorted:
+        if len(unsorted):
             assert len(unsorted) == len(guilty)
-            msg = "There are %d models with circular dependencies :\n" % len(unsorted)
+            todo = [(m, m.objects.count(), guilty[m]) for m in unsorted]
+            todo.sort(key=lambda i: i[1])
+
+            msg = "There are %d models with circular dependencies :\n" % len(todo)
             msg += "- " + "\n- ".join(
                 [
                     full_model_name(m)
-                    + " (depends on %s)" % ", ".join([full_model_name(d) for d in deps])
-                    for m, deps in guilty.items()
-                ]
-            )
-            if False:
-                # we don't write them to the .py file because they are
-                # in random order which would cause false ddt to fail
-                for ln in msg.splitlines():
-                    self.stream.write("\n# %s" % ln)
+                    + " (%d rows, depends on %s)" % (
+                        count, ", ".join([full_model_name(d) for d in deps])
+                    ) for m, count, deps in todo]
+            ) + "\n\n"
+            for ln in msg.splitlines():
+                self.stream.write("\n# %s" % ln)
             logger.info(msg)
-            sorted.extend(unsorted)
+            sorted.extend([i[0] for i in todo])
         return sorted
 
     def value2string(self, obj, field):

{lino-25.7.3 → lino-25.8.0}/lino/management/commands/prep.py

@@ -24,7 +24,7 @@ class Command(BaseCommand):
         )
         (
             parser.add_argument(
-                "--keepmedia",
+                "-k", "--keepmedia",
                 action="store_true",
                 dest="keepmedia",
                 default=False,

{lino-25.7.3 → lino-25.8.0}/lino/modlib/comments/mixins.py

@@ -123,10 +123,9 @@ class Commentable(MemoReferrable):
         return _("Created new {model} {obj}.").format(
             model=self.__class__._meta.verbose_name, obj=self)
 
-    @classmethod
-    def add_comments_filter(cls, qs, ar):
-        return qs
+    # @classmethod
+    # def add_comments_filter(cls, qs, ar):
+    #     return qs
 
-    def is_comment_private(self, comment, ar):
-        """Whether the given comment should be private."""
-        return dd.plugins.comments.private_default
+    def on_create_comment(self, comment, ar):
+        comment.private = dd.plugins.comments.private_default

{lino-25.7.3 → lino-25.8.0}/lino/modlib/comments/models.py

@@ -9,7 +9,7 @@ from django.db import models
 from django.db.models import Q
 from django.core import validators
 from django.utils.html import mark_safe, format_html, SafeString
-from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import ngettext
 from django.conf import settings
 # from lino.utils.html import E, tostring, fromstring
 
@@ -24,6 +24,7 @@ from lino.modlib.search.mixins import ElasticSearchable
 from lino.modlib.gfks.mixins import Controllable
 from lino.modlib.memo.mixins import Previewable, MemoReferrable
 from lino.modlib.publisher.mixins import Publishable
+from lino_xl.lib.groups.mixins import Groupwise
 from .choicelists import CommentEvents, Emotions
 from .mixins import Commentable, MyEmotionField
 from .roles import CommentsReader, CommentsStaff
@@ -49,8 +50,9 @@ class Comment(
     Publishable,
     DateRangeObservable,
     MemoReferrable,
+    Groupwise
 ):
-    class Meta(object):
+    class Meta:
         app_label = "comments"
         abstract = dd.is_abstract_model(__name__, "Comment")
         verbose_name = _("Comment")
@@ -119,8 +121,7 @@ class Comment(
     # more_text = dd.RichTextField(_("More text"), blank=True)
 
     private = models.BooleanField(
-        _("Confidential"), default=dd.plugins.comments.private_default
-    )
+        _("Confidential"), default=dd.plugins.comments.private_default)
 
     comment_type = dd.ForeignKey("comments.CommentType", blank=True, null=True)
     # reply_vote = models.BooleanField(_("Upvote"), null=True, blank=True)
@@ -187,10 +188,10 @@ class Comment(
         # if o.emotion.button_text:
         #     yield o.emotion.button_text
         #     yield " "
-        if False:
-            attrs = {"class": "bordertext"}
-        else:
-            attrs = {}
+        # if False:
+        #     attrs = {"class": "bordertext"}
+        # else:
+        #     attrs = {}
         s += ar.obj2htmls(o, naturaltime(o.created), title=t)
         s += format_html(" {} ", _("by"))
         if o.user is None:
@@ -284,7 +285,7 @@ class Comment(
     def on_create(self, ar):
         super().on_create(ar)
         if self.owner_id:
-            self.private = self.owner.is_comment_private(self, ar)
+            self.owner.on_create_comment(self, ar)
 
     def after_ui_save(self, ar, cw):
         super().after_ui_save(ar, cw)
@@ -355,9 +356,10 @@ class Comment(
             qs = qs.filter(private=False)
         elif not user.user_type.has_required_roles([CommentsStaff]):
             qs = qs.filter(Q(private=False) | Q(user=user))
-        sar = BaseRequest(user=ar.get_user())
-        for m in rt.models_by_base(Commentable):
-            qs = m.add_comments_filter(qs, sar)
+
+        # sar = BaseRequest(user=ar.get_user())
+        # for m in rt.models_by_base(Commentable):
+        #     qs = m.add_comments_filter(qs, sar)
 
         qs = qs.annotate(num_replies=models.Count("replies_to_this"))
         qs = qs.annotate(num_reactions=models.Count("reactions_to_this"))

{lino-25.7.3 → lino-25.8.0}/lino/modlib/comments/ui.py

@@ -3,7 +3,6 @@
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 from lino.modlib.publisher.choicelists import PageFillers
-from django.utils.translation import ngettext
 from django.contrib.humanize.templatetags.humanize import naturaltime
 from django.contrib.contenttypes.models import ContentType
 from django.db import models

{lino-25.7.3 → lino-25.8.0}/lino/modlib/memo/mixins.py

@@ -214,6 +214,8 @@ class Previewable(BasePreviewable):
     body_short_preview = RichTextField(_("Preview"), blank=True, editable=False)
     body_full_preview = RichTextField(_("Preview (full)"), blank=True, editable=False)
 
+    edit_body = dd.ShowEditor("body")
+
     def get_body_parsed(self, ar, short=False):
         if ar.renderer is settings.SITE.kernel.editing_front_end.renderer:
             return self.body_short_preview if short else self.body_full_preview

{lino-25.7.3 → lino-25.8.0}/lino/modlib/publisher/models.py

@@ -38,6 +38,7 @@ from lino.modlib.linod.choicelists import schedule_daily
 from lino.modlib.memo.mixins import Previewable
 from lino.mixins.polymorphic import Polymorphic
 from lino_xl.lib.topics.mixins import Taggable
+from lino_xl.lib.groups.mixins import Groupwise
 # from .utils import render_node
 
 from lino.api import rt, dd
@@ -50,19 +51,22 @@ from .ui import *
 
 
 class Page(
-    Hierarchical, Sequenced, Previewable, Commentable, PublishableContent, Taggable
+    Hierarchical, Sequenced, Previewable, Commentable, PublishableContent,
+    Taggable  # , Groupwise
 ):
     class Meta:
         verbose_name = _("Page")
         verbose_name_plural = _("Pages")
         abstract = dd.is_abstract_model(__name__, "Page")
+        # if dd.is_installed("groups"):
+        #     unique_together = ["group", "ref", "language"]
+        # else:
+        #     unique_together = ["ref", "language"]
         unique_together = ["ref", "language"]
 
     memo_command = "page"
 
-    ref = models.CharField(
-        _("Reference"), max_length=200, blank=True, null=True)
-
+    ref = dd.CharField(_("Reference"), max_length=200, blank=True, null=True)
     title = dd.CharField(_("Title"), max_length=250, blank=True)
     child_node_depth = models.IntegerField(default=1)
     # page_type = PageTypes.field(blank=True, null=True)
@@ -362,10 +366,14 @@ class Page(
     #     return True
 
     def get_absolute_url(self, **kwargs):
+        parts = []
+        if self.group is not None:
+            if self.group.ref is not None:
+                parts.append(self.group.ref)
         if self.ref:
             if self.ref != "index":
-                return dd.plugins.publisher.build_plain_url(self.ref, **kwargs)
-        return dd.plugins.publisher.build_plain_url(**kwargs)
+                parts.append(self.group.ref)
+        return dd.plugins.publisher.build_plain_url(*parts, **kwargs)
 
     def get_publisher_response(self, ar):
         if ar and ar.request and self.language != ar.request.LANGUAGE_CODE:
@@ -382,8 +390,7 @@ class Page(
                     sources.add(p.id)
                     p = p.translated_from
                 qs = self.__class__.objects.filter(
-                    language=rqlang, translated_from__in=sources
-                )
+                    language=rqlang, translated_from__in=sources)
                 obj = qs.first()
                 # obj = self.translated_to.filter(language=rqlang).first()
             # print("20231027 redirect to translation", tt.language, ar.request.LANGUAGE_CODE)

{lino-25.7.3 → lino-25.8.0}/lino/utils/cycler.py

@@ -51,14 +51,17 @@ class Cycler(object):
             return item.pop()
         return item
 
+    def reset(self):
+        self.current = 0
+
     def __len__(self):
         return len(self.items)
 
+    def __iter__(self):
+        return self.items.__iter__()
+
     def __repr__(self):
         return f"Cycler({self.current} of {len(self.items)} in loop {self.loop_no})"
 
-    def reset(self):
-        self.current = 0
-
     def __getitem__(self, *args):
         return self.items.__getitem__(*args)

{lino-25.7.3 → lino-25.8.0}/lino/utils/dpy.py

@@ -6,30 +6,27 @@ Defines Lino's **Python serializer and deserializer**.  See
 :doc:`Specification </specs/dpy>`.
 """
 
-from lino import logger
-from packaging.version import Version
-
+# import traceback
 import os
 import importlib.util
 import sys
-from unipath import Path
+from packaging.version import Version
+from pathlib import Path
 # from lino import AFTER17
-
 from django.conf import settings
 from django.db import models
-
 from django.utils import translation
 from django.utils.module_loading import import_string
 from django.utils.encoding import force_str
-
 # from django.db import IntegrityError
 from django.core.serializers import base
 from django.core.exceptions import ValidationError
 # from django.core.exceptions import ObjectDoesNotExist
-
 # from lino.utils.mldbc.fields import BabelCharField, BabelTextField
 # from lino.core.choicelists import ChoiceListField
 from lino.core.utils import obj2str, full_model_name
+from lino.core.fields import VirtualField
+from lino import logger
 
 SUFFIX = ".py"
 
@@ -118,7 +115,7 @@ if SUPPORT_EMPTY_FIXTURES:
 class FakeDeserializedObject(base.DeserializedObject):
     """Imitates DeserializedObject required by loaddata.
 
-    Unlike normal DeserializedObject, we *don't want* to bypass
+    Unlike normal DeserializedObject, we do *not* want to bypass
     pre_save and validation methods on the individual objects.
 
     """
@@ -126,7 +123,6 @@ class FakeDeserializedObject(base.DeserializedObject):
     def __init__(self, deserializer, object, **kw):
         super().__init__(object, deserializer, **kw)
         self.object = object
-        # self.name = name
         self.deserializer = deserializer
 
     def save(self, *args, **kw):
@@ -134,16 +130,9 @@ class FakeDeserializedObject(base.DeserializedObject):
         # logger.info("Loading %s...",self.name)
 
         self.try_save(*args, **kw)
-        # if self.try_save(*args,**kw):
-        # self.deserializer.saved += 1
-        # else:
-        # self.deserializer.save_later.append(self)
 
     def try_save(self, *args, **kw):
-        """Try to save the specified Model instance `obj`. Return `True`
-        on success, `False` if this instance wasn't saved and should be
-        deferred.
-        """
+        """Try to save this Model instance."""
         obj = self.object
         try:
             m = getattr(obj, "before_dumpy_save", None)
@@ -152,39 +141,56 @@ class FakeDeserializedObject(base.DeserializedObject):
             if not self.deserializer.quick:
                 try:
                     obj.full_clean()
-                except ValidationError as e:
+                except ValidationError:
                     # raise Exception("{0} : {1}".format(obj2str(obj), e))
                     raise  # Exception("{0} : {1}".format(obj2str(obj), e))
             obj.save(*args, **kw)
-            logger.debug("%s has been saved" % obj2str(obj))
+            logger.debug("%s has been saved", obj2str(obj))
             self.deserializer.register_success()
-            return True
-        # except ValidationError,e:
-        # except ObjectDoesNotExist,e:
-        # except (ValidationError,ObjectDoesNotExist), e:
-        # except (ValidationError,ObjectDoesNotExist,IntegrityError), e:
         except Exception as e:
-            if True:
-                if not settings.SITE.loading_from_dump:
-                    # hand-written fixtures are expected to yield in savable
-                    # order
-                    logger.warning(
-                        "Failed to save %s from manual fixture:" % obj2str(obj)
-                    )
-                    raise
+            if not settings.SITE.loading_from_dump:
+                # hand-written fixtures are expected to yield in savable order
+                logger.warning(
+                    "Failed to save %s from manual fixture:", obj2str(obj))
+                raise
             deps = [
-                f.remote_field.model
-                for f in obj._meta.fields
-                if f.remote_field and f.remote_field.model
-            ]
+                f for f in obj._meta.fields
+                if f.remote_field and f.remote_field.model]
             if not deps:
-                logger.exception(e)
-                raise Exception("Failed to save independent %s." % obj2str(obj))
+                # logger.exception(e)
+                msg = f"Failed to save independent {obj2str(obj)}."
+                raise Exception(msg) from e
+            self.on_restore_failure(obj)
             self.deserializer.register_failure(self, e)
-            return False
-        # except Exception,e:
-        # logger.exception(e)
-        # raise Exception("Failed to save %s. Abandoned." % obj2str(obj))
+
+    def on_restore_failure(self, obj):
+        # When a database row fails to save during restore.py, Lino looks
+        # whether it has nullable FK fields that aren't null, set these to None
+        # and try to save an intermediate row.
+
+        nullable = dict()
+        # required = dict()
+        for f in obj._meta.fields:
+            if f.remote_field and f.remote_field.model:
+                if f.null and (v := f.value_from_object(obj)) is not None:
+                    nullable[f] = v
+        if not (nullable):
+            return
+        for f in nullable.keys():
+            setattr(obj, f.attname, None)
+            # f.set_value_in_object(obj, None)
+        try:
+            obj.full_clean()
+            obj.save()
+        except Exception:
+            pass
+        for f, v in nullable.items():
+            setattr(obj, f.attname, v)
+            # f.set_value_in_object(obj, v)
+        logger.info(
+            "Save intermediate %s without %s",
+            obj.__class__.__name__,
+            ", ".join([f"{f.name}={v}" for f, v in nullable.items()]))
 
 
 class Serializer(base.Serializer):
@@ -205,7 +211,7 @@ class Serializer(base.Serializer):
         raise NotImplementedError("Don't use dumpdata but `dump2py`")
 
 
-class FlushDeferredObjects(object):
+class FlushDeferredObjects:
     """
     Indicator class object.
     Fixture may yield a `FlushDeferredObjects`
@@ -215,10 +221,11 @@ class FlushDeferredObjects(object):
     pass
 
 
-class LoaderBase(object):
+class LoaderBase:
     quick = False
     source_version = None
-    max_deferred_objects = 1000
+    max_deferred_objects = 4000
+    strict = False
 
     def __init__(self):
         # logger.info("20120225 DpyLoader.__init__()")
@@ -282,13 +289,13 @@ class LoaderBase(object):
             self.flush_deferred_objects()
             if count > self.max_deferred_objects + 1:
                 raise Exception(
-                    "More than {} deferred objects".format(self.max_deferred_objects)
-                )
+                    f"More than {self.max_deferred_objects} deferred objects")
         l.append(obj)
         # report a full traceback, but only once per model and
         # exception type:
         k = (obj.object.__class__, e.__class__)
         if k not in self.reported_tracebacks:
+            # traceback.print_exc(e)
             logger.exception(e)
             self.reported_tracebacks.add(k)
 
@@ -333,14 +340,17 @@ class LoaderBase(object):
                             ", ".join([str(o.object.pk) for o in objects]),
                         )
                     count += len(objects)
-            msg = "Abandoning with {} unsaved instances:{}"
-            logger.warning(msg.format(count, s))
-
-            # Don't raise an exception. The unsaved instances got lost and
-            # the loaddata should be done again, but meanwhile the database
-            # is not necessarily invalid and may be used for further testing.
-            # And anyway, loaddata would catch it and still continue.
-            # raise Exception(msg)
+            msg = f"Abandoning with {count} unsaved instances:{s}"
+            if self.strict:
+                raise Exception(msg)
+            logger.warning(msg)
+
+            # Until 20250730: Don't raise an exception. The unsaved instances
+            # got lost and the loaddata should be done again, but meanwhile the
+            # database is not necessarily invalid and may be used for further
+            # testing. And anyway, loaddata would catch it and still continue.
+            # Since 20250730: But we need a way to make sure that the restore.py
+            # worked well.
 
         settings.SITE.loading_from_dump = False
         # reset to False because the same SITE might get reused by
@@ -350,11 +360,12 @@ class LoaderBase(object):
 class DpyLoader(LoaderBase):
     """Instantiated by :xfile:`restore.py`."""
 
-    def __init__(self, globals_dict, quick=None):
+    def __init__(self, globals_dict, quick=None, strict=True):
         if quick is not None:
             self.quick = quick
         self.globals_dict = globals_dict
-        super(DpyLoader, self).__init__()
+        self.strict = strict
+        super().__init__()
         self.source_version = globals_dict["SOURCE_VERSION"]
         site = globals_dict["settings"].SITE
         site.startup()
@@ -369,7 +380,7 @@ class DpyDeserializer(LoaderBase):
     """The Django deserializer for :ref:`dpy`.
 
     Note that this deserializer explicitly ignores fixtures whose
-    source file is located in the current directory because i the case
+    source file is located in the current directory because in the case
     of `.py` files this can lead to side effects when importing them.
     See e.g. :ticket:`1029`.  We consider it an odd behaviour of
     Django to search for fixtures also in the current directory (and