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

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

@@ -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/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/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.
     """

lino/modlib/system/choicelists.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2011-2023 Rumma & Ko Ltd
+# Copyright 2011-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 import datetime
@@ -12,6 +12,7 @@ from django.utils.translation import gettext_lazy as _
 
 from lino.utils import isidentifier
 from lino.core.choicelists import ChoiceList, Choice
+from lino.core.roles import login_required, Explorer
 from lino.utils.dates import DateRangeValue
 from lino.utils.format_date import day_and_month, fds
 
@@ -229,3 +230,56 @@ add("M", _("monthly"), "monthly", du_freq=MONTHLY)
 add("Y", _("yearly"), "yearly", du_freq=YEARLY)
 add("P", _("per weekday"), "per_weekday")  # deprecated
 add("E", _("Relative to Easter"), "easter")
+
+
+
+class DisplayColor(Choice):
+    font_color = None
+    def __init__(self, value, text, names, font_color="white"):
+        super().__init__(value, text, names)
+        self.font_color = font_color
+
+
+class DisplayColors(ChoiceList):
+    verbose_name = _("Display color")
+    verbose_name_plural = _("Display colors")
+    item_class = DisplayColor
+    required_roles = login_required(Explorer)
+
+
+add = DisplayColors.add_item
+# cssColors = 'White Silver Gray Black Red Maroon Yellow Olive Lime Green Aqua Teal Blue Navy Fuchsia Purple'
+# cssColors = 'white silver gray black red maroon yellow olive lime green aqua teal blue navy fuchsia purple'
+# for color in cssColors.split():
+#     add(color, _(color), color, font_color="white")
+#
+# lightColors = 'White Silver Gray'
+# # lightColors = 'white silver gray'
+# for color in lightColors.split():
+#     DisplayColors.get_by_value(color).font_color = "black"
+
+# B&W
+add("100",   _("White"), "white",  "black")
+add("110",    _("Gray"), "gray",   "black")
+add("120",   _("Black"), "black",  "white")
+
+# Rainbow colors
+add("210",     _("Red"), "red",    "white")
+add("220",  _("Orange"), "orange", "white")
+add("230",  _("Yellow"), "yellow", "black")
+add("240",   _("Green"), "green",  "white")
+add("250",    _("Blue"), "blue",   "white")
+add("260", _("Magenta"), "magenta","white")
+add("270",  _("Violet"), "violet", "white")
+
+# Other colors
+add("300",  _("Silver"), "silver", "black")
+add("310",  _("Maroon"), "maroon", "white")
+add("311",    _("Peru"), "peru",   "white")
+add("320",   _("Olive"), "olive",  "white")
+add("330",    _("Aqua"), "aqua",   "white")
+add("340",    _("Navy"), "navy",   "white")
+add("350", _("Fuchsia"), "fuchsia","white")
+add("351",  _("Purple"), "purple", "white")
+
+# List of all named colors: https://www.w3schools.com/colors/colors_names.asp

lino/modlib/system/models.py

@@ -33,6 +33,7 @@ from .choicelists import (
     DurationUnits,
     Recurrences,
     Weekdays,
+    DisplayColors
 )
 from .mixins import Lockable
 

lino/modlib/users/models.py

@@ -99,7 +99,7 @@ class User(AbstractBaseUser, Contactable, CreatedModified, Publishable, DateRang
     user_type = UserTypes.field(blank=True)
     initials = models.CharField(_("Initials"), max_length=10, blank=True)
     if dd.plugins.users.with_nickname:
-        nickname = models.CharField(_("Nickname"), max_length=20, blank=True)
+        nickname = models.CharField(_("Nickname"), max_length=50, blank=True)
     else:
         nickname = dd.DummyField()
     first_name = models.CharField(_("First name"), max_length=30, blank=True)
@@ -144,7 +144,7 @@ class User(AbstractBaseUser, Contactable, CreatedModified, Publishable, DateRang
         my_settings = MySettings()
 
     def __str__(self):
-        return self.nickname if self.nickname else self.get_full_name()
+        return self.nickname or self.get_full_name()
 
     @property
     def is_active(self):

lino/modlib/weasyprint/__init__.py

@@ -29,6 +29,8 @@ class Plugin(ad.Plugin):
 
     verbose_name = _("WeasyPrint")
 
+    needs_plugins = ["lino.modlib.jinja"]
+
     header_height = 20
     """Height of header in mm. Set to `None` if you want no header."""
 

lino/utils/__init__.py

@@ -67,7 +67,7 @@ from urllib.parse import urlencode
 # import locale
 import dateparser
 from io import StringIO
-import contextlib
+from contextlib import redirect_stdout, contextmanager
 from pathlib import Path
 
 from etgen.utils import join_elems
@@ -77,13 +77,6 @@ from lino.utils.code import codefiles, codetime
 
 from rstgen.utils import confirm, i2d, i2t
 
-try:
-    import lino_book
-    DEMO_DATA = Path(lino_book.__file__).parent.parent.absolute() / 'demo_data'
-    """The root directory with demo data included in the Developer Guide."""
-except ImportError:
-    DEMO_DATA = None
-
 DATE_TO_DIR_TPL = "%Y/%m"
 
 def read_exception(excinfo):
@@ -366,6 +359,12 @@ curry = lambda func, *args, **kw: lambda *p, **n: func(
     *args + p, **dict(list(kw.items()) + list(n.items()))
 )
 
+def capture_output(func, *args, **kwargs):
+    s = StringIO()
+    with redirect_stdout(s):
+        func(*args, **kwargs)
+    return s.getvalue()
+
 
 class IncompleteDate(object):
     """Naive representation of a potentially incomplete gregorian date.
@@ -694,7 +693,7 @@ class MissingRow:
         return "MissingRow({!r})".format(self.message)
 
 
-@contextlib.contextmanager
+@contextmanager
 def logging_disabled(level):
     try:
         logging.disable(level)

lino/utils/djangotest.py

@@ -20,6 +20,7 @@ from django.db import connection, reset_queries, connections, DEFAULT_DB_ALIAS
 from django.utils import translation
 
 from lino.utils import AttrDict
+from lino.api import rt
 from lino.core.signals import testcase_setup  # , database_ready
 from lino.core.callbacks import applyCallbackChoice
 from .test import CommonTestCase
@@ -112,7 +113,7 @@ class DjangoManageTestCase(DjangoTestCase, CommonTestCase):
         the response's content (which is expected to contain a dict), convert
         this dict to an AttrDict before returning it.
         """
-        ar = settings.SITE.login(username)
+        ar = rt.login(username)
         self.client.force_login(ar.user)
         extra[settings.SITE.remote_user_header] = username
         # extra.update(REMOTE_USER=username)

lino/utils/html.py

@@ -14,6 +14,7 @@ from html2text import HTML2Text
 from django.utils.html import SafeString, mark_safe, escape
 # from lino.utils import tostring
 
+SAFE_EMPTY = mark_safe("")
 
 def html2text(html, **kwargs):
     """
@@ -69,3 +70,33 @@ def assert_safe(s):
     if not isinstance(s, SafeString):
         raise Exception("%r is not a safe string" % s)
     # assert isinstance(s, SafeString)
+
+
+class Grouper:
+
+    def __init__(self, ar):
+        self.ar = ar
+        if ar.actor.group_by is None: return
+        self.last_values = [None for f in ar.actor.group_by]
+
+    def begin(self):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        return SAFE_EMPTY
+
+    def stop(self):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        return SAFE_EMPTY
+
+    def before_row(self, obj):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        self.current_values = [f(obj) for f in self.ar.actor.group_by]
+        if self.current_values == self.last_values:
+            return SAFE_EMPTY
+        return self.ar.actor.before_group_change(self, obj)
+
+    def after_row(self, obj):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        if self.current_values == self.last_values:
+            return SAFE_EMPTY
+        self.last_values = self.current_values
+        return self.ar.actor.after_group_change(self, obj)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lino
-Version: 24.10.3
+Version: 24.11.0
 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