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

lino/__init__.py

@@ -26,7 +26,7 @@ defines no models, some template files, a series of :term:`django-admin commands
 
 """
 
-__version__ = '24.10.2'
+__version__ = '24.10.3'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/dd.py

@@ -25,6 +25,7 @@ from lino.core.utils import obj2str
 from lino.core.utils import obj2unicode
 from lino.core.utils import range_filter
 from lino.core.utils import inrange_filter
+from lino.core.utils import overlap_range_filter
 from lino.core.utils import full_model_name
 
 from lino.core.model import Model

lino/core/store.py

@@ -821,7 +821,10 @@ class DateStoreField(StoreField):
             try:
                 return datetime.date(*settings.SITE.parse_date(v))
             except Exception as e:
-                raise Warning("Invalid date '{}'' : {}".format(v, e))
+                # The front end is responsible for validating before submitting.
+                # Here it's too late to complain.
+                return None
+                # raise Warning("Invalid date '{}'' : {}".format(v, e))
 
     def format_value(self, ar, v):
         """Return a plain textual representation of this value as a unicode

lino/core/utils.py

@@ -23,6 +23,7 @@ from django.core import exceptions
 from django.http import QueryDict
 
 from lino.utils.html import E, assert_safe, tostring
+from lino.utils.ranges import isrange
 
 from django.core.validators import validate_email, ValidationError, URLValidator
 
@@ -309,21 +310,41 @@ def range_filter(value, f1, f2):
     q2 = Q(**{f2 + "__isnull": True}) | Q(**{f2 + "__gte": value})
     return Q(q1, q2)
 
-
 def inrange_filter(fld, rng, **kw):
     """Assuming a database model with a field named `fld`, return a Q
-    object to select those rows whose `fld` value is not null and
-    within the given range `rng`.  `rng` must be a tuple or list with
-    two items.
-
+    object to select the rows having value for `fld` within the given range `rng`.
+    `rng` must be a tuple or list with two items.
     """
-    assert rng[0] <= rng[1]
+
+    # assert rng[0] <= rng[1]
     kw[fld + "__isnull"] = False
-    kw[fld + "__gte"] = rng[0]
-    kw[fld + "__lte"] = rng[1]
+    if rng[0] is not None:
+        kw[fld + "__gte"] = rng[0]
+    if rng[1] is not None:
+        kw[fld + "__lte"] = rng[1]
     return Q(**kw)
 
 
+def overlap_range_filter(sv, ev, f1, f2, **kw):
+    """
+
+    Return a Q object to select all objects having fields `f1` and `f2` define a
+    range that overlaps with the range specified by `sv` (start value) and `ev`
+    (end value).
+
+    For example, when I specify filter parameters `Date from` 2024-02-21 and
+    `until` 2024-03-12 in a :class:`lino.modlib.periods.StoredPeriods` table, I
+    want both February and March. Tested examples see
+    :ref:`dg.plugins.periods.period_filter`.
+
+    """
+    # if not isrange(rng[0], rng[1]):
+    #     raise ValueError(f"{rng} is not a valid range")
+    if not ev:
+        ev = sv
+    return Q(**{f1+"__lte" : ev, f2+"__gte" : sv})
+
+
 def babelkw(*args, **kw):
     return settings.SITE.babelkw(*args, **kw)
 
@@ -679,7 +700,7 @@ class ParameterPanel(object):
 
     Subclassed e.g. by
     :class:`lino.mixins.periods.ObservedDateRange`.
-    :class:`lino_xl.lib.accounting.AccountingPeriodRange`.
+    :class:`lino_xl.lib.accounting.PeriodRangeParameters`.
     """
 
     def __init__(self, **kw):

lino/help_texts.py

@@ -376,6 +376,15 @@ help_texts = {
     'lino.modlib.linod.SystemTask.log_level' : _("""The logging level to apply when running this task."""),
     'lino.modlib.linod.SystemTask.run' : _("""Performs a routine job."""),
     'lino.modlib.linod.SystemTasks' : _("""The default actor for the SystemTask model."""),
+    'lino.modlib.periods.StoredPeriod' : _("""An accounting period is the smallest time slice to be declared in accounting reports. Usually it corresponds to one month. But there are except for some small companies which declare per quarter."""),
+    'lino.modlib.periods.StoredYears' : _("""The fiscal years available in this database."""),
+    'lino.modlib.periods.PeriodRange' : _("""Model mixin for objects that cover a range of accounting periods."""),
+    'lino.modlib.periods.PeriodRange.start_period' : _("""The first period of the range to cover."""),
+    'lino.modlib.periods.PeriodRange.end_period' : _("""The last period of the range to cover."""),
+    'lino.modlib.periods.PeriodRangeObservable' : _("""Model mixin for objects that can be filtered by a range of accounting periods. This adds two parameter fields start_period and end_period to every table on this model."""),
+    'lino.modlib.periods.StoredPeriodRange' : _("""A parameter panel with two fields:"""),
+    'lino.modlib.periods.StoredPeriodRange.start_period' : _("""Start of observed period range."""),
+    'lino.modlib.periods.StoredPeriodRange.end_period' : _("""Optional end of observed period range. Leave empty to consider only the Start period."""),
     'lino.modlib.publisher.Page' : _("""The Django model that represents a content page."""),
     'lino.modlib.publisher.PublisherBuildMethod' : _("""This deserves better documentation."""),
     'lino.modlib.publisher.Publishable' : _("""Model mixin to add to models that are potentially publishable."""),

lino/mixins/periods.py

@@ -372,4 +372,4 @@ class Today(ParameterPanel):
                 help_text=_("Date of observation"),
             ),
         )
-        super(Today, self).__init__(**kw)
+        super().__init__(**kw)

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/periods/__init__.py

@@ -0,0 +1,20 @@
+# 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")
+    fix_y2k = False
+    start_year = 2012
+
+    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")

lino/modlib/periods/fixtures/std.py

@@ -0,0 +1,22 @@
+# -*- 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)
+        # 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,242 @@
+# -*- 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
+from lino.mixins.periods import DateRange
+from lino.mixins import Referrable
+
+from lino.modlib.office.roles import OfficeStaff
+
+
+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 = _("Fiscal year")
+        verbose_name_plural = _("Fiscal years")
+        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 year2ref(cls, year):
+        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
+
+    @classmethod
+    def get_or_create_from_date(cls, date):
+        obj = cls.from_int(date.year, None)
+        if obj is None:
+            obj = cls.create_from_year(date.year)
+            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_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)
+
+    @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_default_for_date(cls, d):
+        ref = cls.get_ref_for_date(d)
+        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.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
+
+
+StoredPeriod.set_widget_options('ref', width=6)
+
+
+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/utils/ranges.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2009-2021 Luc Saffre
+# Copyright 2009-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """The :mod:`lino.utils.ranges` module contains utility methods for
 working with "ranges".
@@ -76,10 +76,10 @@ def overlap(a1, a2, b1, b2):
     works with integers or other comparable values.  The following
     examples use integer values to be more readable.
 
-    Unlike the test presented at
-    <http://bytes.com/topic/python/answers/457949-determing-whether-two-ranges-overlap>,
-    this works also with "open" ranges (the open end being indicated
-    by a `None` value).
+    Unlike the test presented in `Determing whether two ranges overlap
+    <https://post.bytes.com/forum/topic/python/398735-determing-whether-two-ranges-overlap?t=457949>`__,
+    this works also with "open" ranges (the open end being indicated by a `None`
+    value).
 
     Types of constellations::
 
@@ -129,13 +129,3 @@ def overlap(a1, a2, b1, b2):
         else:
             return True
     return True
-
-
-def _test():
-    import doctest
-
-    doctest.testmod()
-
-
-if __name__ == "__main__":
-    _test()

{lino-24.10.2.dist-info → lino-24.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lino
-Version: 24.10.2
+Version: 24.10.3
 Summary: A framework for writing desktop-like web applications using Django and ExtJS or React
 Project-URL: Homepage, https://www.lino-framework.org
 Project-URL: Repository, https://gitlab.com/lino-framework/lino

{lino-24.10.2.dist-info → lino-24.10.3.dist-info}/RECORD

@@ -1,13 +1,13 @@
 lino/.cvsignore,sha256=1vrrWoP-WD8hPfCszHHIiJEi8KUMRCt5WvoKB9TSB1k,28
 lino/SciTEDirectory.properties,sha256=rCYi_e-6h8Yx5DwXhAa6MBPlVINcl6Vv9BQDYZV2_go,28
-lino/__init__.py,sha256=ISO_sqTgmyY5do7wrEc2SMiswT8DTnaL49JbqPkWny0,5585
+lino/__init__.py,sha256=xXbC44yjPzSBUvfGWf_PgZxIv2O6_VnDETw6O0AHX_4,5585
 lino/ad.py,sha256=AQ-vJ4scac1mx3xegXezxnxyOQpV-a0q3VFMJSDbj2s,142
 lino/apps.py,sha256=ECq-dPARDkuhngwNrcipse3b4Irj70HxJs44uWEZFc4,27
 lino/hello.py,sha256=7-PJg7PnEiznyETqGjOwXcKh8rda0qLetpbS2gvRYy0,532
-lino/help_texts.py,sha256=gZq8EJfReHB8Z5jKFFOr1pjDRODm7FVkHC8IRA7gq3w,89104
+lino/help_texts.py,sha256=jcABL4QqvwyJrzaTIqCZfSdeOd5LBu7QcV3curn3ArI,90338
 lino/api/__init__.py,sha256=WmzHU-rHdZ68se_nI0SmepQTGE8-cd9tPpovHRH9aag,512
 lino/api/ad.py,sha256=F6SrcKPRRalHKOZ7QLwsRWGq9hhykQIeo0b85cEk9NQ,314
-lino/api/dd.py,sha256=LHooukTaNuxAbhtSdvDNVbI7nkxeU-QTp5Dfz00bmjk,7764
+lino/api/dd.py,sha256=-mjuoflZilnFM97we-N1H_sEf1TQiNs62JwZ5m4XV1s,7813
 lino/api/doctest.py,sha256=fJ97w6rOO7AdlZ5DmgSHuIq-2LfOIbLT_mmslCdI2do,25561
 lino/api/rt.py,sha256=auN4YoIthkXsjSN09OR6YeaNxSNfUO7E5KyTAvQtjh8,1400
 lino/api/selenium.py,sha256=07BQuC6KW2tBUlIUcPGeCQHIfogz-wuHJqPshSzLDp0,9384
@@ -60,12 +60,12 @@ lino/core/requests.py,sha256=ZLsiyAI2zNt65nWV3ebrnZWaqarTpZSyS31ba7_a_9A,92177
 lino/core/roles.py,sha256=PXwk436xUupxdbJcygRSYFu7ixfKjAJPQRUQ8sy0lB0,4425
 lino/core/signals.py,sha256=0JT89mkjSbRm57QZcSI9DoThoKUGkyi-egNhuLUKEds,948
 lino/core/site.py,sha256=sUuyTNi9IvJ-BwOW1LbAiRKmAE0xOYpHlJqsDH_ID5E,85443
-lino/core/store.py,sha256=uMza9XRX3QeIRCWwBOK9w-4pyjruWtJCfSqOV4_kdgA,51338
+lino/core/store.py,sha256=j3Dk2mSYJLKI6R-SSsuomBcF0cb3dnI87hysqBl5PHU,51499
 lino/core/tables.py,sha256=FfA3KhGshsR1maNB6B11BbJ4m8cxxIaOhV0jvMxTaJA,25468
 lino/core/urls.py,sha256=06QlmN1vpxjmb5snO3SPpP6lX1pMdE60bTiBiC77_vQ,2677
 lino/core/user_types.py,sha256=0iSYmzr2M9v2Mn2y6hzAZeqareUT-gD7l3MfIPyG9ZI,867
 lino/core/userprefs.py,sha256=cmufIS9xJErKDrw05uoWtQTUR6WRWIGkU1KdAqzNr5M,2850
-lino/core/utils.py,sha256=3JgByh5KIG-WM_JMkZpFEot-HAh6wV7jR2YfVeDl48o,34540
+lino/core/utils.py,sha256=TW9eKS8Ua6tCGugBzJUS6gXiEAqI7EbB6VAiKwYshw8,35304
 lino/core/views.py,sha256=b7q9XOjl8nkBV-ZRcR-swFjcC9BGyanRYM2CsB_A5xc,6959
 lino/core/widgets.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lino/core/workflows.py,sha256=9O5INnx3nPW73UmeEPWgN146clQSWwna3Jq_w1MThcg,10567
@@ -120,7 +120,7 @@ lino/mixins/__init__.py,sha256=cSFXzy8i0Akp9PmUSJz8E5t3twO3Z2lyCTyTCEqAQSU,8931
 lino/mixins/dupable.py,sha256=lk1Lgqae1PXRP1Ej6AKg5n3tG1MLYu7Ww1Qy5kb46_E,10092
 lino/mixins/duplicable.py,sha256=lQ5SEQmxPcOU9vETocgQI41uzgvunvXIy7HAnPeKDUI,4224
 lino/mixins/human.py,sha256=YDIfIHHAaVmzd3uGsJp_vDvkaBWOp09I7i4AGNy9YsQ,13255
-lino/mixins/periods.py,sha256=zEK9OiwTMVZX3vpy-viByRrBDNN6OgQFb4sdQmOxjow,11280
+lino/mixins/periods.py,sha256=VSxYLfO3b7aJm0ZbGYBwhA3sFuft2-OO4Qv2iR2cKVk,11269
 lino/mixins/polymorphic.py,sha256=jzpfnzdDChvh1Ua16mdCQQOmoG-7Zyz69UOpcdqIiSA,9391
 lino/mixins/printable.py,sha256=4U8M1lrTjUeuaPwrcWoanCBo53iAxiNpSTsVctI-gI0,199
 lino/mixins/ref.py,sha256=gMWewqZjydq02LRDYY30t5EDWBbtecCOAoVU5IX1ayc,5249
@@ -3525,8 +3525,8 @@ lino/modlib/jinja/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 lino/modlib/jinja/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lino/modlib/jinja/management/commands/showsettings.py,sha256=nM5PNWXzbNdhnyH1b05iB__qwBdtPJ14T-Gt5jqGkww,452
 lino/modlib/jinja/management/commands/status.py,sha256=REApUMUqYgQY_50RwfAFbFBGXmn4UZGtLJMOncmOQHg,609
-lino/modlib/languages/__init__.py,sha256=xKTD2jBZ2Dy5iScnPDH9L035bKmlkixifQ4DOKpl__0,1005
-lino/modlib/languages/models.py,sha256=LiEGV_XNR5xy-eIHYIH-GHVmyFJ4ovK2wz4eCv2KhCY,806
+lino/modlib/languages/__init__.py,sha256=RUPzAiUVGuJXBWVWSomkbMm-f5OXBagZShfx4UyaUIw,1008
+lino/modlib/languages/models.py,sha256=tHF14XZKwx1te3DLbdsdogFLeyLuCWz_WExA-OU6VFo,810
 lino/modlib/languages/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lino/modlib/languages/fixtures/all_languages.py,sha256=L_EmmcLVPKXcFB8uJITN3rWxNJ43CVNTKj5nbSXPK54,20941
 lino/modlib/languages/fixtures/few_languages.py,sha256=nhhfS4bV9x2yvtGlWFX5j7pC40-c31bFInGvlHxmT4Y,846
@@ -3572,6 +3572,10 @@ lino/modlib/odata/views.py,sha256=ssyYYIyGoxXtR3hKnIa-ZBPLb6vxEU5C6XUUQ1L6Z70,72
 lino/modlib/odata/config/odata/csdl.xml,sha256=KFDImzUA4YI6PL-i5AHnm22eBMLTw-K2iljslDJFQH8,296
 lino/modlib/office/__init__.py,sha256=rOKD9zKt-VBvFFqoHBioNp299Igb1Sk2n466iCt6ASQ,287
 lino/modlib/office/roles.py,sha256=oQWTZ-_9_vssc9QW5A0YspMjG_V5gCiHSU0eE0AIH30,356
+lino/modlib/periods/__init__.py,sha256=Q94txH81IrZR23X00rAbR3BUXDYwfUafnURrWzqEmlg,651
+lino/modlib/periods/mixins.py,sha256=IEjeeenFJD9HItK2n1wmsz1KTC9apFb1u87Mz-bhlY4,4266
+lino/modlib/periods/models.py,sha256=tk-CyIqii4s5gj9KBatvU_sAaUseeL6hdRbYDTlItVs,7522
+lino/modlib/periods/fixtures/std.py,sha256=c7K5xYHgC6AJT59W77MSRM2WS5ut58j55hoO_u9frJ4,788
 lino/modlib/printing/__init__.py,sha256=u1fq44d073-IDH_t8hWs1sQdlAHdsCP85sfEOMSW5L4,689
 lino/modlib/printing/actions.py,sha256=ud56ri8NAK0U8d8vVrhv-GTE8WD8jiUidpdXGrmVPlA,11632
 lino/modlib/printing/choicelists.py,sha256=KzcFD-WjXIXiqLY-gVuuOvE0pueJuV7t5IMgUb4I2P0,9607
@@ -4620,7 +4624,7 @@ lino/utils/pdf.py,sha256=caISmnrrADN1MTK_GIiasfkVUyqhTEuK9mtoMf_S7qU,688
 lino/utils/pythontest.py,sha256=AA9i3CEWgpbJKNTkxc0Gz94sy1R1MBpyinqrlahKKno,4954
 lino/utils/pyuca.py,sha256=YSLpCYEMqKUhx1y0q-ML8Ryu2ARDFO2HyIFxz1DzYEY,4344
 lino/utils/quantities.py,sha256=m_oi647uCTf2NhhQo6ytphZa2jQq1QXIUcts-cLkEJM,7367
-lino/utils/ranges.py,sha256=gXMD3uZBobGnOfn8GXSJ40gtJ7UcxrIOOFWZCk--zXE,3343
+lino/utils/ranges.py,sha256=wVsZMe3dlaRYWWELXCGSK2DvjBfW4eLbAwpQVYqzj3g,3303
 lino/utils/report.py,sha256=5l1NkZpcZyd1zpg37MB4Doly9dH9KHBEFarp9Q6vh4w,7983
 lino/utils/requests.py,sha256=vXxsC51FK9FgrqmF9dy3MsmUqJINjSQ_4AmvBiQbGEk,1337
 lino/utils/restify.py,sha256=QMVQXrmjDl6PPC7HJJGeDm125pcvrZKvcMpiscaPrsw,14066
@@ -4639,8 +4643,8 @@ lino/utils/xml.py,sha256=4Z44W1e5HvTVrU8erkohgnwqY-5Cr2NHywaAJ5OgRvw,989
 lino/utils/mldbc/__init__.py,sha256=QqWRlzeXaOmFfbCk-vTY3SZMn1-FCf67XnpZdd_Nim0,1134
 lino/utils/mldbc/fields.py,sha256=tAX8G5UKigr9c6g0F3ARIjZZtg406mdaZ--PWSbiH9E,2873
 lino/utils/mldbc/mixins.py,sha256=CkYe5jDa7xp9fJq_V8zcZf8ocxgIjUgHc9KZccvA_Yw,1945
-lino-24.10.2.dist-info/METADATA,sha256=ntU1BmW4OU6iHggi-NZO_PMuJVTb9oUJ6TSEG2NMagU,42535
-lino-24.10.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-lino-24.10.2.dist-info/licenses/AUTHORS.rst,sha256=8VEm_G4HOmYEa4oi1nVoKKsdo4JanekEJCefWd2E8vk,981
-lino-24.10.2.dist-info/licenses/COPYING,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
-lino-24.10.2.dist-info/RECORD,,
+lino-24.10.3.dist-info/METADATA,sha256=OEW_3rFYAWtyG5d4N_-peNOZE4NuzcNH4Tg51ldh6YQ,42535
+lino-24.10.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+lino-24.10.3.dist-info/licenses/AUTHORS.rst,sha256=8VEm_G4HOmYEa4oi1nVoKKsdo4JanekEJCefWd2E8vk,981
+lino-24.10.3.dist-info/licenses/COPYING,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+lino-24.10.3.dist-info/RECORD,,