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

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

@@ -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)

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

@@ -16,7 +16,7 @@ from lino.modlib.checkdata.choicelists import Checker
 
 from lino.utils.choosers import chooser
 from lino.core.model import Model
-from lino.mixins.duplicable import Duplicable
+from lino.mixins.clonable import Clonable
 
 from .choicelists import BuildMethods
 from .actions import (
@@ -148,7 +148,7 @@ class Printable(Model):
         return True
 
 
-class CachedPrintable(Duplicable, Printable):
+class CachedPrintable(Clonable, Printable):
     class Meta(object):
         abstract = True
 

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

@@ -38,7 +38,8 @@ class UpdateSummariesByMaster(ComputeResults):
 
 
 class Summarized(dd.Model):
-    class Meta(object):
+
+    class Meta:
         abstract = True
 
     compute_results = ComputeResults()
@@ -86,15 +87,17 @@ class Summarized(dd.Model):
 
     def get_summary_collectors(self):
         raise NotImplementedError(
-            "{} must define get_summary_collectors()".format(self.__class__)
+            f"{self.__class__} must define get_summary_collectors()"
         )
 
 
 class SlaveSummarized(Summarized):
-    class Meta(object):
+
+    class Meta:
         abstract = True
 
     allow_cascaded_delete = "master"
+    allow_cascaded_copy = set()
 
     @classmethod
     def check_all_summaries(cls):
@@ -181,7 +184,6 @@ class DateSummarized(Summarized):
                 flt.update(month=period)
             if year is not None:
                 flt.update(year=year)
-            # obj = cls.get_for_period(**flt)
             for obj in cls.get_for_filter(**flt):
                 obj.compute_summary_values()
 

lino/modlib/users/actions.py

@@ -495,6 +495,11 @@ def get_social_auth_links_func(content_header, flex_row, ar=None):
             else:
                 el = E.span(anchor, style=style)
             links.append(el)
+        anchor = E.a(E.span(gettext("Smart ID")), href="/auth/smart_id")
+        if flex_row:
+            links.append(E.div(anchor, style=style))
+        else:
+            links.append(E.span(anchor, style=style))
         elems.append(E.div(*links, style="text-align: center;"))
         return tostring(E.div(*elems))
 

lino/sphinxcontrib/__init__.py

@@ -102,7 +102,7 @@ def configure(globals_dict, django_settings_module=None):
     rstgen.sphinxconf.configure()
 
     You can specify an additional positional argument `django_settings_module`
-    (the name of a Django settings module).  If this argument is specified, call
+    (the name of a Django settings file).  If this argument is specified, call
     :meth:`lino.startup` with it.
 
     """

lino/sphinxcontrib/actordoc.py

@@ -11,7 +11,7 @@ for a Lino application.
   source code.  This is like :rst:dir:`py2rst` but with the following
   names defined:
 
-  :settings: The Django settings module which is active while building
+  :settings: The Django settings file which is active while building
              the docs.
 
   :dd: The :mod:`lino.api.dd` module.

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/utils/diag.py

@@ -341,9 +341,9 @@ class Analyzer(object):
             return "{0}.{1}".format(fmn(mfk[0]), mfk[1].name)
 
         items1 = []
-        for target, dp in list(tdp.items()):
+        for target, dp in tdp.items():
             items2 = []
-            for dh, pl in list(dp.items()):
+            for dh, pl in dp.items():
                 items2.append(
                     "{0} : {1}".format(
                         dh.__name__, ", ".join([fk2str(mfk) for mfk in pl])