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

lino/mixins/periods.py

@@ -214,11 +214,11 @@ class DateRangeObservable(Model):
     def setup_parameters(cls, fields):
         fields.update(
             start_date=models.DateField(
-                _("Period from"),
+                _("Date range from"),
                 blank=True,
                 null=True,
                 default=cls.get_default_start_date,
-                help_text=_("Start date of observed period"),
+                help_text=_("Start date of observed date range."),
             )
         )
         fields.update(
@@ -227,7 +227,7 @@ class DateRangeObservable(Model):
                 blank=True,
                 null=True,
                 default=cls.get_default_end_date,
-                help_text=_("End date of observed period"),
+                help_text=_("End date of observed date range."),
             )
         )
         super().setup_parameters(fields)
@@ -267,6 +267,12 @@ class DateRange(DateRangeObservable):
     def get_period_text(self):
         return rangetext(self, fdl, self.empty_period_text)
 
+    def covers_date(self, d):
+        if self.start_date and self.start_date > d:
+            return False
+        if self.end_date and self.end_date < d:
+            return False
+        return True
 
 DateRange.set_widget_options("start_date", width=10)
 DateRange.set_widget_options("end_date", width=10)
@@ -372,4 +378,4 @@ class Today(ParameterPanel):
                 help_text=_("Date of observation"),
             ),
         )
-        super(Today, self).__init__(**kw)
+        super().__init__(**kw)

lino/mixins/polymorphic.py

@@ -247,16 +247,16 @@ class Polymorphic(model.Model):
         buttons = self.get_mti_buttons(ar)
         return E.span(*buttons)
 
-    def as_summary_item(self, ar, *args, **kwargs):
+    def as_summary_item(self, ar, text=None, **kwargs):
         # a = super(Polymorphic, self).get_detail_action(ar)
         a = self.get_detail_action(ar)
         if a is not None:
-            return super().as_summary_item(ar, *args, **kwargs)
+            return super().as_summary_item(ar, text, **kwargs)
         for m in self._mtinav_models:
             if m is not self.__class__:
                 obj = mti.get_child(self, m)
                 if obj is not None:
                     if obj.get_detail_action(ar) is not None:
-                        return obj.as_summary_item(ar, *args, **kwargs)
+                        return obj.as_summary_item(ar, text, **kwargs)
         return str(self)
         # return "?!? {} has no detail_action for {}".format(self, ar)

lino/mixins/ref.py

@@ -47,7 +47,7 @@ class Referrable(model.Model):
     @classmethod
     def on_analyze(cls, site):
         cls.set_widget_options("ref", width=cls.ref_max_length)
-        super(Referrable, cls).on_analyze(site)
+        super().on_analyze(site)
 
     def on_duplicate(self, ar, master):
         """
@@ -56,7 +56,10 @@ class Referrable(model.Model):
         """
         if self.ref:
             self.ref += " (DUP)"
-        super(Referrable, self).on_duplicate(ar, master)
+        super().on_duplicate(ar, master)
+
+    def __str__(self):
+        return self.ref or super().__str__()
 
     @staticmethod
     def ref_prefix(obj, ar=None):
@@ -96,7 +99,7 @@ class Referrable(model.Model):
         # if search_text.isdigit():
         if search_text.startswith("*"):
             return models.Q(**{prefix + "ref__icontains": search_text[1:]})
-        return super(Referrable, cls).quick_search_filter(search_text, prefix)
+        return super().quick_search_filter(search_text, prefix)
 
 
 class StructuredReferrable(Referrable):

lino/modlib/checkdata/__init__.py

@@ -20,7 +20,8 @@ class Plugin(ad.Plugin):
     "The config descriptor for this plugin."
 
     verbose_name = _("Checkdata")
-    needs_plugins = ["lino.modlib.users", "lino.modlib.gfks", "lino.modlib.linod"]
+    needs_plugins = ["lino.modlib.users", "lino.modlib.gfks",
+        "lino.modlib.office", "lino.modlib.linod"]
 
     # plugin settings
     responsible_user = None  # the username (a string)
@@ -50,8 +51,7 @@ class Plugin(ad.Plugin):
             User = self.site.models.users.User
             try:
                 self._responsible_user = User.objects.get(
-                    username=self.responsible_user
-                )
+                    username=self.responsible_user)
             except User.DoesNotExist:
                 msg = "Invalid username '{0}' in `responsible_user` "
                 msg = msg.format(self.responsible_user)

lino/modlib/extjs/ext_renderer.py

@@ -986,7 +986,7 @@ class ExtRenderer(JsCacheRenderer):
         tbl = dh.layout._datasource
         yield ""
         yield "Lino.%s = Ext.extend(Lino.ActionFormPanel,{" % dh.layout._formpanel_name
-        for k, v in list(dh.main.ext_options().items()):
+        for k, v in dh.main.ext_options().items():
             if k != "items":
                 yield "  %s: %s," % (k, py2js(v))
         assert tbl.action_name is not None

lino/modlib/languages/__init__.py

@@ -27,7 +27,7 @@ from lino import ad, _
 class Plugin(ad.Plugin):
     "See :doc:`/dev/plugins`."
 
-    verbose_name = _("Boards")
+    verbose_name = _("Languages")
 
     def setup_config_menu(self, site, user_type, m, ar=None):
         p = self.get_menu_group()

lino/modlib/languages/models.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2008-2017 Luc Saffre
+# Copyright 2008-2017 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """Defines the :class:`Language` model.
 

lino/modlib/linod/consumers.py

@@ -57,9 +57,8 @@ class LinodConsumer(AsyncConsumer):
     async def run_background_tasks(self, event: dict):
         # 'run.background.tasks' in `pm linod`
         from lino.modlib.linod.mixins import start_task_runner
-
-        # start_task_runner = settings.SITE.models.linod.start_task_runner
-        ar = settings.SITE.login()
+        from lino.core.requests import BaseRequest
+        ar = BaseRequest()
         asyncio.ensure_future(start_task_runner(ar))
 
     async def send_push(self, event):

lino/modlib/memo/mixins.py

@@ -286,7 +286,7 @@ class MemoReferrable(dd.Model):
     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)
 

lino/modlib/periods/__init__.py

@@ -0,0 +1,31 @@
+# Copyright 2008-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+from lino import ad, _
+
+
+class Plugin(ad.Plugin):
+
+    verbose_name = _("Stored periods")
+    period_name = _("Accounting period")
+    period_name_plural = _("Accounting periods")
+    year_name = _("Fiscal year")
+    year_name_plural = _("Fiscal years")
+    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

@@ -0,0 +1,23 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2012-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+import datetime
+from django.conf import settings
+from lino.api import dd, rt, _
+
+start_year = dd.get_plugin_setting("periods", "start_year", None)
+
+def objects():
+    StoredYear = rt.models.periods.StoredYear
+
+    cfg = dd.plugins.periods
+    site = settings.SITE
+    if site.the_demo_date is not None:
+        if start_year > site.the_demo_date.year:
+            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.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

@@ -0,0 +1,126 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2008-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+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.modlib.office.roles import OfficeStaff
+
+
+class PeriodRange(dd.Model):
+
+    class Meta:
+        abstract = True
+
+    start_period = dd.ForeignKey(
+        'periods.StoredPeriod',
+        blank=True,
+        verbose_name=_("Start period"),
+        related_name="%(app_label)s_%(class)s_set_by_start_period")
+
+    end_period = dd.ForeignKey(
+        'periods.StoredPeriod',
+        blank=True,
+        null=True,
+        verbose_name=_("End period"),
+        related_name="%(app_label)s_%(class)s_set_by_end_period")
+
+    def get_period_filter(self, fieldname, **kwargs):
+        return rt.models.periods.StoredPeriod.get_period_filter(
+            fieldname, self.start_period, self.end_period, **kwargs)
+
+
+class PeriodRangeObservable(dd.Model):
+
+    class Meta:
+        abstract = True
+
+    observable_period_prefix = ''
+
+    @classmethod
+    def setup_parameters(cls, fields):
+        fields.update(start_period=dd.ForeignKey(
+            'periods.StoredPeriod',
+            blank=True,
+            null=True,
+            help_text=_("Start of observed period range."),
+            verbose_name=_("Period from")))
+        fields.update(end_period=dd.ForeignKey(
+            'periods.StoredPeriod',
+            blank=True,
+            null=True,
+            help_text=_("Optional end of observed period range. "
+                        "Leave empty to observe only the start period."),
+            verbose_name=_("Period until")))
+        super().setup_parameters(fields)
+
+    @classmethod
+    def get_request_queryset(cls, ar, **kwargs):
+        qs = super().get_request_queryset(ar, **kwargs)
+        if (pv := ar.param_values) is None: return qs
+        if pv.start_period is not None:
+            fkw = dict()
+            fkw[cls.observable_period_prefix + "journal__preliminary"] = False
+            flt = rt.models.periods.StoredPeriod.get_period_filter(
+                cls.observable_period_prefix + "accounting_period",
+                pv.start_period, pv.end_period, **fkw)
+            qs = qs.filter(**flt)
+        return qs
+
+    @classmethod
+    def get_title_tags(cls, ar):
+        for t in super().get_title_tags(ar):
+            yield t
+        pv = ar.param_values
+        if pv.start_period is not None:
+            if pv.end_period is None:
+                yield str(pv.start_period)
+            else:
+                yield "{}..{}".format(pv.start_period, pv.end_period)
+
+
+class PeriodRangeParameters(dd.ParameterPanel):
+
+    def __init__(self,
+                 verbose_name_start=_("Period from"),
+                 verbose_name_end=_("until"),
+                 **kwargs):
+        kwargs.update(
+            start_period=dd.ForeignKey(
+                'periods.StoredPeriod',
+                blank=True,
+                null=True,
+                help_text=_("Start of observed period range"),
+                verbose_name=verbose_name_start),
+            end_period=dd.ForeignKey(
+                'periods.StoredPeriod',
+                blank=True,
+                null=True,
+                help_text=_("Optional end of observed period range. "
+                            "Leave empty to consider only the Start period."),
+                verbose_name=verbose_name_end))
+        super().__init__(**kwargs)
+
+    def check_values(self, pv):
+        if not pv.start_period:
+            raise Warning(_("Select at least a start period"))
+        if pv.end_period:
+            if str(pv.start_period) > str(pv.end_period):
+                raise Warning(_("End period must be after start period"))
+
+    def get_title_tags(self, ar):
+        pv = ar.param_values
+        if pv.start_period:
+            if pv.end_period:
+                yield _("Periods {}...{}").format(pv.start_period,
+                                                  pv.end_period)
+            else:
+                yield _("Period {}").format(pv.start_period)
+        else:
+            yield str(_("All periods"))

lino/modlib/periods/models.py

@@ -0,0 +1,246 @@
+# -*- coding: UTF-8 -*-
+# 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
+from lino import mixins
+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
+
+add = PeriodStates.add_item
+add('10', _("Open"), 'open')
+add('20', _("Closed"), 'closed')
+
+
+class StoredYear(DateRange, Referrable):
+
+    class Meta:
+        app_label = 'periods'
+        verbose_name = dd.plugins.periods.year_name
+        verbose_name_plural = dd.plugins.periods.year_name_plural
+        ordering = ['ref']
+
+    preferred_foreignkey_width = 10
+
+    state = PeriodStates.field(default='open')
+
+    @classmethod
+    def get_simple_parameters(cls):
+        yield super().get_simple_parameters()
+        yield "state"
+
+    @classmethod
+    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("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):
+        ref = cls.get_ref_for_date(date)
+        obj = cls.get_by_ref(ref, None)
+        if obj is None:
+            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
+
+    def __str__(self):
+        return self.ref
+
+
+class StoredPeriod(DateRange, Referrable):
+
+    class Meta:
+        ordering = ['ref']
+        app_label = 'periods'
+        verbose_name = dd.plugins.periods.period_name
+        verbose_name_plural = dd.plugins.periods.period_name_plural
+
+    preferred_foreignkey_width = 10
+
+    state = PeriodStates.field(default='open')
+    year = dd.ForeignKey('periods.StoredYear', blank=True, null=True)
+    remark = models.CharField(_("Remark"), max_length=250, blank=True)
+
+    @classmethod
+    def get_simple_parameters(cls):
+        yield super().get_simple_parameters()
+        yield "state"
+        yield "year"
+
+    @classmethod
+    def get_request_queryset(cls, ar):
+        qs = super().get_request_queryset(ar)
+        if (pv := ar.param_values) is None: return qs
+
+        # if pv.start_date is None or pv.end_date is None:
+        #     period = None
+        # else:
+        #     period = (pv.start_date, pv.end_date)
+        # if period is not None:
+        #     qs = qs.filter(dd.inrange_filter('start_date', period))
+        if pv.start_date or pv.end_date:
+            qs = qs.filter(dd.overlap_range_filter(
+                pv.start_date, pv.end_date, "start_date", "end_date"))
+        # if pv.start_date:
+        #     qs = qs.filter(dd.range_filter(pv.start_date, 'start_date', 'end_date'))
+        #     # qs = qs.filter(start_date__gte=pv.start_date)
+        # if pv.end_date:
+        #     qs = qs.filter(dd.range_filter(pv.end_date, 'start_date', 'end_date'))
+            # qs = qs.filter(end_date__lte=pv.end_date)
+        return qs
+
+    @classmethod
+    def get_available_periods(cls, today):
+        """Return a queryset of periods available for booking."""
+        if today is None:  # added 20160531
+            today = dd.today()
+        fkw = dict(start_date__lte=today, end_date__gte=today)
+        return cls.objects.filter(**fkw)
+
+    @classmethod
+    def get_periods_in_range(cls, p1, p2):
+        return cls.objects.filter(ref__gte=p1.ref, ref__lte=p2.ref)
+
+    @classmethod
+    def get_period_filter(cls, fieldname, p1, p2, **kwargs):
+        if p1 is None:
+            return kwargs
+
+        # ignore preliminary movements if a start_period is given:
+        # kwargs[voucher_prefix + "journal__preliminary"] = False
+
+        # accounting_period = voucher_prefix + "accounting_period"
+
+        if p2 is None:
+            kwargs[fieldname] = p1
+        else:
+            periods = cls.get_periods_in_range(p1, p2)
+            kwargs[fieldname + '__in'] = periods
+        return kwargs
+
+    @classmethod
+    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:
+            obj = cls(
+                ref=ref,
+                start_date=date.replace(day=1),
+                end_date=last_day_of_month(date))
+            obj.full_clean()
+            obj.save()
+        return obj
+
+    def full_clean(self, *args, **kwargs):
+        if self.start_date is None:
+            self.start_date = dd.today().replace(day=1)
+        if not self.year:
+            self.year = StoredYear.get_or_create_from_date(self.start_date)
+        super().full_clean(*args, **kwargs)
+
+    def __str__(self):
+        if not self.ref:
+            return dd.obj2str(self)
+            # "{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'
+    required_roles = dd.login_required(OfficeStaff)
+    column_names = "ref start_date end_date state *"
+    # detail_layout = """
+    # ref id
+    # start_date end_date
+    # """
+
+class StoredPeriods(dd.Table):
+    required_roles = dd.login_required(OfficeStaff)
+    model = 'periods.StoredPeriod'
+    order_by = ["ref", "start_date", "year"]
+    column_names = "ref start_date end_date year state remark *"

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

lino/modlib/system/__init__.py

@@ -14,9 +14,7 @@ class Plugin(ad.Plugin):
     "See :doc:`/dev/plugins`."
 
     verbose_name = _("System")
-
     needs_plugins = ["lino.modlib.printing"]
-
     use_dashboard_layouts = False
     """Whether to use system.DashboardLayouts. This feature is broken.
     """