lino 25.4.4__tar.gz → 25.5.0__tar.gz

{lino-25.4.4 → lino-25.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lino
-Version: 25.4.4
+Version: 25.5.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

{lino-25.4.4 → lino-25.5.0}/lino/__init__.py

@@ -31,7 +31,7 @@ from django import VERSION
 from django.apps import AppConfig
 from django.conf import settings
 import warnings
-__version__ = '25.4.4'
+__version__ = '25.5.0'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

{lino-25.4.4 → lino-25.5.0}/lino/api/doctest.py

@@ -524,6 +524,20 @@ def show_choicelists():
     print(rstgen.table(headers, rows))
 
 
+def show_parent_layouts():
+    """
+    Show all actors having a parent layout.
+    """
+    headers = ["name", "parent layout"]
+    rows = []
+    for a in actors.actors_list:
+        if issubclass(a, AbstractTable) and a.parent_layout:
+            parent = a.parent_layout._datasource
+            row = [str(a), str(parent)]  # , parent.__module__]
+            rows.append(row)
+    print(rstgen.table(headers, rows))
+
+
 def show_permissions(*args):
     print(visible_for(*args))
 

{lino-25.4.4 → lino-25.5.0}/lino/core/elems.py

@@ -5,8 +5,6 @@
 
 """
 
-from lino.utils.jsgen import VisibleComponent
-import types
 import decimal
 from lxml.html import fromstring
 from lxml import etree
@@ -15,7 +13,7 @@ from django.db import models
 from django.utils.translation import gettext as _
 from django.utils.functional import Promise
 from django.utils.text import format_lazy
-from django.utils.html import SafeString, escape
+from django.utils.html import SafeString
 from django.conf import settings
 from django.db.models.fields.related import (
     ReverseOneToOneDescriptor as SingleRelatedObjectDescriptor,
@@ -40,16 +38,15 @@ from lino.core.gfks import GenericRelation, GenericRel
 from lino.core import choicelists
 from lino.modlib.bootstrap3.views import table2html
 
-from lino.utils.html import E, py2html, tostring
-from lino.utils.html import html2text
+from lino.utils.jsgen import VisibleComponent
+from lino.utils.html import E, tostring, forcetext, html2text
 from lino.utils.ranges import constrain
 from lino.utils import jsgen
 from lino.utils import mti
 from lino.utils.jsgen import py2js, js_code
-from lino.utils.html2xhtml import html2xhtml
+# from lino.utils.html2xhtml import html2xhtml
 from lino.utils import join_elems
 from lino.core.actors import qs2summary
-from lino.core.store import get_atomizer
 
 from lino.core.layouts import (
     FormLayout,
@@ -66,7 +63,6 @@ from lino.utils.format_date import fds
 from lino.modlib.users.utils import get_user_profile
 
 # from etgen import etree
-from lino.utils.html import E, forcetext
 from etgen.html2rst import html2rst
 
 EXT_CHAR_WIDTH = 9
@@ -2756,6 +2752,7 @@ def get_summary_element(lh, de, name, **kw):
 def create_layout_element(lh, name, **kw):
     """
     Create a layout element from the named data element.
+    `lh` is the layout handle of the actor who is the datasource of the data element.
     """
 
     if True:  # settings.SITE.catch_layout_exceptions:
@@ -2850,6 +2847,8 @@ def create_layout_element(lh, name, **kw):
         # The data element refers to a slave table. Slave tables make
         # no sense in an insert window because the master does not yet
         # exist.
+        de.attach_to_parent_layout(lh.layout)
+
         if settings.SITE.is_hidden_plugin(de.app_label):
             return None
 
@@ -2858,8 +2857,8 @@ def create_layout_element(lh, name, **kw):
 
         # print("20240317", de, lh)
         if isinstance(lh.layout, FormLayout):
-            # When a table is specified in the layout of a DetailWindow, then it
-            # will be rendered as a :term:`slave panel`. The panel will have a
+            # When a table is specified in the layout of a detail window, then it
+            # is rendered as a :term:`slave panel`. The panel will have a
             # tool button to "open that table in its own window". The display
             # mode of that summary is defined by the `default_display_modes` of
             # the table.
@@ -2884,7 +2883,7 @@ def create_layout_element(lh, name, **kw):
 
             if (
                 len(de.default_display_modes) > 1
-                and lh.ui.renderer.front_end.media_name == "react"
+                and lh.ui.media_name == "react"
             ):
                 # print(f"20240928 {de} in {lh} gets SlaveContainer")
                 return SlaveContainer(lh, name, de, **kw)

{lino-25.4.4 → lino-25.5.0}/lino/core/fields.py

@@ -163,13 +163,21 @@ class PriceField(models.DecimalField):
     """
     A thin wrapper around Django's `DecimalField
     <https://docs.djangoproject.com/en/5.0/ref/models/fields/#decimalfield>`_
-    which adds default values for `decimal_places`, `max_length` and
+    with price-like default values for `decimal_places`, `max_length` and
     `max_digits`.
     """
 
+    # def __init__(self, verbose_name=None, max_digits=10, **kwargs):
+    #     defaults = dict(
+    #         max_length=max_digits,
+    #         max_digits=max_digits,
+    #         decimal_places=2,
+    #     )
+    #     defaults.update(kwargs)
+    #     super().__init__(verbose_name, **defaults)
+
     def __init__(self, verbose_name=None, max_digits=10, **kwargs):
         defaults = dict(
-            max_length=max_digits,
             max_digits=max_digits,
             decimal_places=2,
         )
@@ -656,8 +664,10 @@ class VirtualField(FakeField):
         self.model = model
         self.name = name
         self.attname = name
+        # if getattr(self.return_type, "model", False):
         if hasattr(self.return_type, "model"):
-            # logger.info("20200425 return_type for virtual field %s has a model", self)
+            # logger.info("20200425 return_type for virtual "
+            #     "field %s has a model %s (not %s)", self, self.return_type.model, model)
             return
         self.return_type.model = VirtualModel(model)
         self.return_type.column = None
@@ -945,7 +955,7 @@ class QuantityField(models.CharField):
     """
 
     description = _("Quantity (Decimal or Duration)")
-    overflow_value = None
+    # overflow_value = None
 
     def __init__(self, *args, **kw):
         kw.setdefault("max_length", settings.SITE.quantity_max_length)
@@ -972,16 +982,18 @@ class QuantityField(models.CharField):
         I'd add "Any value allowed for this field when instantiating a model."
 
         """
-        if value:
+        if isinstance(value, quantities.Quantity):
+            return value
+        elif isinstance(value, Decimal):
+            return quantities.Quantity(value)
+        elif isinstance(value, str):
+            return quantities.parse(value)
+        elif value:
             # try:
-            if isinstance(value, str):
-                return quantities.parse(value)
             return quantities.Quantity(value)
             # except Exception as e:
             #     raise ValidationError(
             #         "Invalid value {} for {} : {}".format(value, self, e))
-        elif isinstance(value, Decimal):
-            return quantities.Quantity(value)
         return None
 
     def from_db_value(self, value, expression, connection, context=None):
@@ -999,14 +1011,18 @@ class QuantityField(models.CharField):
         return str(value)  # if value is None else ''
 
     def clean(self, raw_value, obj):
-        if len(str(raw_value)) > self.max_length:
-            if self.overflow_value:
-                return self.overflow_value
-            raise ValidationError(
-                f"Cannot accept quantity {raw_value} "
-                + f"because max_length is {self.max_length}")
-            # print("20230129 Can't store {}={} in {}".format(self.name, raw_value, obj))
-            # return -1
+        # if isinstance(raw_value, quantities.Quantity):
+        raw_value = self.to_python(raw_value)
+        if raw_value is not None:
+            raw_value = raw_value.limit_length(self.max_length, ValidationError)
+        # if len(str(raw_value)) > self.max_length:
+        #     if self.overflow_value:
+        #         return self.overflow_value
+        #     raise ValidationError(
+        #         f"Cannot accept quantity {raw_value} "
+        #         + f"because max_length is {self.max_length}")
+        #     # print("20230129 Can't store {}={} in {}".format(self.name, raw_value, obj))
+        #     # return -1
         return super().clean(raw_value, obj)
 
 
@@ -1324,6 +1340,14 @@ class TableRow(object):
     def disable_create(self, ar):
         return None
 
+    def before_ui_save(self, ar, cw):
+        # Needed for polls.AnswerRemarkField
+        pass
+
+    def get_master_data(self, ar, master_instance=None):
+        # Needed for polls.AnswerRemarkField
+        return
+
     def get_detail_action(self, ar):
         """
         Return the (bound) detail action to use for showing this database row in

{lino-25.4.4 → lino-25.5.0}/lino/core/kernel.py

@@ -37,6 +37,7 @@ from django.utils.translation import gettext_lazy as _
 from django.core.exceptions import PermissionDenied, ValidationError
 from django.db.utils import DatabaseError
 from django.db import IntegrityError
+from django.utils.log import DEFAULT_LOGGING
 
 from django.db import models
 
@@ -162,7 +163,9 @@ class Kernel(object):
         # logger.info("20231016 kernel_startup (%s)", site._history_aware_logging)
         # print("20231019 kernel_startup()", site, site._history_aware_logging)
 
-        if site._history_aware_logging:
+        # if site._history_aware_logging:
+        # if not is_devserver():
+        if "file" in DEFAULT_LOGGING['handlers']:
             if len(sys.argv) == 0:
                 process_name = "WSGI"
             else:

{lino-25.4.4 → lino-25.5.0}/lino/core/layouts.py

@@ -99,7 +99,7 @@ class LayoutHandle(object):
         assert isinstance(layout, BaseLayout)
         assert isinstance(ui, Plugin)
         self.layout = layout
-        self.ui = ui
+        self.ui = ui  # TODO: rename ui to front_end
         self.hidden_elements = layout.hidden_elements
         self._data_elems = []
         self._names = {}
@@ -299,7 +299,7 @@ class LayoutHandle(object):
             else:
                 e.hidden = True
 
-        self.ui.setup_layout_element(e)
+        # self.ui.setup_layout_element(e)
         self.layout.setup_element(self, e)
         self._names[name] = e
         return e

{lino-25.4.4 → lino-25.5.0}/lino/core/model.py

@@ -7,7 +7,7 @@ See :doc:`/dev/models`, :doc:`/dev/delete`, :doc:`/dev/disable`,
 :doc:`/dev/hide`, :doc:`/dev/format`
 
 """
-
+# from bs4 import BeautifulSoup
 from lino import logger
 import copy
 
@@ -25,6 +25,7 @@ from lino.utils.soup import sanitize
 from lino.core import fields
 from lino.core import signals
 from lino.core import actions
+from lino.core import inject
 
 from .fields import make_remote_field, RichTextField, displayfield
 from .utils import error2str
@@ -331,9 +332,9 @@ class Model(models.Model, fields.TableRow):
     @classmethod
     def lookup_or_create(model, lookup_field, value, **known_values):
         """
-        Look up whether there is a model instance having
-        `lookup_field` with value `value`
-        (and optionally other `known_values` matching exactly).
+
+        Look up whether there is a row having value `value` for field
+        `lookup_field` (and optionally other `known_values` matching exactly).
 
         If it doesn't exist, create it and emit an
         :attr:`auto_create <lino.core.signals.auto_create>` signal.
@@ -425,7 +426,12 @@ class Model(models.Model, fields.TableRow):
             old = getattr(self, f.name)
             if old is None:
                 continue
-            new = sanitize(old, **kwargs)
+
+            if getattr(f, "format") == "plain":
+                # assert BeautifulSoup(old, "html.parser").find() is None
+                new = old
+            else:
+                new = sanitize(old, **kwargs)
             # try:
             #     new = bleach.clean(
             #         new,
@@ -819,6 +825,10 @@ class Model(models.Model, fields.TableRow):
 
         setattr(model, vfield_name, pick_choice)
 
+    @classmethod
+    def update_field(cls, *args, **kwargs):
+        inject.update_field(cls, *args, **kwargs)
+
     @classmethod
     def django2lino(cls, model):
         """

{lino-25.4.4 → lino-25.5.0}/lino/core/plugin.py

@@ -223,8 +223,8 @@ class Plugin:
     def get_dashboard_items(self, user):
         return []
 
-    def setup_layout_element(self, el):
-        pass
+    # def setup_layout_element(self, el):
+    #     pass
 
     def get_detail_url(self, ar, actor, pk, *args, **kw):
         from lino.core.renderer import TextRenderer

{lino-25.4.4 → lino-25.5.0}/lino/core/requests.py

@@ -2031,9 +2031,9 @@ class ActionRequest(BaseRequest):
             if w is None:
                 WARNINGS_LOGGED[e] = True
                 # raise
-                # logger.exception(e)
                 logger.warning(f"Error while executing {repr(self)}: {e}\n"
                                "(Subsequent warnings will be silenced.)")
+                logger.exception(e)
 
         if self._data_iterator is None:
             raise Exception(f"No data iterator for {self}")

{lino-25.4.4 → lino-25.5.0}/lino/core/site.py

@@ -36,12 +36,13 @@ from lino.utils.html import E, tostring
 from lino.core.plugin import Plugin
 from lino.utils import AttrDict, date_offset, i2d, buildurl
 
+
 NO_REMOTE_AUTH = True
 # 20240518 We have only one production site still using remote http
 # authentication, and they will migrate to sessions-based auth with their next
 # upgrade.
 
-ASYNC_LOGGING = False
+# ASYNC_LOGGING = False
 # This is to fix the issue that the "started" and "ended" messages are not logged.
 # But setting this to True causes #4986 (Unable to configure handler 'mail_admins')
 # because since 20230529 we called logging..config.dictConfig() during
@@ -138,7 +139,6 @@ class Site(object):
     quantity_max_length = 6
     # upload_to_tpl = "uploads/%Y/%m"
     auto_fit_column_widths = True
-    # locale = 'en_GB.utf-8'
     site_locale = None
     confdirs = None
     kernel = None
@@ -368,14 +368,14 @@ class Site(object):
     csv_params = dict()
 
     # attributes documented in book/docs/opics/loggin.rst:
-    _history_aware_logging = False
+    _history_aware_logging = True
     log_each_action_request = False
+    default_loglevel = "INFO"
     logger_filename = "lino.log"
     logger_format = (
         "%(asctime)s %(levelname)s [%(name)s %(process)d %(thread)d] : %(message)s"
     )
     auto_configure_logger_names = "atelier lino"
-    log_sock_path = None
 
     # appy_params = dict(ooPort=8100)
     appy_params = dict(
@@ -597,31 +597,36 @@ class Site(object):
         self.startup_time = datetime.datetime.now()
 
     def setup_logging(self):
-        # documented in book/docs/opics/loggin.rst
+        # documented in book/docs/topics/logging.rst
 
-        if not self.auto_configure_logger_names:
+        if self.auto_configure_logger_names is None:
             return
 
-        if len(logging.root.handlers) > 0:
-            # Logging has been configured by something else. This can happen
-            # when Site is instantiated a second time. Or accidentaly (e.g. when you call logging.basicConfig() in the settings.py), Or when some testing
-            # environment runs multiple doctests in a same process.  We don't
-            # care, we restart configuration from scratch.
-
-            for handler in logging.root.handlers[:]:
-                logging.root.removeHandler(handler)
+        # if len(logging.root.handlers) > 0:
+        #
+        #     # Logging has been configured by something else. This can happen
+        #     # when Site is instantiated a second time. Or accidentaly (e.g. when
+        #     # you call logging.basicConfig() in the settings.py), Or when some
+        #     # testing environment runs multiple doctests in a same process.  We
+        #     # don't care, we restart configuration from scratch.
+        #
+        #     for handler in logging.root.handlers[:]:
+        #         logging.root.removeHandler(handler)
 
         from django.utils.log import DEFAULT_LOGGING
 
         d = DEFAULT_LOGGING
 
-        if d.get("logger_ok", False):
-            # raise Exception("20231017")
-            return
+        # if d.get("logger_ok", False):
+        #     # raise Exception("20231017")
+        #     return
 
-        level = os.environ.get("LINO_LOGLEVEL", "INFO").upper()
+        level = os.environ.get("LINO_LOGLEVEL", self.default_loglevel).upper()
         file_level = os.environ.get("LINO_FILE_LOGLEVEL", level).upper()
-        min_level = min(*[getattr(logging, k) for k in (level, file_level)])
+        sql_level = os.environ.get("LINO_SQL_LOGLEVEL", level).upper()
+
+        min_level = min(*[getattr(logging, k) for k in (
+            level, file_level, sql_level)])
 
         # print("20231017 level is", level)
 
@@ -642,22 +647,13 @@ class Site(object):
 
         # when Site is instantiated several times, we keep the existing file handler
         # print("20231016", self.logger_filename, handlers.keys())
-        if self.logger_filename and "file" not in handlers:
+        if "file" not in handlers:
             logdir = self.site_dir / "log"
             if logdir.is_dir():
                 self._history_aware_logging = True
                 log_file_path = logdir / self.logger_filename
                 # print("20231019 logging", file_level, "to", log_file_path)
-                self.log_sock_path = logdir / (self.logger_filename + ".sock")
-                if self.log_sock_path.exists():
-                    # print("20231019 log via socket server")
-                    handlers["file"] = {
-                        "class": "lino.core.site.LinoSocketHandler",
-                        "host": str(self.log_sock_path),
-                        "port": None,
-                        "level": file_level,
-                    }
-                else:
+                if True:
                     # print("20231019 log directly to file")
                     formatters = d.setdefault("formatters", {})
                     formatters.setdefault(
@@ -671,6 +667,15 @@ class Site(object):
                         "encoding": "UTF-8",
                         "formatter": "verbose",
                     }
+            else:
+                try:
+                    from systemd.journal import JournalHandler
+                    handlers["file"] = {
+                        "class": "systemd.journal.JournalHandler",
+                        "SYSLOG_IDENTIFIER": str(self.project_name),
+                    }
+                except ImportError:
+                    pass
 
         # when a file handler exists, we have the loggers use it even if this
         # instance didn't create it:
@@ -681,9 +686,10 @@ class Site(object):
             # if name not in d['loggers']:
             d["loggers"][name] = loggercfg
 
-        dblogger = d["loggers"].setdefault("django.db.backends", {})
-        dblogger["level"] = os.environ.get("LINO_SQL_LOGLEVEL", "WARNING")
-        dblogger["handlers"] = loggercfg["handlers"]
+        if sql_level != level:
+            dblogger = d["loggers"].setdefault("django.db.backends", {})
+            dblogger["level"] = sql_level
+            dblogger["handlers"] = loggercfg["handlers"]
 
         # # https://code.djangoproject.com/ticket/30554
         # logger = d['loggers'].setdefault('django.utils.autoreload', {})
@@ -694,19 +700,19 @@ class Site(object):
         #         if item not in ['linod', 'root']:
         #             d['loggers'][item]['propagate'] = True
 
-        if ASYNC_LOGGING:
-            config = d.copy()
-
-            try:
-                logging.config.dictConfig(config)
-                # logging.config.dictConfig(d)
-            finally:
-                d.clear()
-                d["logger_ok"] = True
-                d["version"] = 1
-                d["disable_existing_loggers"] = False
-        else:
-            d["logger_ok"] = True
+        # if ASYNC_LOGGING:
+        #     config = d.copy()
+        #
+        #     try:
+        #         logging.config.dictConfig(config)
+        #         # logging.config.dictConfig(d)
+        #     finally:
+        #         d.clear()
+        #         # d["logger_ok"] = True
+        #         d["version"] = 1
+        #         d["disable_existing_loggers"] = False
+        # else:
+        #     d["logger_ok"] = True
         # self.update_settings(LOGGING=d)
         # pprint(d)
         # print("20161126 Site %s " % d['loggers'].keys())
@@ -971,7 +977,7 @@ class Site(object):
         self.update_settings(ROOT_URLCONF=self.root_urlconf)
         self.update_settings(MEDIA_URL="/media/")
 
-        if not "STATIC_ROOT" in self.django_settings:
+        if "STATIC_ROOT" not in self.django_settings:
             # cache_root = os.environ.get("LINO_CACHE_ROOT", None)
             # if cache_root:
             #     p = Path(cache_root)
@@ -979,10 +985,10 @@ class Site(object):
             #     p = self.site_dir
             p = self.site_dir
             self.update_settings(STATIC_ROOT=str(p / "static_root"))
-        if not "STATIC_URL" in self.django_settings:
+        if "STATIC_URL" not in self.django_settings:
             self.update_settings(STATIC_URL="/static/")
 
-        if not "USE_TZ" in self.django_settings:
+        if "USE_TZ" not in self.django_settings:
             # django.utils.deprecation.RemovedInDjango50Warning: The default
             # value of USE_TZ will change from False to True in Django 5.0. Set
             # USE_TZ to False in your project settings if you want to keep the
@@ -1228,11 +1234,13 @@ class Site(object):
         from lino.core.kernel import site_startup
 
         site_startup(self)
-        if self.site_locale:
-            try:
-                locale.setlocale(locale.LC_ALL, self.site_locale)
-            except locale.Error as e:
-                self.logger.warning("%s : %s", self.site_locale, e)
+
+        if self.site_locale is None:
+            self.site_locale = '.'.join(locale.getlocale())
+        try:
+            locale.setlocale(locale.LC_ALL, self.site_locale)
+        except locale.Error as e:
+            self.logger.warning("%s : %s", self.site_locale, e)
         self.clear_site_config()
 
     def register_shutdown_task(self, task):
@@ -2250,10 +2258,7 @@ class Site(object):
         return moneyfmt(v, places=places, **kw)
 
     def format_currency(self, *args, **kwargs):
-        res = locale.currency(*args, **kwargs)
-        # if six.PY2:
-        #     res = res.decode(locale.nl_langinfo(locale.CODESET))
-        return res
+        return locale.currency(*args, **kwargs)
 
     LOOKUP_OP = "__iexact"
 

{lino-25.4.4 → lino-25.5.0}/lino/core/store.py

@@ -447,7 +447,7 @@ class PreviewTextStoreField(StoreField):
 class VirtStoreField(StoreField):
     def __init__(self, vf, delegate, name):
         self.vf = vf
-        StoreField.__init__(self, vf.return_type, name)
+        super().__init__(vf.return_type, name)
         self.as_js = delegate.as_js
         self.column_names = delegate.column_names
         self.list_values_count = delegate.list_values_count

{lino-25.4.4 → lino-25.5.0}/lino/core/tables.py

@@ -323,6 +323,12 @@ class AbstractTable(actors.Actor):
     See :ref:`dg.table.default_display_modes`.
     """
 
+    parent_layout = None
+
+    @classmethod
+    def attach_to_parent_layout(cls, parent):
+        cls.parent_layout = parent
+
     @classmethod
     # def get_display_mode(cls, available_width=None):
     def get_display_mode(cls):
@@ -532,7 +538,7 @@ method in order to sort the rows of the queryset.
     @classmethod
     def get_column_names(self, ar):
         """Dynamic tables can subclass this method and return a value for
-        :attr:`column_names` which depends on the request.
+        :attr:`column_names` that depends on the request.
 
         """
         # if settings.SITE.mobile_view: