lino 25.2.1__py3-none-any.whl → 25.2.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__ = '25.2.1'
+__version__ = '25.2.3'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 
@@ -64,14 +64,19 @@ import warnings
 
 warnings.filterwarnings(
     "error",
-    "DateTimeField .* received a naive datetime (.*) while time zone support is active.",
+    r"DateTimeField .* received a naive datetime (.*) while time zone support is active.",
     RuntimeWarning,
     "django.db.models.fields",
 )
 
+# TODO: Is it okay to ignore the followgin warning? It's because e.g.
+# lino.modlib.excerpts has a pre_analyze receiver set_excerpts_actions(), which
+# accesses the database to set actions before Lino analyzes the models. It
+# catches OperationalError & Co because --of course-- it fails e.g. for
+# admin-commands like "pm prep".
 warnings.filterwarnings(
     "ignore",
-    "Accessing the database during app initialization is discouraged\. To fix this warning, avoid executing queries in AppConfig\.ready\(\) or when your app modules are imported\.",
+    r"Accessing the database during app initialization is discouraged\. To fix this warning, avoid executing queries in AppConfig\.ready\(\) or when your app modules are imported\.",
     RuntimeWarning,
     "django.db.backends.utils",
 )

lino/api/dd.py

@@ -209,6 +209,19 @@ from lino.modlib.linod.choicelists import Procedures
 
 
 def background_task(**kwargs):
+    """
+    Register the decorated function as a :term:`background task`.
+
+    Keyword arguments are used as default values when checkdata creates a
+    :class:`lino.modlib.linod.SystemTask` instance for this procedure.
+
+    Except for the special keyword ``class_name``, which defaults to
+    "linod.SystemTask". It is used by :mod:`lino_xl.lib.invoicing` to register a
+    procedure that will create an :term:`invoicing task` instead of a normal
+    :term:`background task`. :class:`lino_xl.lib.invoicing.InvoicingTask`
+    instead of :class:`lino.modlib.linod.SystemTask`.
+
+    """
     if "class_name" not in kwargs:
         kwargs["class_name"] = "linod.SystemTask"
 

lino/api/doctest.py

@@ -1,28 +1,45 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2015-2024 Rumma & Ko Ltd
+# Copyright 2015-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """
-A selection of names to be used in tested documents.
+A selection of names to be used in tested documents as follows:
+
+>>> from lino.api.doctest import *
+
+This is by convention everything we want to have in the global namespace of a
+tested document. It includes
+
+- well-known Python standard modules like os, sys, datetime and collections.
+- A variable :data:`test_client`
+
 """
 
+import os
+import sys
+import datetime
+import collections
 import six  # TODO: remove here and then run all doctests
 import logging
 import sqlparse
+import json
+import textwrap
+
+from bs4 import BeautifulSoup
+from pprint import pprint, pformat
 from urllib.parse import urlencode
+
 import django
 django.setup()
+
 from lino.core.constants import *
 from lino.api.shell import *
 from django.utils import translation
 from django.utils.encoding import force_str
 from django.test import Client
 from django.db import connection, reset_queries as reset_sql_queries
-import json
-from bs4 import BeautifulSoup
-import textwrap
-from pprint import pprint, pformat
 
-from rstgen import table, ul
+import pytest
+# from rstgen import table, ul
 import rstgen
 from rstgen import attrtable
 from rstgen.utils import unindent, rmu, sixprint
@@ -49,10 +66,12 @@ from lino.core.actions import register_params
 from lino.core.layouts import BaseLayout
 
 test_client = Client()
-# naming it simply "client" caused conflict with a
-# `lino_welfare.pcsw.models.Client`
+"""An instance of :class:`django.test.Client`.
 
-import collections
+N.B. Naming it simply "client" caused conflict with a
+:class:`lino_welfare.pcsw.models.Client`
+
+"""
 
 HttpQuery = collections.namedtuple(
     "HttpQuery", ["username", "url_base", "json_fields", "expected_rows", "kwargs"]
@@ -293,7 +312,7 @@ def show_workflow(actions, all=False, language=None):
                         # required_roles
                     ]
                 )
-        print(table(cols, cells).strip())
+        print(rstgen.table(cols, cells).strip())
 
     if language:
         with translation.override(language):
@@ -363,7 +382,7 @@ def fields_help(model, fieldnames=None, columns=False, all=None):
 
     # return table(cols, cells).strip()
     items = ["{} ({}) : {}".format(row[1], row[0], row[2]) for row in cells]
-    return ul(items).strip()
+    return rstgen.ul(items).strip()
 
 
 def show_fields(*args, **kwargs):
@@ -552,7 +571,7 @@ def show_choicelist(cls):
     for i in cls.get_list_items():
         row = [i.value, i.name] + str2languages(i.text)
         rows.append(row)
-    print(table(headers, rows))
+    print(rstgen.table(headers, rows))
 
 
 def show_choicelists():
@@ -568,7 +587,7 @@ def show_choicelists():
             i.verbose_name_plural
         )
         rows.append(row)
-    print(table(headers, rows))
+    print(rstgen.table(headers, rows))
 
 
 def show_permissions(*args):
@@ -590,7 +609,7 @@ def show_translations(things, fmt, languages=None):
                 x, txt = fmt(thing)
                 cells.append(txt)
         rows.append(cells)
-    print(table(headers, rows))
+    print(rstgen.table(headers, rows))
 
 
 def show_model_translations(*models, **kwargs):
@@ -779,7 +798,7 @@ def show_change_watchers():
             rows.append(
                 [full_model_name(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
             )
-    print(table(headers, rows, max_width=40))
+    print(rstgen.table(headers, rows, max_width=40))
 
 def show_display_modes():
     """
@@ -796,4 +815,17 @@ def show_display_modes():
                     ("x" if dm in a.extra_display_modes else "")
                         for dm in dml]
             )
-    print(table(headers, rows))
+    print(rstgen.table(headers, rows))
+
+
+def checkdb(m, num):
+    """
+    Raise an exception if the database doesn't contain the specified number of
+    rows of the specified model.
+
+    This is for usage in :xfile:`startup.py` scripts.
+
+    """
+    if m.objects.count() != num:
+        raise Exception(
+            f"Model {m} should have {num} rows but has {m.objects.count()}")

lino/api/selenium.py

@@ -115,7 +115,7 @@ class Tour(object):
     error_message = None
     language = None
     languages = []
-    server_url = "http://127.0.0.1:8000/"
+    server_url = "http://127.0.0.1:8000"
     images_width = 90
 
     def __init__(

lino/core/actors.py

@@ -1948,17 +1948,26 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         return html
 
     @classmethod
-    def get_table_summary(cls, obj, ar=None):
+    def get_slave_summary(cls, obj, ar=None):
+        """
+        :param cls: Slave table
+        :param obj: Master instance
+        :param ar: Action request on master table
+        """
+        if ar is None:
+            return ''
+        sar = cls.request(parent=ar, master_instance=obj, is_on_main_actor=False)
+        return cls.get_table_summary(sar)
+
+    @classmethod
+    def get_table_summary(cls, ar):
         """
         Return the HTML `<div>` to be displayed by
         :class:`lino.core.elems.TableSummaryPanel`.
         It basically just calls :meth:`table_as_summary`.
 
         """
-        if ar is None:
-            return ''
-        sar = cls.request(parent=ar, master_instance=obj, is_on_main_actor=False)
-        p = cls.table_as_summary(sar)
+        p = cls.table_as_summary(ar)
         # assert_safe(p)  # temporary 20240506
         # print("20240712", p)
         # return format_html(DIVTPL, p)
@@ -1981,9 +1990,9 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         """
         p = qs2summary(
             ar,
-            ar.data_iterator,
+            ar.sliced_data_iterator,
             separator=cls.summary_sep,
-            max_items=cls.preview_limit,
+            max_items=ar.limit or cls.preview_limit,
             wraptpl=None,
         )
         # assert isinstance(p, str)

lino/core/boundaction.py

@@ -184,4 +184,4 @@ class BoundAction(object):
         return "<%s(%s, %r)>" % (self.__class__.__name__, self.actor, self.action)
 
     def __str__(self):
-        return "{} on {}".format(self.action, self.actor)
+        return f"{self.action.__class__.__name__} on {self.actor}"

lino/core/choicelists.py

@@ -823,7 +823,7 @@ class ChoiceList(with_metaclass(ChoiceListMeta, tables.AbstractTable)):
     @classmethod
     def filter(self, **fkw):
         def f(item):
-            for k, v in list(fkw.items()):
+            for k, v in fkw.items():
                 if getattr(item, k) != v:
                     return False
             return True

lino/core/dbtables.py

@@ -315,22 +315,22 @@ class Table(AbstractTable):
         # qs = self.model.get_request_queryset(ar)
         # str(qs.query)
 
-        # return qs.get(pk=pk)
-        try:
+        if not settings.SITE.catch_layout_exceptions:
             return qs.get(pk=pk)
-        # except ValueError:
-        #     return None
-        except self.model.DoesNotExist:
-            # sql = qs.query
-            # import sqlparse
-            # sql = str(sql).replace('"', '')
-            # sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
-            # raise self.model.DoesNotExist(f"No row {pk} in {ar} ({sql})")
-            raise self.model.DoesNotExist(f"No row {pk} in {ar}") from None
-            # from django.core.exceptions import ObjectDoesNotExist
-            # assert isinstance(exc, ObjectDoesNotExist)
-            # raise exc
-            # return None
+        else:
+            try:
+                return qs.get(pk=pk)
+            except self.model.DoesNotExist:
+                # sql = qs.query
+                # import sqlparse
+                # sql = str(sql).replace('"', '')
+                # sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
+                # raise self.model.DoesNotExist(f"No row {pk} in {ar} ({sql})")
+                raise self.model.DoesNotExist(f"No row {pk} in {ar}") from None
+                # from django.core.exceptions import ObjectDoesNotExist
+                # assert isinstance(exc, ObjectDoesNotExist)
+                # raise exc
+                # return None
 
     # @classmethod
     # def disabled_actions(self, ar, obj):  # no longer used since 20170909

lino/core/elems.py

@@ -1830,7 +1830,7 @@ class SlaveSummaryPanel(LightWeightContainer):
     oui5_field_template = "openui5/elems/field/SlaveSummaryElement.xml"
 
     def __init__(self, lh, slave, name, **kw):
-        super().__init__(lh, slave, name, slave.get_table_summary, **kw)
+        super().__init__(lh, slave, name, slave.get_slave_summary, **kw)
 
 
 class StoryElement(LightWeightContainer):

lino/core/renderer.py

@@ -284,7 +284,7 @@ class HtmlRenderer(Renderer):
                 raise Exception("Both nosummary and display_mode were specified")
 
         if display_mode == constants.DISPLAY_MODE_SUMMARY:
-            yield ar.actor.get_table_summary(ar.master_instance, ar)
+            yield ar.actor.get_table_summary(ar)
             return
 
         if header_level is not None:
@@ -834,7 +834,7 @@ class TextRenderer(HtmlRenderer):
         # yield "20240506 {}".format(ar)
         if display_mode == constants.DISPLAY_MODE_SUMMARY:
             s = to_rst(
-                ar.actor.get_table_summary(ar.master_instance, ar),
+                ar.actor.get_table_summary(ar),
                 stripped=stripped,
             )
             if stripped:

lino/core/requests.py

@@ -24,6 +24,7 @@ from django.conf import settings
 from django.utils.translation import gettext_lazy as _
 from django.utils.translation import gettext
 from django.utils.translation import get_language, activate
+from django.utils.html import format_html
 from django.utils import translation
 from django.utils import timezone
 from django.core.mail import send_mail
@@ -103,6 +104,16 @@ def mi2bp(master_instance, bp):
             #     self.master_instance.__class__, self.master_instance))
 
 
+class PrintLogger(logging.Logger):
+    format = "%(message)s"
+
+    def __init__(self, level):
+        super().__init__("~", level)
+        h = logging.StreamHandler(stream=sys.stdout)
+        h.setFormatter(logging.Formatter(self.format))
+        self.addHandler(h)
+        # print("20231012", logging.getLevelName(self.level), self.__class__)
+
 class StringLogger(logging.Logger):
     # Instantiated by BaseRequest.capture_logger()
 
@@ -535,12 +546,26 @@ class BaseRequest:
         try:
             # We instantiate a temporary Logger object, which is not known by the
             # root logger.
+            # self.logger = PrintLogger(level)
             self.logger = StringLogger(old_logger, level)
             # self.logger.parent =
             yield self.logger
 
         finally:
             self.logger.streamer.flush()
+            # print(self.logger.getvalue())
+            self.logger = old_logger
+
+    @contextmanager
+    def print_logger(self, level=logging.INFO):
+        old_logger = self.logger
+        try:
+            # We instantiate a temporary Logger object, which is not known by the
+            # root logger.
+            self.logger = PrintLogger(level)
+            yield None
+
+        finally:
             self.logger = old_logger
 
     @contextmanager
@@ -820,22 +845,29 @@ class BaseRequest:
         Given a tuple of primary keys, set :attr:`selected_rows` to a list
         of corresponding database objects.
 
-        The special pks's -99998  and -99999 are filtered out.
+        TODO: Explain why the special primary keys -99998 and -99999 are
+        filtered out.
 
         """
         # ~ print 20131003, selected_pks
         self.selected_rows = []
-        # for pk in selected_pks:
-        #     if pk and pk != "-99998" and pk != "-99999":
-        #         self.selected_rows.append(self.get_row_by_pk(pk))
-        try:
+
+        # Until 20250212 we catched for ObjectDoesNotExist here in order to
+        # reformulate the message. This made #5924 (Menu "My invoicing plan"
+        # fails) difficult to diagnose.
+        if True:
             for pk in selected_pks:
                 if pk and pk != "-99998" and pk != "-99999":
                     self.selected_rows.append(self.get_row_by_pk(pk))
-        except ObjectDoesNotExist:
-            # raise exceptions.BadRequest(
-            raise ObjectDoesNotExist(
-                f"No row with primary key {pk} in {self.actor}") from None
+        else:
+            try:
+                for pk in selected_pks:
+                    if pk and pk != "-99998" and pk != "-99999":
+                        self.selected_rows.append(self.get_row_by_pk(pk))
+            except ObjectDoesNotExist:
+                # raise exceptions.BadRequest(
+                raise ObjectDoesNotExist(
+                    f"No row with primary key {repr(pk)} in {self.actor}") from None
         # self.selected_rows = filter(lambda x: x, self.selected_rows)
         # note: ticket #523 was because the GET contained an empty pk ("&sr=")
 
@@ -1631,7 +1663,8 @@ class BaseRequest:
             # print("20190703", self.actor, self.actor.default_action)
             sar = self.spawn_request(actor=self.actor)
             list_title = tostring(sar.href_to_request(sar, list_title, icon_name=None))
-            return list_title + " » " + self.get_detail_title(elem)
+            # return list_title + " » " + self.get_detail_title(elem)
+            return format_html("{} » {}", list_title,  self.get_detail_title(elem))
 
     def form2obj_and_save(ar, data, elem, is_new):
         """
@@ -1885,10 +1918,13 @@ class ActionRequest(BaseRequest):
             self.set_selected_pks(*selected_pks)
 
     def __str__(self):
-        return "{0} {1}".format(self.__class__.__name__, self.bound_action)
+        return f"{self.__class__.__name__} for {self.bound_action}"
 
-    def __repr__(self):
-        return "{0} {1}".format(self.__class__.__name__, self.bound_action)
+    # def __str__(self):
+    #     return "{0} {1}".format(self.__class__.__name__, self.bound_action)
+    #
+    # def __repr__(self):
+    #     return "{0} {1}".format(self.__class__.__name__, self.bound_action)
 
     def gen_insert_button(
         self, target=None, button_attrs=dict(style="float: right;"), **values

lino/core/site.py

@@ -356,7 +356,7 @@ class Site(object):
     verbose_client_info_message = False
 
     stopsignal = "SIGTERM"
-    help_url = "http://www.lino-framework.org"
+    help_url = "https://www.lino-framework.org"
 
     help_email = "users@lino-framework.org"
 
@@ -395,11 +395,11 @@ class Site(object):
 
     date_format_strftime = "%d.%m.%Y"
 
-    date_format_regex = "/^[0123]?\d\.[01]?\d\.-?\d+$/"
+    date_format_regex = r"/^[0123]?\d\.[01]?\d\.-?\d+$/"
 
     datetime_format_strftime = "%Y-%m-%dT%H:%M:%S"
 
-    datetime_format_extjs = "Y-m-d\TH:i:s"
+    datetime_format_extjs = r"Y-m-d\TH:i:s"
 
     quick_startup = False
 
@@ -973,6 +973,7 @@ class Site(object):
 
     def install_settings(self):
         assert not self.help_url.endswith("/")
+        assert not self.server_url.endswith("/")
 
         for p in self.installed_plugins:
             p.install_django_settings(self)
@@ -2136,13 +2137,12 @@ class Site(object):
 
         # yield "lino.modlib.lino_startup"
 
-    # server_url = None
     copyright_name = None
     """Name of copyright holder of the site's content."""
 
     copyright_url = None
 
-    server_url = "http://127.0.0.1:8000/"
+    server_url = "http://127.0.0.1:8000"
     """The "official" URL used by "normal" users when accessing this Lino
     site.
 

lino/help_texts.py

@@ -374,13 +374,14 @@ help_texts = {
     'lino.modlib.linod.Procedures' : _("""The choicelist of background procedures available in this application."""),
     'lino.modlib.linod.LogLevels' : _("""A choicelist of logging levels available in this application."""),
     'lino.modlib.linod.SystemTask' : _("""Django model used to represent a background task."""),
-    'lino.modlib.linod.SystemTask.procedure' : _("""Pointer to an instance of Procedure."""),
     'lino.modlib.linod.SystemTask.start_datetime' : _("""Tells at what time exactly this job started."""),
     'lino.modlib.linod.SystemTask.message' : _("""Stores information about the job, mostly logs."""),
     'lino.modlib.linod.SystemTask.disabled' : _("""Tells whether the task should be ignored."""),
     '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.linod.Runnable' : _("""Model mixin used by SystemTask and other models."""),
+    'lino.modlib.linod.Runnable.procedure' : _("""The background procedure to run in this task."""),
     'lino.modlib.periods.StoredYear' : _("""The Django model used to store a fiscal year."""),
     'lino.modlib.periods.StoredPeriod' : _("""The Django model used to store an accounting period."""),
     'lino.modlib.periods.StoredYears' : _("""The fiscal years defined in this database."""),
@@ -511,14 +512,14 @@ help_texts = {
     'lino.modlib.comments.AllComments' : _("""Show all comments."""),
     'lino.modlib.comments.MyComments' : _("""Show the comments posted by the current user."""),
     'lino.modlib.comments.RecentComments' : _("""Show the most recent comments that have been posted on this site."""),
-    'lino.modlib.comments.CommentsByRFC' : _("""Shows the comments for a given database object."""),
+    'lino.modlib.comments.CommentsByRFC' : _("""Shows the comments about a given database row."""),
     'lino.modlib.comments.CommentEvents' : _("""The choicelist with selections for Comments.observed_event."""),
     'lino.modlib.comments.Emotions' : _("""The list of available values for the Comment.emotion field."""),
     'lino.modlib.comments.CommentType' : _("""The CommentType model is not being used in production, one day we will probably remove it."""),
     'lino.modlib.comments.CommentTypes' : _("""The table with all existing comment types."""),
     'lino.modlib.comments.Commentable' : _("""Mixin for models that are commentable, i.e. the rows of which can become discussion topic of comments."""),
     'lino.modlib.comments.Commentable.add_comments_filter' : _("""Add filters to the given queryset of comments, requested by the given user."""),
-    'lino.modlib.comments.Commentable.get_rfc_description' : _("""Return a HTML formatted string with the description of this Commentable as it should be displayed by the slave summary of CommentsByOwner."""),
+    'lino.modlib.comments.Commentable.get_rfc_description' : _("""Return a HTML formatted string with the description of this Commentable as it should be displayed by the slave summary of CommentsByRFC."""),
     'lino.modlib.comments.Commentable.on_commented' : _("""This is automatically called when a comment has been created or modified."""),
     'lino.modlib.files.Volume' : _("""The Django model representing a file volume."""),
     'lino.modlib.files.Volume.id' : _("""The primary key used to point to this volume from a database object."""),
@@ -552,6 +553,10 @@ help_texts = {
     'lino.modlib.gkfs.GenericForeignKey' : _("""Add verbose_name and help_text to Django’s GFK."""),
     'lino.modlib.gkfs.GenericForeignKeyIdField' : _("""Use this instead of models.PositiveIntegerField for fields that are part of a GFK and you want Lino to render them using a Combobox."""),
     'lino.modlib.jinja.JinjaBuildMethod' : _("""Inherits from lino.modlib.printing.DjangoBuildMethod."""),
+    'lino.modlib.jinja.XMLMaker' : _("""Usage example in /topics/xml"""),
+    'lino.modlib.jinja.XMLMaker.xml_file_name' : _("""The name of the XML file to generate. This file will be overwritten without asking. The name formatted with one name self in the context."""),
+    'lino.modlib.jinja.XMLMaker.xml_file_template' : _("""The name of a Jinja template to render for generating the XML content."""),
+    'lino.modlib.jinja.XMLMaker.xml_validator_file' : _("""The name of a “validator” to use for validating the XML content."""),
     'lino.modlib.memo.Previewable' : _("""Adds three rich text fields (lino.core.fields.RichTextField):"""),
     'lino.modlib.memo.Previewable.body' : _("""An editable text body."""),
     'lino.modlib.memo.Previewable.body_short_preview' : _("""A read-only preview of the first paragraph of body."""),

lino/modlib/comments/models.py

@@ -290,7 +290,7 @@ class Comment(
     def full_clean(self):
         super().full_clean()
         if self.reply_to_id and not self.owner_id:
-            # added only 2023-11-19
+            # added only 2023-11-19, that's why we have CommentChecker
             self.owner = self.reply_to.owner
         # self.owner.setup_comment(self)
 

lino/modlib/comments/ui.py

@@ -206,7 +206,7 @@ class CommentsByType(CommentsByX):
     master_key = "comment_type"
     column_names = "body created user *"
 
-
+# TODO: rename CommentsByRFC to CommentsByOwner
 class CommentsByRFC(CommentsByX):
     master_key = "owner"
     details_of_master_template = _("%(details)s about %(master)s")

lino/modlib/extjs/__init__.py

@@ -250,12 +250,12 @@ class Plugin(Plugin):
             ),
             url(
                 rx + r"choices/(?P<app_label>\w+)/(?P<rptname>\w+)/"
-                "(?P<fldname>\w+)$",
+                r"(?P<fldname>\w+)$",
                 views.Choices.as_view(),
             ),
             url(
                 rx + r"apchoices/(?P<app_label>\w+)/(?P<actor>\w+)/"
-                "(?P<an>\w+)/(?P<field>\w+)$",
+                r"(?P<an>\w+)/(?P<field>\w+)$",
                 views.ActionParamChoices.as_view(),
             ),
             # the thread_id can be a negative number: