lino 25.7.2__py3-none-any.whl → 25.8.0__py3-none-any.whl

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.2'
+__version__ = '25.8.0'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/doctest.py

@@ -14,6 +14,7 @@ tested document. It includes
 
 """
 
+from lino.mixins.clonable import Clonable
 from lino.utils.fieldutils import get_fields, fields_help
 from lino.core.boundaction import BoundAction
 from lino.core.tables import AbstractTable
@@ -23,7 +24,9 @@ from lino.core.actions import ShowTable
 from lino.core.menus import Menu
 from lino.utils.html import html2text
 from lino.utils import dbhash
-from lino.core.utils import full_model_name, get_models
+from lino.core.utils import get_models
+from lino.core.utils import full_model_name
+from lino.core.utils import full_model_name as fmn
 from lino.utils.diag import visible_for
 from lino.sphinxcontrib.actordoc import menuselection_text
 from lino import logger
@@ -746,7 +749,7 @@ def show_change_watchers():
         ws = m.change_watcher_spec
         if ws:
             rows.append(
-                [full_model_name(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
+                [fmn(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
             )
     print(rstgen.table(headers, rows, max_width=40))
 
@@ -801,3 +804,26 @@ def checkdb(m, num):
     if m.objects.count() != num:
         raise Exception(
             f"Model {m} should have {num} rows but has {m.objects.count()}")
+
+
+def show_clonables():
+    """
+    Print a list of all :class:`Clonable <lino.mixins.clonable.Clonable>`
+    models, together with their related slaves, i.e. the data that will be
+    cloned in cascade with their master.
+    """
+    items = []
+    for m in get_models():
+        if issubclass(m, Clonable):
+            rels = []
+            if (obj := m.objects.first()) is not None:
+                new, related = obj.duplication_plan()
+                for fk, qs in related:
+                    rels.append(f"{fmn(qs.model)}.{fk.name}")
+            if len(rels):
+                x = ", ".join(rels)
+                items.append(f"{fmn(m)} : {x}")
+            else:
+                items.append(fmn(m))
+    items = sorted(items)
+    print(rstgen.ul(items).strip())

lino/core/actions.py

@@ -98,6 +98,13 @@ class Action(Parametrizable, Permittable):
                 raise Exception(
                     "Unkonwn icon_name '{0}'".format(self.icon_name))
 
+        params = {}
+        if self.parameters is not None:
+            params.update(self.parameters)
+        self.setup_parameters(params)
+        if len(params):
+            self.parameters = params
+
         register_params(self)
 
         if self.callable_from is not None:
@@ -151,6 +158,9 @@ class Action(Parametrizable, Permittable):
 
         return decorator
 
+    def setup_parameters(self, params):
+        pass
+
     def get_help_text(self, ba):
         if ba is ba.actor.default_action:
             if self.default_record_id is not None:
@@ -223,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
@@ -352,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/core/atomizer.py

@@ -309,10 +309,10 @@ def fields_list(model, field_names):
     Return a set with the names of the specified fields, checking
     whether each of them exists.
 
-    Arguments: `model` is any subclass of `django.db.models.Model`. It
-    may be a string with the full name of a model
-    (e.g. ``"myapp.MyModel"``).  `field_names` is a single string with
-    a space-separated list of field names.
+    Arguments: `model` is any subclass of `django.db.models.Model`. It may be a
+    string with the full name of a model (e.g. ``"myapp.MyModel"``).
+    `field_names` is an iterable of field names or a single string with a
+    space-separated list of field names.
 
     If one of the names refers to a dummy field, this name will be ignored
     silently.
@@ -326,16 +326,17 @@ def fields_list(model, field_names):
     iterable on the fields.
     """
     lst = set()
-    names_list = field_names.split()
+    if isinstance(field_names, str):
+        field_names = field_names.split()
 
-    for name in names_list:
+    for name in field_names:
         if name == "*":
             explicit_names = set()
             for name in names_list:
                 if name != "*":
                     explicit_names.add(name)
             for de in fields.wildcard_data_elems(model):
-                if not isinstance(de, DummyField):
+                if not isinstance(de, fields.DummyField):
                     if de.name not in explicit_names:
                         if fields.use_as_wildcard(de):
                             lst.add(de.name)
@@ -343,7 +344,7 @@ def fields_list(model, field_names):
             e = model.get_data_elem(name)
             if e is None:
                 raise fields.FieldDoesNotExist(
-                    "No data element %r in %s" % (name, model))
+                    f"No data element '{name}' in {model}")
             if not hasattr(e, "name"):
                 raise fields.FieldDoesNotExist(
                     "%s %r in %s has no name" % (e.__class__, name, model)

lino/core/auth/utils.py

@@ -73,7 +73,8 @@ class AnonymousUser:
 
 
 def activate_social_auth_testing(
-    globals_dict, google=True, github=True, wikimedia=True, facebook=True
+    globals_dict, google=True, github=True, wikimedia=True, facebook=True,
+    smart_id=False
 ):
     """
     Used for testing a development server.
@@ -97,6 +98,13 @@ def activate_social_auth_testing(
         # 'social_core.backends.google.GoogleOAuth2',
         # 'social_core.backends.google.GoogleOAuth',
         # 'social_core.backends.facebook.FacebookOAuth2',
+    if smart_id:
+        Site.social_auth_backends.append("lino.utils.smart_id.SmartID")
+        # https://oauth.ee/docs
+        globals_dict.update(
+            SOCIAL_AUTH_SMART_ID_KEY="xxx",
+            SOCIAL_AUTH_SMART_ID_SECRET="yyy",
+        )
     if wikimedia:
         Site.social_auth_backends.append("social_core.backends.mediawiki.MediaWiki")
         globals_dict.update(

lino/core/callbacks.py

@@ -72,9 +72,9 @@ class Callback(object):
         - func: a callable to be executed when user selects this choice
         - the label of the button
         """
-        assert not name in self.choices_dict
+        assert name not in self.choices_dict
         allowed_names = ("yes", "no", "ok", "cancel")
-        if not name in allowed_names:
+        if name not in allowed_names:
             raise Exception("Sorry, name must be one of %s" % allowed_names)
         cbc = CallbackChoice(name, func, label)
         self.choices.append(cbc)

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/core/fields.py

@@ -1492,7 +1492,6 @@ class TableRow(object):
 
     def save_existing_instance(self, ar):
         watcher = ChangeWatcher(self)
-        # print("20210213 save_existing_instance", ar.ah, ar.rqdata, self.disabled_fields)
         ar.ah.store.form2obj(ar, ar.rqdata, self, False)
         self.full_clean()
         pre_ui_save.send(sender=self.__class__, instance=self, ar=ar)

lino/core/kernel.py

@@ -230,25 +230,15 @@ class Kernel(object):
 
             Model.django2lino(model)
 
-            if isinstance(model.hidden_columns, str):
-                model.hidden_columns = frozenset(
-                    atomizer.fields_list(model, model.hidden_columns)
-                )
-
-            if isinstance(model.active_fields, str):
-                model.active_fields = frozenset(
-                    atomizer.fields_list(model, model.active_fields)
-                )
-
-            if isinstance(model.allow_cascaded_delete, str):
-                model.allow_cascaded_delete = frozenset(
-                    atomizer.fields_list(model, model.allow_cascaded_delete)
-                )
-
-            if isinstance(model.allow_cascaded_copy, str):
-                model.allow_cascaded_copy = frozenset(
-                    atomizer.fields_list(model, model.allow_cascaded_copy)
-                )
+            if model.allow_cascaded_copy is None:
+                model.allow_cascaded_copy = model.allow_cascaded_delete
+
+            # 'suppress_cascaded_copy'
+            for k in ('hidden_columns', 'active_fields',
+                      'allow_cascaded_delete', 'allow_cascaded_copy'):
+                # resolve_fields_list(model, k, frozenset, frozenset())
+                if (v := getattr(model, k, None)) is not None:
+                    setattr(model, k, atomizer.fields_list(model, v))
 
             # Note how to inherit this from from parent model.
             if model.quick_search_fields is None:

lino/core/model.py

@@ -47,8 +47,9 @@ class Model(models.Model, fields.TableRow):
     class Meta(object):
         abstract = True
 
-    allow_cascaded_copy = frozenset()
     allow_cascaded_delete = frozenset()
+    allow_cascaded_copy = None
+    # suppress_cascaded_copy = frozenset()
     grid_post = actions.CreateRow()
     submit_insert = actions.SubmitInsert()
     allow_merge_action = False
@@ -479,14 +480,20 @@ class Model(models.Model, fields.TableRow):
         elem.after_ui_save(ar, None)
 
     def save_watched_instance(elem, ar, watcher):
+        # raise Exception("20250726")
         if watcher.is_dirty():
             # pre_ui_save.send(sender=elem.__class__, instance=elem, ar=ar)
             # elem.before_ui_save(ar, watcher)
             elem.save(force_update=True)
             watcher.send_update(ar)
             ar.success(_("%s has been updated.") % obj2unicode(elem))
-        else:
-            ar.success(_("%s : nothing to save.") % obj2unicode(elem))
+        # else:
+        #     ar.success(_("%s : nothing to save.") % obj2unicode(elem))
+        # 20250726 The "nothing to save" message is confusing e.g. in
+        # ratings.ResponsesByExam when setting score1 or score2. These virtual
+        # fields store the value in their respective ChallengeRating object but
+        # the examResponse remains unchanged.
+
         elem.after_ui_save(ar, watcher)
 
     def delete_instance(self, ar):
@@ -948,6 +955,7 @@ LINO_MODEL_ATTRIBS = (
     "before_ui_save",
     "allow_cascaded_delete",
     "allow_cascaded_copy",
+    # "suppress_cascaded_copy",
     "workflow_state_field",
     "workflow_owner_field",
     "disabled_fields",

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/core/store.py

@@ -203,7 +203,6 @@ class StoreField(object):
 
     def set_value_in_object(self, ar, instance, v):
         # logger.info("20180712 super set_value_in_object() %s", v)
-
         old_value = self.value_from_object(instance, ar.request)
         # old_value = getattr(instance,self.field.attname)
         if old_value != v:
@@ -865,8 +864,8 @@ class FileFieldStoreField(StoreField):
 
 
 class MethodStoreField(StoreField):
-    """Deprecated. See `/blog/2012/0327`.
-    Still used for DISPLAY_MODE_HTML.
+    """
+    Still used for DISPLAY_MODE_HTML and writable virtual fields.
     """
 
     def full_value_from_object(self, obj, ar=None):
@@ -898,6 +897,7 @@ class MethodStoreField(StoreField):
     # pass
 
     def form2obj(self, request, instance, post_data, is_new):
+        # print("20250726", self, post_data)
         pass
         # return instance
         # raise Exception("Cannot update a virtual field")

lino/core/utils.py

@@ -810,29 +810,30 @@ def error2str(self, e):
 
 
 def resolve_fields_list(model, k, collection_type=tuple, default=None):
-    qsf = getattr(model, k)
-    if qsf is None:
+    value = getattr(model, k)
+    if value is None:
         setattr(model, k, default)
-    elif qsf == default:
-        pass
-    elif isinstance(qsf, collection_type):
-        pass
-    elif isinstance(qsf, str):
+        return
+    elif value == default:
+        return
+    elif isinstance(value, collection_type):
+        return
+    if isinstance(value, str):
+        value = value.split()
+    if isinstance(value, (list, tuple)):
         lst = []
-        for n in qsf.split():
+        for n in value:
             f = model.get_data_elem(n)
             if f is None:
-                msg = "Invalid field {} in {} of {}"
-                msg = msg.format(n, k, model)
+                msg = f"Invalid field {n} in {k} of {model}"
                 raise Exception(msg)
             lst.append(f)
         setattr(model, k, collection_type(lst))
         # fields.fields_list(model, model.quick_search_fields))
     else:
         raise ChangedAPI(
-            "{0}.{1} must be None or a string "
-            "of space-separated field names (not {2})".format(model, k, qsf)
-        )
+            f"{model}.{k} must be None or a string "
+            f"of space-separated field names (not {value})")
 
 
 def class_dict_items(cl, exclude=None):

lino/help_texts.py

@@ -17,6 +17,8 @@ help_texts = {
     'lino.mixins.ProjectRelated' : _("""Mixin for models that are related to a “project”, i.e. to an object of the type given by your lino.core.site.Site.project_model."""),
     'lino.mixins.ProjectRelated.project' : _("""Pointer to the project to which this object is related."""),
     'lino.mixins.ProjectRelated.update_owned_instance' : _("""When a project-related object controls another project-related object, then the controlled automatically inherits the project of its controller."""),
+    'lino.mixins.clonable.CloneRow' : _("""See /dev/duplicate."""),
+    'lino.mixins.clonable.Clonable' : _("""See /dev/duplicate."""),
     'lino.mixins.dupable.CheckedSubmitInsert' : _("""Like the standard lino.core.actions.SubmitInsert, but adds a confirmation if there is a possible duplicate record."""),
     'lino.mixins.dupable.PhoneticWordBase' : _("""Base class for the table of phonetic words of a given dupable model. For every (non-abstract) dupable model there must be a subclass of PhoneticWordBase. The subclass must define a field owner which points to the Dupable, and the Dupable’s dupable_word_model must point to its subclass of PhoneticWordBase."""),
     'lino.mixins.dupable.Dupable' : _("""Base class for models that can be “dupable”."""),
@@ -30,9 +32,6 @@ help_texts = {
     'lino.mixins.dupable.DupableChecker' : _("""Checks for the following repairable problem:"""),
     'lino.mixins.dupable.DupableChecker.model' : _("""alias of Dupable"""),
     'lino.mixins.dupable.SimilarObjects' : _("""Shows the other objects that are similar to this one."""),
-    'lino.mixins.duplicable.Duplicate' : _("""Duplicate the selected row."""),
-    'lino.mixins.duplicable.Duplicate.run_from_ui' : _("""This actually runs the action."""),
-    'lino.mixins.duplicable.Duplicable' : _("""Adds a row action “Duplicate”, which duplicates (creates a clone of) the object it was called on."""),
     'lino.mixins.human.Human' : _("""Base class for models that represent a human."""),
     'lino.mixins.human.Human.title' : _("""Used to specify a professional position or academic qualification like “Dr.” or “PhD”."""),
     'lino.mixins.human.Human.first_name' : _("""The first name, also known as given name."""),
@@ -87,10 +86,9 @@ help_texts = {
     'lino.mixins.sequenced.MoveByN' : _("""Move this row N rows upwards or downwards."""),
     'lino.mixins.sequenced.MoveUp' : _("""Move this row one row upwards."""),
     'lino.mixins.sequenced.MoveDown' : _("""Move this row one row downwards."""),
-    'lino.mixins.sequenced.DuplicateSequenced' : _("""Duplicate this row."""),
     'lino.mixins.sequenced.Sequenced' : _("""Mixin for models that have a field seqno containing a “sequence number”."""),
     'lino.mixins.sequenced.Sequenced.seqno' : _("""The sequence number of this item with its parent."""),
-    'lino.mixins.sequenced.Sequenced.duplicate' : _("""Create a duplicate of this object and insert the new object below this one."""),
+    'lino.mixins.sequenced.Sequenced.clone_row' : _("""Create a duplicate of this row and insert the new row below this one."""),
     'lino.mixins.sequenced.Sequenced.move_up' : _("""Exchange the seqno of this item and the previous item."""),
     'lino.mixins.sequenced.Sequenced.move_down' : _("""Exchange the seqno of this item and the next item."""),
     'lino.mixins.sequenced.Sequenced.move_buttons' : _("""Displays buttons for certain actions on this row:"""),
@@ -234,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."""),
@@ -311,7 +309,6 @@ help_texts = {
     'lino.core.model.Model.submit_insert' : _("""The SubmitInsert action to be executed when the when the users submits an insert window."""),
     'lino.core.model.Model.create_from_choice' : _("""Called when a learning combo has been submitted. Create a persistent database object if the given text contains enough information."""),
     'lino.core.model.Model.choice_text_to_dict' : _("""Return a dict of the fields to fill when the given text contains enough information for creating a new database object."""),
-    'lino.core.model.Model.allow_cascaded_delete' : _("""A set of names of ForeignKey or GenericForeignKey fields of this model that allow for cascaded delete."""),
     'lino.core.model.Model.__str__' : _("""Return a translatable text that describes this database row."""),
     'lino.core.model.Model.as_str' : _("""Return a translatable text that describes this database row. Unlike __str__() this method gets an action request when it is called, so it knows the context."""),
     'lino.core.model.Model.get_str_words' : _("""Yield a series of words that describe this database row in plain text."""),
@@ -717,4 +714,9 @@ help_texts = {
     'lino.core.model.Model.get_choices_text' : _("""Return the text to be displayed when an instance of this model is being used as a choice in a combobox of a ForeignKey field pointing to this model. request is the web request, actor is the requesting actor."""),
     'lino.core.model.Model.disable_delete' : _("""Decide whether this database object may be deleted. Return None when there is no veto against deleting this database row, otherwise a translatable message that explains to the user why they can’t delete this row."""),
     'lino.core.model.Model.update_field' : _("""Shortcut to call lino.core.inject.update_field() for usage during lino.core.site.Site.do_site_startup() in a settings.py or similar place."""),
+    'lino.core.model.Model.on_duplicate' : _("""Called after duplicating a row."""),
+    'lino.core.model.Model.after_duplicate' : _("""Called by lino.mixins.clonable.Duplicate on the new copied row instance, after the row and its related fields have been saved."""),
+    'lino.core.model.Model.delete_veto_message' : _("""Return the message Cannot delete X because N Ys refer to it."""),
+    'lino.core.model.Model.allow_cascaded_delete' : _("""A set of foreign key fields that link this model to a master in a “possessive” way, i.e. objects of this model should get deleted together with their master."""),
+    'lino.core.model.Model.allow_cascaded_copy' : _("""A set of foreign key fields that that cause database rows to be automatically cloned when their master gets cloned."""),
 }

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/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/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/mixins/__init__.py

@@ -8,8 +8,9 @@ by applications and the :ref:`xl`. But none of them is mandatory.
 .. autosummary::
    :toctree:
 
-    duplicable
+
     dupable
+    clonable
     sequenced
     human
     periods
@@ -50,7 +51,7 @@ from .polymorphic import Polymorphic
 from .periods import ObservedDateRange, Yearly, Monthly, Today
 from .periods import DateRange
 from .sequenced import Sequenced, Hierarchical
-from .duplicable import Duplicable, Duplicate
+from .clonable import Clonable, CloneRow
 from .registrable import Registrable, RegistrableState
 from .ref import Referrable, StructuredReferrable