lino 25.7.2__tar.gz → 25.7.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lino
-Version: 25.7.2
+Version: 25.7.3
 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.2 → lino-25.7.3}/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.7.3'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

{lino-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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:

{lino-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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-25.7.2 → lino-25.7.3}/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:"""),
@@ -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-25.7.2 → lino-25.7.3}/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
 

lino-25.7.2/lino/mixins/duplicable.py → lino-25.7.3/lino/mixins/clonable.py

@@ -1,13 +1,10 @@
 # -*- coding: UTF-8 -*-
 # Copyright 2012-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
-"""Defines the model mixin :class:`Duplicable`.  "duplicable"
-[du'plikəblə] means "able to produce a duplicate
-['duplikət], ['du:plikeit]".
-
-"""
+"See :doc:`/dev/duplicate`."
 
 from django.utils.translation import gettext_lazy as _
+from django.utils.text import format_lazy
 
 from lino import logger
 from lino.core import actions
@@ -16,16 +13,12 @@ from lino.core.diff import ChangeWatcher
 # from lino.core.roles import Expert
 
 
-class Duplicate(actions.Action):
-    """Duplicate the selected row.
-
-    This will call :meth:`lino.core.model.Model.on_duplicate` on the
-    new object and on related objects.
+class CloneRow(actions.Action):
+    "See :doc:`/dev/duplicate`."
 
-    """
-
-    label = "\u2687"  # ⚇ "white circle with two dots"
-    # label = _("Duplicate")
+    # button_text = "⚇"  # \u2687 "white circle with two dots"
+    button_text = "🗗"  # OVERLAP (U+1F5D7)
+    label = _("Duplicate")
     # icon_name = 'arrow_divide'
     sort_index = 11
     show_in_workflow = False
@@ -34,6 +27,11 @@ class Duplicate(actions.Action):
 
     # required_roles = set([Expert])
 
+    def get_help_text(self, ba):
+        return format_lazy(
+            _("Insert a new {} as a copy of this."),
+            ba.actor.model._meta.verbose_name)
+
     def get_action_view_permission(self, actor, user_type):
         # the action is readonly because it doesn't write to the
         # current object, but since it does modify the database we
@@ -48,30 +46,9 @@ class Duplicate(actions.Action):
         return super().get_action_view_permission(actor, user_type)
 
     def run_from_code(self, ar, **known_values):
+        # CloneSequenced uses known_values to set seqno to seqno + 1
         obj = ar.selected_rows[0]
-        related = []
-        for m, fk in obj._lino_ddh.fklist:
-            # print(fk.name, m.allow_cascaded_delete, m.allow_cascaded_copy, obj)
-            if fk.name in m.allow_cascaded_delete or fk.name in m.allow_cascaded_copy:
-                related.append((fk, m.objects.filter(**{fk.name: obj})))
-
-        fields_list = obj._meta.concrete_fields
-        if True:
-            for f in fields_list:
-                if not f.primary_key:
-                    if f.name not in known_values:
-                        known_values[f.name] = getattr(obj, f.name)
-            new = obj.__class__(**known_values)
-            # 20120704 create_instances causes fill_from_person() on a
-            # CBSS request.
-        else:
-            # doesn't seem to want to work
-            new = obj
-            for f in fields_list:
-                if f.primary_key:
-                    # causes Django to consider this an unsaved instance
-                    setattr(new, f.name, None)
-
+        new, related = obj.duplication_plan(**known_values)
         new.on_duplicate(ar, None)
         new.full_clean()
         new.save(force_insert=True)
@@ -94,11 +71,9 @@ class Duplicate(actions.Action):
 
         logger.info("%s has been duplicated to %s (%d related rows)",
                     obj, new, relcount)
-
         return new
 
     def run_from_ui(self, ar, **kw):
-        """This actually runs the action."""
 
         if (msg := ar.actor.model.disable_create(ar)) is not None:
             ar.error(msg)
@@ -126,18 +101,38 @@ class Duplicate(actions.Action):
         )
 
 
-class Duplicable(model.Model):
-    """Adds a row action "Duplicate", which duplicates (creates a clone
-    of) the object it was called on.
+class Clonable(model.Model):
+    "See :doc:`/dev/duplicate`."
 
-    Subclasses may override :meth:`lino.core.model.Model.on_duplicate`
-    to customize the default behaviour, which is to copy all fields
-    except the primary key and all related objects that are
-    duplicable.
+    class Meta:
+        abstract = True
 
-    """
+    clone_row = CloneRow()
 
-    class Meta(object):
-        abstract = True
+    def duplication_plan(obj, **known_values):
+        related = []
+        for m, fk in obj._lino_ddh.fklist:
+            # if fk.name in m.suppress_cascaded_copy:
+            #     continue
+            # print(fk.name, m.allow_cascaded_delete, m.allow_cascaded_copy, obj)
+            # if fk.name in m.allow_cascaded_delete or fk.name in m.allow_cascaded_copy:
+            if fk.name in m.allow_cascaded_copy:
+                related.append((fk, m.objects.filter(**{fk.name: obj})))
 
-    duplicate = Duplicate()
+        fields_list = obj._meta.concrete_fields
+        if True:
+            for f in fields_list:
+                if not f.primary_key:
+                    if f.name not in known_values:
+                        known_values[f.name] = getattr(obj, f.name)
+            new = obj.__class__(**known_values)
+            # 20120704 create_instances causes fill_from_person() on a
+            # CBSS request.
+        else:
+            # doesn't seem to want to work
+            new = obj
+            for f in fields_list:
+                if f.primary_key:
+                    # causes Django to consider this an unsaved instance
+                    setattr(new, f.name, None)
+        return new, related

{lino-25.7.2 → lino-25.7.3}/lino/mixins/dupable.py

@@ -5,8 +5,8 @@
 Defines the :class:`Dupable` model mixin and related functionality
 to assist users in finding unwanted duplicate database records.
 
-Don't mix up this module with :mod:`lino.mixins.duplicable`.  Models
-are "duplicable" if users may *want* to duplicate some instance
+Don't mix up this module with :mod:`lino.mixins.`.  Models
+are "" if users may *want* to duplicate some instance
 thereof, while "dupable" implies that the duplicates are *unwanted*.
 To dupe *somebody* means "to make a dupe of; deceive; delude; trick."
 (`reference.com <https://dictionary.reference.com/browse/dupe>`_), and

{lino-25.7.2 → lino-25.7.3}/lino/mixins/registrable.py

@@ -143,7 +143,7 @@ class Registrable(model.Model):
             # if not ar.bound_action.action.readonly:
             if not ba.action.readonly:
                 return False
-        return super(Registrable, self).get_row_permission(ar, state, ba)
+        return super().get_row_permission(ar, state, ba)
 
     def register(self, ar):
         """
@@ -193,7 +193,7 @@ class Registrable(model.Model):
 
     @classmethod
     def get_simple_parameters(cls):
-        for p in super(Registrable, cls).get_simple_parameters():
+        for p in super().get_simple_parameters():
             yield p
         # if isinstance(cls.workflow_state_field, str):
         #     raise Exception("Unresolved workflow state field in {}".format(cls))
@@ -203,4 +203,4 @@ class Registrable(model.Model):
 
     def on_duplicate(self, ar, master):
         self.state = self.workflow_state_field.choicelist.draft
-        super(Registrable, self).on_duplicate(ar, master)
+        super().on_duplicate(ar, master)