lino 24.10.3__py3-none-any.whl → 24.11.1__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,32 +77,24 @@ 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:
             kwargs.update(title=txt)
-        e = self.as_summary_item(ar, **kwargs)
+        e = self.as_summary_item(ar)
         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:

lino/modlib/notify/mixins.py

@@ -8,46 +8,47 @@ from lino.api import dd, rt, _
 
 
 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 = _("{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 ""
+
+    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/__init__.py

@@ -10,11 +10,22 @@ class Plugin(ad.Plugin):
     period_name_plural = _("Accounting periods")
     year_name = _("Fiscal year")
     year_name_plural = _("Fiscal years")
-    fix_y2k = False
     start_year = 2012
+    start_month = 1
+    period_type = "month"
+    fix_y2k = False
+    short_ref = False
 
     def setup_config_menu(self, site, user_type, m, ar=None):
         p = self.get_menu_group()
         m = m.add_menu(p.app_label, p.verbose_name)
         m.add_action("periods.StoredYears")
         m.add_action("periods.StoredPeriods")
+
+    def before_analyze(self):
+        if self.fix_y2k and self.start_month != 1:
+            raise Exception("When fix_y2k is set, start_month must be 1")
+        if isinstance(self.period_type, str):
+            self.period_type = self.site.models.periods.PeriodTypes.get_by_name(
+                self.period_type)
+        super().before_analyze()

lino/modlib/periods/fixtures/std.py

@@ -18,5 +18,6 @@ def objects():
             raise Exception("plugins.periods.start_year is after the_demo_date")
     today = site.the_demo_date or datetime.date.today()
     for y in range(start_year, today.year + 6):
-        yield StoredYear.create_from_year(y)
+        # yield StoredYear.create_from_year(y)
+        yield StoredYear.get_or_create_from_date(datetime.date(y, today.month, today.day))
         # StoredYears.add_item(StoredYear.year2value(y), str(y))

lino/modlib/periods/mixins.py

@@ -7,7 +7,6 @@ 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.modlib.office.roles import OfficeStaff

lino/modlib/periods/models.py

@@ -8,12 +8,45 @@ from django.utils.translation import gettext_lazy as _
 
 from lino.api import dd
 from lino import mixins
-from lino.utils import last_day_of_month
+from lino.utils import last_day_of_month, ONE_DAY
 from lino.mixins.periods import DateRange
 from lino.mixins import Referrable
 
 from lino.modlib.office.roles import OfficeStaff
 
+NEXT_YEAR_SEP = "/"
+YEAR_PERIOD_SEP = "-"
+
+class PeriodType(dd.Choice):
+    ref_template = None
+    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
@@ -27,8 +60,8 @@ class StoredYear(DateRange, Referrable):
 
     class Meta:
         app_label = 'periods'
-        verbose_name = _("Fiscal year")
-        verbose_name_plural = _("Fiscal years")
+        verbose_name = dd.plugins.periods.year_name
+        verbose_name_plural = dd.plugins.periods.year_name_plural
         ordering = ['ref']
 
     preferred_foreignkey_width = 10
@@ -41,45 +74,33 @@ class StoredYear(DateRange, Referrable):
         yield "state"
 
     @classmethod
-    def year2ref(cls, year):
+    def get_ref_for_date(cls, date):
+        year = date.year
+        if date.month < dd.plugins.periods.start_month:
+            year -= 1
         if dd.plugins.periods.fix_y2k:
             if year < 2000:
                 return str(year)[-2:]
             elif year < 3000:
                 return chr(int(str(year)[-3:-1]) + 65) + str(year)[-1]
             else:
-                raise Exception("20180827")
-            # elif year < 2010:
-            #     return "A" + str(year)[-1]
-            # elif year < 2020:
-            #     return "B" + str(year)[-1]
-            # elif year < 2030:
-            #     return "C" + str(year)[-1]
-            # else:
-            # raise Exception(20160304)
-        # return str(year)[2:]
-        return str(year)
-
-    @classmethod
-    def from_int(cls, year, *args):
-        ref = cls.year2ref(year)
-        return cls.get_by_ref(ref, *args)
-
-    @classmethod
-    def create_from_year(cls, year):
-        ref = cls.year2ref(year)
-        return cls(ref=ref,
-                   start_date=datetime.date(year, 1, 1),
-                   end_date=datetime.date(year, 12, 31))
-        # obj.full_clean()
-        # obj.save()
-        # return obj
+                raise Exception("fix_y2k not supported after 2999")
+        elif dd.plugins.periods.short_ref:
+            if dd.plugins.periods.start_month == 1:
+                return str(year)[-2:]
+            return str(year)[-2:] + NEXT_YEAR_SEP + str(year+1)[-2:]
+        elif dd.plugins.periods.start_month == 1:
+            return str(year)
+        return str(year) + NEXT_YEAR_SEP + str(year+1)[-2:]
 
     @classmethod
     def get_or_create_from_date(cls, date):
-        obj = cls.from_int(date.year, None)
+        ref = cls.get_ref_for_date(date)
+        obj = cls.get_by_ref(ref, None)
         if obj is None:
-            obj = cls.create_from_year(date.year)
+            sd = datetime.date(date.year, dd.plugins.periods.start_month, 1)
+            ed = sd.replace(year=date.year+1) - ONE_DAY
+            obj = cls(ref=ref, start_date=sd, end_date=ed)
             obj.full_clean()
             obj.save()
         return obj
@@ -138,43 +159,6 @@ class StoredPeriod(DateRange, Referrable):
         fkw = dict(start_date__lte=today, end_date__gte=today)
         return cls.objects.filter(**fkw)
 
-    @classmethod
-    def get_ref_for_date(cls, d):
-        """Return a text to be used as :attr:`ref` for a new period.
-
-        Alternative implementation for usage on a site with movements
-        before year 2000::
-
-            @classmethod
-            def get_ref_for_date(cls, d):
-                if d.year < 2000:
-                    y = str(d.year - 1900)
-                elif d.year < 2010:
-                    y = "A" + str(d.year - 2000)
-                elif d.year < 2020:
-                    y = "B" + str(d.year - 2010)
-                elif d.year < 2030:
-                    y = "C" + str(d.year - 2020)
-                return y + "{:0>2}".format(d.month)
-
-        """
-        y = StoredYear.year2ref(d.year)
-        return "{}-{:0>2}".format(y, d.month)
-
-        # if dd.plugins.periods.fix_y2k:
-        #     return rt.models.periods.StoredYear.from_int(d.year).ref \
-        #         + "{:0>2}".format(d.month)
-
-        # return "{0.year}-{0.month:0>2}".format(d)
-
-        # """The template used for building the :attr:`ref` of an
-        # :class:`StoredPeriod`.
-        #
-        # `Format String Syntax
-        # <https://docs.python.org/2/library/string.html#formatstrings>`_
-        #
-        # """
-
     @classmethod
     def get_periods_in_range(cls, p1, p2):
         return cls.objects.filter(ref__gte=p1.ref, ref__lte=p2.ref)
@@ -197,14 +181,26 @@ class StoredPeriod(DateRange, Referrable):
         return kwargs
 
     @classmethod
-    def get_default_for_date(cls, d):
-        ref = cls.get_ref_for_date(d)
+    def get_ref_for_date(cls, date):
+        pt = dd.plugins.periods.period_type
+        month = date.month
+        month_offset = month - dd.plugins.periods.start_month
+        if month_offset < 0:
+            month_offset += 12
+        period = int(month_offset / pt.duration) + 1
+        # periods_per_year = int(12 / p.duration)
+        # period = (month_offset % (periods_per_year-1)) + 1
+        return pt.ref_template.format(**locals())
+
+    @classmethod
+    def get_or_create_from_date(cls, date):  # get_default_for_date until 20241020
+        ref = date2ref(date)
         obj = cls.get_by_ref(ref, None)
         if obj is None:
-            values = dict(start_date=d.replace(day=1))
-            values.update(end_date=last_day_of_month(d))
-            values.update(ref=ref)
-            obj = StoredPeriod(**values)
+            obj = cls(
+                ref=ref,
+                start_date=date.replace(day=1),
+                end_date=last_day_of_month(date))
             obj.full_clean()
             obj.save()
         return obj
@@ -222,9 +218,17 @@ class StoredPeriod(DateRange, Referrable):
             # "{0} {1} (#{0})".format(self.pk, self.year)
         return self.ref
 
+    @property
+    def nickname(self):
+        if self.year.covers_date(dd.today()):
+            if len(parts := self.ref.split(YEAR_PERIOD_SEP)) == 2:
+                return parts[1]
+        return self.ref
 
 StoredPeriod.set_widget_options('ref', width=6)
 
+def date2ref(d):
+    return StoredYear.get_ref_for_date(d) + YEAR_PERIOD_SEP + StoredPeriod.get_ref_for_date(d)
 
 class StoredYears(dd.Table):
     model = 'periods.StoredYear'

lino/modlib/printing/actions.py

@@ -119,6 +119,7 @@ class BasePrintAction(Action):
 class DirectPrintAction(BasePrintAction):
     url_action_name = None
     icon_name = "printer"
+    # button_text = "🖶"  # 1F5B6
     tplname = None
 
     def __init__(self, label=None, tplname=None, build_method=None, **kw):
@@ -162,6 +163,7 @@ class CachedPrintAction(BasePrintAction):
     # select_rows = False
     http_method = "POST"
     icon_name = "printer"
+    # button_text = "🖶"  # 1F5B6
 
     def before_build(self, bm, elem):
         if elem.build_time:

lino/modlib/printing/choicelists.py

@@ -46,14 +46,14 @@ class BuildMethod(Choice):
             names, self.__class__.__name__, names, **kwargs
         )
 
-    def get_target(self, action, elem):
-        "used by `get_target_name`"
+    def get_target(self, action, obj):
+        # Used by get_target_name()
         # assert self.name is not None
         return MediaFile(
             self.use_webdav,
             self.cache_name,
             self.value,
-            elem.filename_root() + self.target_ext,
+            obj.filename_root() + self.target_ext,
         )
 
     def get_target_name(self, action, elem):

lino/modlib/publisher/ui.py

@@ -172,6 +172,6 @@ class TranslationsByPage(Pages):
     default_display_modes = {None: constants.DISPLAY_MODE_SUMMARY}
 
     @classmethod
-    def row_as_summary(cls, ar, obj, **kwargs):
+    def row_as_summary(cls, ar, obj, text=None, **kwargs):
         # return format_html("({}) {}", obj.language, obj.as_summary_row(ar, **kwargs))
-        return E.span("({}) ".format(obj.language), obj.as_summary_item(ar, **kwargs))
+        return E.span("({}) ".format(obj.language), obj.as_summary_item(ar, text, **kwargs))