lino 24.11.0__py3-none-any.whl → 25.1.0__py3-none-any.whl

lino/modlib/memo/mixins.py

@@ -2,8 +2,6 @@
 # Copyright 2016-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from bs4 import BeautifulSoup, NavigableString
-from bs4.element import Tag
 from lxml.html import fragments_fromstring
 from lino.utils.html import E, tostring, mark_safe
 import lxml
@@ -22,212 +20,24 @@ from lino.core.gfks import gfk2lookup
 from lino.core.model import Model
 from lino.core.fields import fields_list, RichTextField, PreviewTextField
 from lino.utils.restify import restify
+from lino.utils.soup import truncate_comment
 from lino.utils.mldbc.fields import BabelTextField
 from lino.core.exceptions import ChangedAPI
 from lino.modlib.checkdata.choicelists import Checker
 from lino.api import rt, dd, _
 
 
-def old_truncate_comment(html_str, max_p_len=None):
-    # returns a single paragraph with a maximum number of visible chars.
-    # No longer used. Replaced by new truncate_comment() below
-    if max_p_len is None:
-        max_p_len = settings.SITE.plugins.memo.short_preview_length
-    html_str = html_str.strip()  # remove leading or trailing newlines
-
-    if not html_str.startswith("<"):
-        if len(html_str) > max_p_len:
-            txt = html_str[:max_p_len] + "..."
-        else:
-            txt = html_str
-        return txt
-    soup = BeautifulSoup(html_str, "html.parser")
-    ps = soup.find_all(
-        ["p", "h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8", "h9", "pre"]
-    )
-    if len(ps) > 0:
-        anchor_end = "</a>"
-        txt = ""
-        for p in ps:
-            text = ""
-            for c in p.contents:
-                if isinstance(c, Tag):
-                    if c.name == "a":
-                        text += str(c)
-                        max_p_len = max_p_len + len(text) - len(c.text)
-                    else:
-                        # text += str(c)
-                        text += c.text
-                else:
-                    text += str(c)
-
-            if len(txt) + len(text) > max_p_len:
-                txt += text
-                if anchor_end in txt:
-                    ae_index = txt.index(anchor_end) + len(anchor_end)
-                    if ae_index >= max_p_len:
-                        txt = txt[:ae_index]
-                        txt += "..."
-                        break
-                txt = txt[:max_p_len]
-                txt += "..."
-                break
-            else:
-                txt += text + "\n\n"
-        return txt
-    return html_str
-
-
 def django_truncate_comment(html_str):
     # works, but we don't use it because (...)
     return Truncator(html_str).chars(
         settings.SITE.plugins.memo.short_preview_length, html=True
     )
 
-
-PARAGRAPH_TAGS = {
-    "p",
-    "h1",
-    "h2",
-    "h3",
-    "h4",
-    "h5",
-    "h6",
-    "h7",
-    "h8",
-    "h9",
-    "pre",
-    "li",
-    "div",
-}
-WHITESPACE_TAGS = PARAGRAPH_TAGS | {
-    "[document]",
-    "span",
-    "ul",
-    "html",
-    "head",
-    "body",
-    "base",
-}
-
-
 MARKDOWNCFG = dict(
     extensions=["toc"], extension_configs=dict(toc=dict(toc_depth=3, permalink=True))
 )
 
 
-class Style:
-    # TODO: Extend rstgen.sphinxconf.sigal_image.Format to incoroporate this.
-    def __init__(self, s):
-        self._map = {}
-        if s:
-            for i in s.split(";"):
-                k, v = i.split(":", maxsplit=1)
-                self._map[k.strip()] = v.strip()
-        self.is_dirty = False
-
-    def __contains__(self, *args):
-        return self._map.__contains__(*args)
-
-    def __setitem__(self, k, v):
-        if k in self._map and self._map[k] == v:
-            return
-        self._map[k] = v
-        self.is_dirty = True
-
-    def __delitem__(self, k):
-        if k in self._map:
-            self.is_dirty = True
-        return self._map.__delitem__(k)
-
-    def adjust_size(self):
-        # if self['float'] == "none":
-        #     return
-        if "width" in self._map:
-            del self["width"]
-        self["height"] = dd.plugins.memo.short_preview_image_height
-
-    def as_string(self):
-        return ";".join(["{}:{}".format(*kv) for kv in self._map.items()])
-
-
-class TextCollector:
-    def __init__(self, max_length=None):
-        self.text = ""
-        self.sep = ""  # becomes "\n\n" after a PARAGRAPH_TAGS
-        self.remaining = max_length or settings.SITE.plugins.memo.short_preview_length
-        self.image = None
-
-    def add_chunk(self, ch):
-        # print("20230712 add_chunk", ch.name, ch)
-
-        if ch.name in WHITESPACE_TAGS:
-            for c in ch.children:
-                if not self.add_chunk(c):
-                    return False
-            if ch.name in PARAGRAPH_TAGS:
-                self.sep = "\n\n"
-            else:
-                self.sep = " "
-            return True
-
-        assert ch.name != "IMG"
-
-        if ch.name == "img":
-            if self.image is not None:
-                # Ignore all images except the first one.
-                self.text += self.sep
-                return True
-            style = Style(ch.get("style", None))
-            if not "float" in style:
-                style["float"] = "right"
-            style.adjust_size()
-            if style.is_dirty:
-                ch["style"] = style.as_string()
-            self.image = ch
-            # print("20231023 a", ch)
-
-        we_want_more = True
-        if ch.string is not None:
-            if len(ch.string) > self.remaining:
-                # print("20231023", len(ch.string), '>', self.remaining)
-                ch.string = ch.string[: self.remaining] + "..."
-                we_want_more = False
-                # print("20230927", ch.string, ch)
-                # self.text += str(ch.string) + "..."
-                # return False
-            self.remaining -= len(ch.string)
-
-        if isinstance(ch, NavigableString):
-            self.text += self.sep + ch.string
-        else:
-            self.text += self.sep + str(ch)
-
-        self.remaining -= len(self.sep)
-        self.sep = ""
-        return we_want_more
-
-
-def truncate_comment(html_str, max_length=300):
-    # new implementation since 20230713
-    html_str = html_str.strip()  # remove leading or trailing newlines
-
-    if not html_str.startswith("<"):
-        # print("20231023 c", html_str)
-        if len(html_str) > max_length:
-            return html_str[:max_length] + "..."
-        return html_str
-
-    # if "choose one or the other" in html_str:
-    #     print(html_str)
-    #     raise Exception("20230928 {} {}".format(len(html_str), max_length))
-
-    soup = BeautifulSoup(html_str, "html.parser")
-    tc = TextCollector(max_length)
-    tc.add_chunk(soup)
-    return tc.text
-
-
 def rich_text_to_elems(ar, description):
     if description.startswith("<"):
         # desc = E.raw('<div>%s</div>' % self.description)
@@ -267,21 +77,16 @@ class MemoReferrable(dd.Model):
 
     memo_command = None
 
-    @classmethod
-    def on_analyze(cls, site):
-        super().on_analyze(site)
+    if dd.is_installed("memo"):
 
-        if cls.memo_command is None or not site.is_installed("memo"):
-            return
-
-        mp = site.plugins.memo.parser
-        mp.register_django_model(cls.memo_command, cls)
-        # mp.add_suggester("[" + cls.memo_command + " ", cls.objects.all(), 'pk')
-
-    # def get_memo_title(self):
-    #    """A text to be used as title of the ``<a href>``."""
-    #    return None
-    # return str(self)
+        @classmethod
+        def on_analyze(cls, site):
+            super().on_analyze(site)
+            if cls.memo_command is None:
+                return
+            mp = site.plugins.memo.parser
+            mp.register_django_model(cls.memo_command, cls)
+            # mp.add_suggester("[" + cls.memo_command + " ", cls.objects.all(), 'pk')
 
     def memo2html(self, ar, txt, **kwargs):
         if txt:
@@ -290,9 +95,6 @@ class MemoReferrable(dd.Model):
         return tostring(e)
         # return ar.obj2str(self, **kwargs)
 
-        # return "<p>Oops, undefined memo2html()</p>"
-
-    # def obj2memo(self, title=str):
     def obj2memo(self, text=None):
         """Render the given database object as memo markup."""
         if self.memo_command is None:
@@ -369,24 +171,24 @@ class BasePreviewable(dd.Model):
         )
         short = truncate_comment(full, self.get_preview_length())
         if not full.startswith("<"):
-            if markdown is not None:
+            if dd.get_plugin_setting("memo", "use_markup"):
                 full = markdown.markdown(full, **MARKDOWNCFG)
         return (short, full)
 
     def get_saved_mentions(self):
         Mention = rt.models.memo.Mention
         flt = gfk2lookup(Mention.owner, self)
-        return Mention.objects.filter(**flt).order_by("source_type", "source_id")
+        return Mention.objects.filter(**flt).order_by("target_type", "target_id")
 
     def synchronize_mentions(self, mentions):
         Mention = rt.models.memo.Mention
         for obj in self.get_saved_mentions():
-            if obj.source in mentions:
-                mentions.remove(obj.source)
+            if obj.target in mentions:
+                mentions.remove(obj.target)
             else:
                 obj.delete()
-        for source in mentions:
-            obj = Mention(owner=self, source=source)
+        for target in mentions:
+            obj = Mention(owner=self, target=target)
             # source_id=source.pk,
             # source_type=ContentType.objects.get_for_model(source.__class__))
             obj.full_clean()
@@ -472,7 +274,7 @@ class PreviewableChecker(Checker):
         ):
             yield (True, _("Preview differs from source."))
             is_broken = True
-        found_mentions = set([obj.source for obj in obj.get_saved_mentions()])
+        found_mentions = set([obj.target for obj in obj.get_saved_mentions()])
         if expected_mentions != found_mentions:
             yield (True, _("Mentions differ from expected mentions."))
             is_broken = True

lino/modlib/memo/models.py

@@ -9,6 +9,7 @@ from django.utils.text import format_lazy
 
 # from rstgen.sphinxconf.sigal_image import line2html
 from lino.api import dd, rt, _
+from lino.core import constants
 from lino.core.roles import SiteStaff
 from lino.core.gfks import gfk2lookup
 from lino.modlib.gfks.mixins import Controllable
@@ -17,7 +18,7 @@ from .parser import split_name_rest
 # from .mixins import *
 
 # Translators: will also be concatenated with '(type)' '(object)'
-source_label = _("Source")
+target_label = _("Target")
 
 
 class Mention(Controllable):
@@ -27,36 +28,64 @@ class Mention(Controllable):
         verbose_name = _("Mention")
         verbose_name_plural = _("Mentions")
 
-    source_type = dd.ForeignKey(
+    target_type = dd.ForeignKey(
         ContentType,
         editable=True,
         blank=True,
         null=True,
-        related_name="%(app_label)s_%(class)s_source_set",
-        verbose_name=format_lazy("{} {}", source_label, _("(type)")),
+        related_name="%(app_label)s_%(class)s_target_set",
+        verbose_name=format_lazy("{} {}", target_label, _("(type)")),
     )
 
-    source_id = GenericForeignKeyIdField(
-        source_type,
+    target_id = GenericForeignKeyIdField(
+        target_type,
         editable=True,
         blank=True,
         null=True,
-        verbose_name=format_lazy("{} {}", source_label, _("(object)")),
+        verbose_name=format_lazy("{} {}", target_label, _("(object)")),
     )
 
-    source = GenericForeignKey("source_type", "source_id", verbose_name=source_label)
+    target = GenericForeignKey("target_type", "target_id", verbose_name=target_label)
 
+    @classmethod
+    def get_simple_parameters(cls):
+        for p in super().get_simple_parameters():
+            yield p
+        yield "target_type"
+        yield "target_id"
+
+    def as_summary_item(self, ar, text=None, **kwargs):
+        # raise Exception("20240613")
+        if ar is None:
+            obj = super()
+        elif ar.is_obvious_field('target'):
+            obj = self.owner
+        elif ar.is_obvious_field('owner'):
+            obj = self.target
+        else:
+            obj = super()
+        return obj.as_summary_item(ar, text, **kwargs)
+
+dd.update_field(Mention, 'owner', verbose_name=_("Referrer"))
 
 class Mentions(dd.Table):
     required_roles = dd.login_required(SiteStaff)
     editable = False
     model = "memo.Mention"
-    column_names = "source owner *"
+    column_names = "owner target *"
     # detail_layout = """
     # id comment owner created
     # """
 
+# Not used because when you are on the owner, you can see the mentions in the memo text
+# class MentionsByOwner(Mentions):
+#     label = _("Mentions")
+#     master_key = "owner"
+#     column_names = "target *"
+#     default_display_modes = {None: constants.DISPLAY_MODE_SUMMARY}
 
-class MentionsByOwner(Mentions):
-    master_key = "owner"
-    column_names = "source *"
+class MentionsByTarget(Mentions):
+    label = _("Mentioned by")
+    master_key = "target"
+    column_names = "owner *"
+    default_display_modes = {None: constants.DISPLAY_MODE_SUMMARY}

lino/modlib/memo/parser.py

@@ -159,7 +159,7 @@ class Parser:
                 )
         self.commands[cmdname] = func
 
-    def register_django_model(self, name, model, cmd=None):
+    def register_django_model(self, name, model, cmd=None, rnd=None):
         """
         Register the given string `name` as command for referring to
         database rows of the given Django database model `model`.
@@ -172,6 +172,8 @@ class Parser:
         # if rnd is None:
         #     def rnd(obj):
         #         return "[{} {}] ({})".format(name, obj.id, title(obj))
+        if rnd is None:
+            rnd = model.memo2html
         if cmd is None:
 
             def cmd(ar, s, cmdname, mentions, context):
@@ -200,7 +202,8 @@ class Parser:
                 #     caption = obj.get_memo_title()
                 # txt = "#{0}".format(obj.id)
                 # kw.update(title=title(obj))
-                return obj.memo2html(ar, text)
+                # return obj.memo2html(ar, text)
+                return rnd(obj, ar, text)
                 # e = ar.obj2html(obj, txt, **kw)
                 # # return str(ar)
                 # return etree.tostring(e)
@@ -210,7 +213,8 @@ class Parser:
         #         pass
 
         cmd._for_model = model
-        cmd.__doc__ = """
+        if cmd.__doc__ is None:
+            cmd.__doc__ = rnd.__doc__ or """
 Insert a reference to the specified {}.
 
 The first argument is mandatory and specifies the primary key.

lino/modlib/notify/mixins.py

@@ -1,53 +1,54 @@
-# Copyright 2016-2022 Rumma & Ko Ltd
+# Copyright 2016-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from lino.utils.html import E, tostring
+from lino.utils.html import E, tostring, format_html, mark_safe
 from lino.api import dd, rt, _
 
 # PUBLIC_GROUP = "all_users_channel"
 
 
 class ChangeNotifier(dd.Model):
-    class Meta(object):
-        abstract = True
 
-    if dd.is_installed("notify"):
+    class Meta:
+        abstract = True
 
-        def get_change_subject(self, ar, cw):
-            ctx = dict(user=ar.user, what=str(self))
-            if cw is None:
-                return _("{user} created {what}").format(**ctx)
-                # msg = _("has been created by {user}").format(**ctx)
-                # return "{} {}".format(self, msg)
-            if len(list(cw.get_updates())) == 0:
-                return
-            return _("{user} modified {what}").format(**ctx)
-            # msg = _("has been modified by {user}").format(**ctx)
+    def get_change_subject(self, ar, cw):
+        ctx = dict(user=ar.user, what=str(self))
+        if cw is None:
+            return _("{user} created {what}").format(**ctx)
+            # msg = _("has been created by {user}").format(**ctx)
             # return "{} {}".format(self, msg)
+        if len(list(cw.get_updates())) == 0:
+            return
+        return _("{user} modified {what}").format(**ctx)
+        # msg = _("has been modified by {user}").format(**ctx)
+        # return "{} {}".format(self, msg)
+
+    def get_change_body(self, ar, cw):
+        ctx = dict(user=ar.user, what=ar.obj2htmls(self))
+        if cw is None:
+            html = format_html(_("{user} created {what}"), **ctx)
+            html += self.get_change_info(ar, cw)
+            html = format_html("<p>{}</p>.", html)
+        else:
+            items = list(cw.get_updates_html(["_user_cache"]))
+            if len(items) == 0:
+                return
+            txt = format_html(_("{user} modified {what}"), **ctx)
+            html = format_html("<p>{}:</p>", txt)
+            html += tostring(E.ul(*items))
+            html += self.get_change_info(ar, cw)
+        return format_html("<div>{}</div>", html)
+
+    def get_change_info(self, ar, cw):
+        return mark_safe("")
+
+    if dd.is_installed("notify"):
 
         def add_change_watcher(self, user):
             pass
             # raise NotImplementedError()
 
-        def get_change_body(self, ar, cw):
-            ctx = dict(user=ar.user, what=ar.obj2htmls(self))
-            if cw is None:
-                html = _("{user} created {what}").format(**ctx)
-                html += self.get_change_info(ar, cw)
-                html = "<p>{}</p>.".format(html)
-            else:
-                items = list(cw.get_updates_html(["_user_cache"]))
-                if len(items) == 0:
-                    return
-                html = _("{user} modified {what}").format(**ctx)
-                html = "<p>{}:</p>".format(html)
-                html += tostring(E.ul(*items))
-                html += self.get_change_info(ar, cw)
-            return "<div>{}</div>".format(html)
-
-        def get_change_info(self, ar, cw):
-            return ""
-
         def get_change_owner(self):
             return self
 

lino/modlib/periods/choicelists.py

@@ -0,0 +1,46 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2008-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+from django.utils.translation import gettext_lazy as _
+
+from lino.api import dd
+from lino.utils import ONE_DAY
+
+
+class PeriodType(dd.Choice):
+    ref_template = None
+
+    def __init__(self, value, text, duration, ref_template):
+        super().__init__(value, text, value)
+        self.ref_template = ref_template
+        self.duration = duration
+
+class PeriodTypes(dd.ChoiceList):
+    item_class = PeriodType
+    verbose_name = _("Period type")
+    verbose_name_plural = _("Period types")
+    column_names = "value text duration ref_template"
+
+    @dd.displayfield(_("Duration"))
+    def duration(cls, p, ar):
+        return str(p.duration)
+
+    @dd.displayfield(_("Template for reference"))
+    def ref_template(cls, p, ar):
+        return p.ref_template
+
+add = PeriodTypes.add_item
+# value/names,  text, duration, ref_template
+add("month",     _("Month"),     1, "{month:0>2}")
+add("quarter",   _("Quarter"),   3, "Q{period}")
+add("trimester", _("Trimester"), 4, "T{period}")
+add("semester",  _("Semester"),  6, "S{period}")
+
+
+class PeriodStates(dd.Workflow):
+    pass
+
+add = PeriodStates.add_item
+add('10', _("Open"), 'open')
+add('20', _("Closed"), 'closed')

lino/modlib/periods/mixins.py

@@ -2,15 +2,40 @@
 # Copyright 2008-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
+import datetime
 from django.db import models
 from django.utils.translation import gettext_lazy as _
 
 from lino.api import dd, rt
 from lino import mixins
-from lino.mixins.periods import DateRange
 from lino.mixins import Referrable
+from lino.utils import ONE_DAY
 
 from lino.modlib.office.roles import OfficeStaff
+from lino.modlib.system.choicelists import DurationUnits
+
+
+def get_range_for_date(date):
+    """
+    Return the default start and end date of the period to create for the given
+    date.
+    """
+    pt = dd.plugins.periods.period_type
+    month = date.month
+    year = date.year
+    month -= dd.plugins.periods.start_month
+    if month < 0:
+        month += 12
+        year -= 1
+    period = int(month / pt.duration)
+    month = dd.plugins.periods.start_month + period * pt.duration
+    if month > 12:
+        month -= 12
+        year += 1
+    sd = datetime.date(year, month, 1)
+    # ed = sd.replace(month=sd.month + pt.duration + 1, 1) - ONE_DAY
+    ed = DurationUnits.months.add_duration(sd, pt.duration) - ONE_DAY
+    return (sd, ed)
 
 
 class PeriodRange(dd.Model):