lino 25.7.1__py3-none-any.whl → 25.7.3__py3-none-any.whl

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",
@@ -994,6 +1002,7 @@ LINO_MODEL_ATTRIBS = (
     "_lino_tables",
     "show_in_site_search",
     "allow_merge_action",
+    "get_overview_elems",
 )
 
 

lino/core/plugin.py

@@ -65,7 +65,7 @@ class Plugin:
                 raise Exception("%s has no attribute %s" % (self, k))
             setattr(self, k, v)
 
-    def get_required_plugins(self):
+    def get_needed_plugins(self):
         return self.needs_plugins
 
     def get_used_libs(self, html=None):

lino/core/renderer.py

@@ -498,7 +498,7 @@ class HtmlRenderer(Renderer):
         return E.p(*buttons)
 
     def get_home_url(self, *args, **kw):
-        return settings.SITE.kernel.web_front_ends[0].build_plain_url(*args, **kw)
+        return settings.SITE.kernel.editing_front_end.build_plain_url(*args, **kw)
 
     def obj2url(self, ar, obj):
         ba = obj.get_detail_action(ar)

lino/core/requests.py

@@ -1842,10 +1842,9 @@ class ActionRequest(BaseRequest):
             pv = self.actor.param_defaults(self)
             for k in pv.keys():
                 if k not in self.actor.parameters:
-                    raise Exception(
-                        "%s.param_defaults() returned invalid keyword %r"
-                        % (self.actor, k)
-                    )
+                    msg = f"{self.actor} param_defaults() returned keyword {k}"
+                    msg += f" (must be one of {sorted(self.actor.parameters.keys())})"
+                    raise Exception(msg)
 
             # New since 20120913.  E.g. newcomers.Newcomers is a
             # simple pcsw.Clients with

lino/core/site.py

@@ -862,7 +862,7 @@ class Site(object):
             needed_by = ip
             # while needed_by.needed_by is not None:
             #     needed_by = needed_by.needed_by
-            for dep in ip.get_required_plugins():
+            for dep in ip.get_needed_plugins():
                 k2 = dep.rsplit(".")[-1]
                 if k2 not in self.plugins:
                     install_plugin(dep, needed_by=needed_by)

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

@@ -664,10 +664,11 @@ class Parametrizable:
     parameters = None
     params_layout = None
     params_panel_hidden = True
-    params_panel_pos = "top"  # allowed values "top", "bottom", "left" and "right"
+    params_panel_pos = "bottom"  # allowed values "top", "bottom", "left" and "right"
     use_detail_param_panel = False
 
     _params_layout_class = NotImplementedError
+    _field_actions = dict()
 
     def get_window_layout(self, actor):
         return self.params_layout
@@ -809,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):
@@ -1238,11 +1240,12 @@ def register_params(cls):
             cls.params_layout = cls._params_layout_class.join_str.join(
                 cls.parameters.keys()
             )
+    if cls.params_layout is not None:
         install_layout(cls, "params_layout", cls._params_layout_class)
 
-    # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
-    elif cls.params_layout is not None:
-        raise Exception("{} has a params_layout but no parameters".format(cls))
+    # # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
+    # elif cls.params_layout is not None:
+    #     raise Exception("{} has a params_layout but no parameters".format(cls))
 
     # if isinstance(cls, type) and cls.__name__.endswith("Users"):
     # # if isinstance(cls, type) and cls.model is not None and cls.model.__name__ == "User":

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,8 +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.disabled_fields' : _("""Return a set of field names that should be disabled (i.e. not editable) for this database object."""),
     '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."""),
@@ -705,15 +701,22 @@ help_texts = {
     'lino.modlib.weasyprint.WeasyHtmlBuildMethod' : _("""Renders the input template and returns the unmodified output as plain HTML."""),
     'lino.modlib.weasyprint.WeasyPdfBuildMethod' : _("""Like WeasyBuildMethod, but the rendered HTML is then passed through weasyprint which converts from HTML to PDF."""),
     'lino.core.model.Model' : _("""Lino extension of Django’s database model. This is a subclass of Django’s Model class (django.db.models.Model)."""),
+    'lino.core.model.Model.__init__' : _("""The first positional argument is the optional label, other arguments should be specified as keywords and can be any of the existing class attributes."""),
     'lino.core.model.Model.overview' : _("""A multi-paragraph representation of this database row."""),
     'lino.core.model.Model.navigation_panel' : _("""A virtual field that displays the navigation panel for this row. This may be included in a detail layout, usually either on the left or the right side with full height."""),
     'lino.core.model.Model.workflow_buttons' : _("""Shows the current workflow state of this database row and a list of available workflow actions."""),
     'lino.core.model.Model.workflow_state_field' : _("""Optional default value for the workflow_state_field of all data tables based on this model."""),
     'lino.core.model.Model.workflow_owner_field' : _("""Optional default value for workflow_owner_field on all data tables based on this model."""),
+    'lino.core.model.Model.disabled_fields' : _("""Return a set of field names that should be disabled (i.e. not editable) for this database object."""),
     'lino.core.model.Model.FOO_changed' : _("""Called when field FOO of an instance of this model has been modified through the user interface."""),
     'lino.core.model.Model.FOO_choices' : _("""Return a queryset or list of allowed choices for field FOO."""),
     'lino.core.model.Model.create_FOO_choice' : _("""For every field named “FOO” for which a chooser exists, if the model also has a method called “create_FOO_choice”, then this chooser will be a learning chooser. That is, users can enter text into the combobox, and Lino will create a new database object from it."""),
     '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/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/mixins/{duplicable.py → 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/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/mixins/registrable.py

@@ -118,12 +118,14 @@ class Registrable(model.Model):
         # yield 'date'
 
     def disabled_fields(self, ar):
+        rv = super().disabled_fields(ar)
         if not self.state.is_editable:
             # return self._registrable_fields
             # Copy _registrable_fields otherwise _registrable_fields get
             # modified as more disabled fields are added to the set.
-            return self._registrable_fields.copy()
-        return super().disabled_fields(ar)
+            # return self._registrable_fields.copy()
+            rv |= self._registrable_fields
+        return rv
 
     def get_row_permission(self, ar, state, ba):
         """Only rows in an editable state may be edited.
@@ -141,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):
         """
@@ -191,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))
@@ -201,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)

lino/mixins/sequenced.py

@@ -24,7 +24,7 @@ from lino.utils.html import E
 from lino.utils import AttrDict
 from lino.utils import join_elems
 
-from .duplicable import Duplicable, Duplicate
+from lino.mixins.clonable import Clonable, CloneRow
 
 
 class MoveByN(actions.Action):
@@ -167,8 +167,7 @@ class MoveDown(actions.Action):
         ar.success(**kw)
 
 
-class DuplicateSequenced(Duplicate):
-    """Duplicate this row."""
+class CloneSequenced(CloneRow):
 
     def run_from_code(self, ar, **kw):
         obj = ar.selected_rows[0]
@@ -184,7 +183,7 @@ class DuplicateSequenced(Duplicate):
         return super().run_from_code(ar, **kw)
 
 
-class Sequenced(Duplicable):
+class Sequenced(Clonable):
     """Mixin for models that have a field :attr:`seqno` containing a
     "sequence number".
 
@@ -192,12 +191,11 @@ class Sequenced(Duplicable):
 
         The sequence number of this item with its parent.
 
-    .. method:: duplicate
+    .. method:: clone_row
 
-        Create a duplicate of this object and insert the new object
-        below this one.
+        Create a duplicate of this row and insert the new row below this one.
 
-        Implemented by :class:`DuplicateSequenced`
+        Implemented by :class:`CloneSequenced`
 
     .. attribute:: move_up
 
@@ -212,28 +210,28 @@ class Sequenced(Duplicable):
         Displays buttons for certain actions on this row:
 
         - :attr:`move_up` and :attr:`move_down`
-        - duplicate
+        - clone_row
 
     .. attribute:: move_by_n
 
     """
 
-    move_action_names = ("move_up", "move_down", "duplicate")
+    move_action_names = ("move_up", "move_down", "clone_row")
     """The names of the actions to display in the `move_buttons`
     column.
 
     Overridden by :class:`lino.modlib.dashboard.Widget` where the
-    duplicate button would be irritating.
+    clone_row button would be irritating.
 
     """
 
-    class Meta(object):
+    class Meta:
         abstract = True
         ordering = ["seqno"]
 
     seqno = models.IntegerField(_("No."), blank=True, null=False)
 
-    duplicate = DuplicateSequenced()
+    clone_row = CloneSequenced()
 
     move_up = MoveUp()
     move_down = MoveDown()
@@ -352,7 +350,7 @@ Sequenced.set_widget_options("move_buttons", width=5)
 Sequenced.set_widget_options("seqno", hide_sum=True)
 
 
-class Hierarchical(Duplicable):
+class Hierarchical(Clonable):
     """Model mixin for things that have a "parent" and "siblings".
 
     Pronounciation: [hai'ra:kikl]

lino/modlib/dupable/models.py

@@ -4,8 +4,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/modlib/extjs/views.py

@@ -463,6 +463,13 @@ class ApiElement(View):
                 else:
                     datarec = ar.elem2rec_detailed(elem)
                 datarec.update(**vm)
+
+                fa = dict()
+                for k, lst in rpt._field_actions.items():
+                    fa[k] = [ar.row_action_button(elem, ba) for ba in lst]
+                if fa:
+                    datarec.update(field_actions=fa)
+
                 return json_response(datarec)
 
             after_show = ar.get_status(record_id=pk)

lino/modlib/linod/__init__.py

@@ -50,7 +50,7 @@ class Plugin(ad.Plugin):
         m = m.add_menu(mg.app_label, mg.verbose_name)
         m.add_action("linod.Procedures")
 
-    def get_required_plugins(self):
+    def get_needed_plugins(self):
         # We don't use needs_plugins because it depends on use_channels. We must
         # not install the plugin when the Python package isn't installed because
         # otherwise `pm install` fails with ModuleNotFoundError: No module named

lino/modlib/memo/__init__.py

@@ -50,7 +50,7 @@ class Plugin(ad.Plugin):
     """The front end to use when writing previews.
 
     If this is `None`, Lino will use the default :term:`front end`
-    (:attr:`lino.core.site.Site.web_front_ends`).
+    (:attr:`lino.core.site.Site.editing_front_end`).
 
     Used on sites that are available through more than one web front ends.  The
     :term:`server administrator` must then decide which front end is the primary
@@ -115,7 +115,6 @@ class Plugin(ad.Plugin):
     def post_site_startup(self, site):
         if self.front_end is None:
             self.front_end = site.kernel.editing_front_end
-            # web_front_ends[0]
         else:
             self.front_end = site.plugins.resolve(self.front_end)
 

lino/modlib/notify/api.py

@@ -8,6 +8,7 @@ from django.conf import settings
 from django.utils.timezone import now
 from lino.api import rt, dd
 from lino.modlib.linod.utils import CHANNEL_NAME, BROADCAST_CHANNEL, get_channel_name
+from lino_xl.lib.matrix.utils import send_notification_to_matrix_room, send_notification_direct
 
 NOTIFICATION = "NOTIFICATION"
 CHAT = "CHAT"
@@ -67,6 +68,10 @@ def send_notification(
     if user is None or settings.SITE.loading_from_dump:
         return
 
+    if dd.is_installed("matrix") and dd.plugins.matrix.credentials_file is not None:
+        # send_notification_to_matrix_room(f"{subject}\n\n{body}")
+        send_notification_direct(f"{subject}\n\n{body}", user)
+
     if dd.get_plugin_setting("linod", "use_channels"):
         # importing channels at module level would cause certain things to fail
         # when channels isn't installed, e.g. `manage.py prep` in `lino_book.projects.workflows`.

lino/modlib/office/roles.py

@@ -1,7 +1,6 @@
 # Copyright 2015-2023 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from lino.core.roles import UserRole
 from lino.modlib.uploads.roles import UploadsReader