lino 25.4.3__py3-none-any.whl → 25.4.5__py3-none-any.whl

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.3'
+__version__ = '25.4.5'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/core/fields.py

@@ -163,7 +163,7 @@ 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`.
     """
 
@@ -656,8 +656,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

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/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/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
@@ -368,14 +369,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(
@@ -559,21 +560,13 @@ class Site(object):
                     break
 
         if self.master_site is None:
-            # cache_root = os.environ.get("LINO_CACHE_ROOT", None)
-            # if cache_root:
-            #     # TODO: deprecate
-            #     cr = Path(cache_root).absolute()
-            #     if not cr.exists():
-            #         msg = "LINO_CACHE_ROOT ({0}) does not exist!".format(cr)
-            #         raise Exception(msg)
-            #     self.site_dir = (cr / self.project_name).resolve()
-            #     self.setup_cache_directory()
-            # else:
-            #     self.site_dir = self.project_dir
             self.site_dir = self.project_dir
-            db = self.get_database_settings()
-            if db is not None:
-                self.django_settings.update(DATABASES=db)
+            self.django_settings.update(DATABASES={
+                "default": {
+                    "ENGINE": "django.db.backends.sqlite3",
+                    "NAME": str(self.site_dir / "default.db")
+                }
+            })
         else:
             self.site_dir = self.master_site.site_dir
             self._history_aware_logging = self.master_site._history_aware_logging
@@ -605,31 +598,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)
 
@@ -650,22 +648,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(
@@ -679,6 +668,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:
@@ -689,9 +687,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', {})
@@ -702,34 +701,25 @@ 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())
         # import yaml
         # print("20231019", yaml.dump(d))
 
-    def get_database_settings(self):
-        if self.site_dir is None:
-            pass  # raise Exception("20160516 No site_dir")
-        else:
-            dbname = self.site_dir / "default.db"
-            return {
-                "default": {"ENGINE": "django.db.backends.sqlite3", "NAME": str(dbname)}
-            }
-
     def get_anonymous_user(self):
         # The code below works even when users is not installed
         from lino.modlib.users.choicelists import UserTypes

lino/core/utils.py

@@ -37,6 +37,9 @@ get_models = apps.get_models
 
 validate_url = URLValidator()
 
+DEVSERVER_COMMANDS = {
+    "runserver", "testserver", "test", "demotest", "makescreenshots", "shell"}
+
 
 def djangoname(o):
     return o.__module__.split(".")[-2] + "." + o.__name__
@@ -144,6 +147,8 @@ def is_devserver():
 
     """
     # ~ print 20130315, sys.argv[1]
+    if settings.DEBUG:
+        return True  # doctest under pytest
     if sys.argv[0].startswith("-"):
         return True  # doctest under pytest
     if len(sys.argv) <= 1:
@@ -153,9 +158,9 @@ def is_devserver():
     # if sys.argv[0].endswith("doctest.py") or sys.argv[0].endswith("doctest_utf8.py"):
     if sys.argv[0].endswith("doctest.py") or sys.argv[0].endswith("pytest"):
         return True
-    if sys.argv[1] in ("runserver", "testserver", "test", "makescreenshots", "shell"):
+    if sys.argv[1] in DEVSERVER_COMMANDS:
         return True
-    # print(sys.argv[1])
+    # print(sys.argv)
     return False
 
 

lino/help_texts.py

@@ -182,8 +182,6 @@ help_texts = {
     'lino.utils.IncompleteDate' : _("""Naive representation of a potentially incomplete gregorian date."""),
     'lino.utils.IncompleteDate.parse' : _("""Parse the given string and return an IncompleteDate object."""),
     'lino.utils.IncompleteDate.get_age' : _("""Return age in years as integer."""),
-    'lino.utils.SumCollector' : _("""A dictionary of sums to be collected using an arbitrary key."""),
-    'lino.utils.SumCollector.collect' : _("""Add the given value to the sum at the given key k."""),
     'lino.utils.MissingRow' : _("""Represents a database row that is expected to exist but doesn’t."""),
     'lino.utils.addressable.Addressable' : _("""General mixin (not only for Django models) to encapsulate the generating of “traditional” (“snail”) mail addresses."""),
     'lino.utils.addressable.Addressable.address_person_lines' : _("""Yield one or more text lines, one for each line of the person part."""),

lino/mixins/registrable.py

@@ -1,18 +1,18 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2010-2020 Rumma & Ko Ltd
+# Copyright 2010-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """
 This defines the :class:`Registable` model mixin.
 """
 
 from django.db import models
-from django.utils.translation import gettext_lazy as _
+# from django.utils.translation import gettext_lazy as _
 
+from lino import logger
 from lino.core import model
-from lino.core.actions import Action
+# from lino.core.actions import Action
 from lino.core.workflows import ChangeStateAction
 from lino.core.exceptions import ChangedAPI
-
 from lino.core.workflows import State
 
 
@@ -180,6 +180,7 @@ class Registrable(model.Model):
         state_field = self.workflow_state_field
         target_state = state_field.choicelist.draft
         self.set_workflow_state(ar, state_field, target_state)
+        logger.warning("%s deregisters %s", ar.get_user(), self)
 
     # no longer needed after 20170826
     # @classmethod

lino/modlib/checkdata/models.py

@@ -21,6 +21,9 @@ from lino.api import dd, rt, _
 from .choicelists import Checker, Checkers
 from .roles import CheckdataUser
 
+MAX_LENGTH = 250
+MORE = " (...)"
+
 
 class CheckerAction(dd.Action):
     fix_them = False
@@ -150,7 +153,7 @@ class Message(Controllable, UserAuthored):
     checker = Checkers.field(verbose_name=_("Checker"))
     # severity = Severities.field()
     # feedback = Feedbacks.field(blank=True)
-    message = models.CharField(_("Message text"), max_length=250)
+    message = models.CharField(_("Message text"), max_length=MAX_LENGTH)
     # fixable = models.BooleanField(_("Fixable"), default=False)
 
     update_problem = UpdateMessage()
@@ -166,6 +169,11 @@ class Message(Controllable, UserAuthored):
     def __str__(self):
         return self.message
 
+    def full_clean(self):
+        if len(self.message) > MAX_LENGTH:
+            self.message = self.message[:MAX_LENGTH - len(MORE)] + MORE
+        super().full_clean()
+
     @classmethod
     def get_simple_parameters(cls):
         for p in super(Message, cls).get_simple_parameters():

lino/modlib/jinja/mixins.py

@@ -11,6 +11,7 @@ from django.conf import settings
 from django.utils.html import mark_safe, escape
 
 from lino.api import dd, _
+from lino.utils.sums import myround
 from lino.utils.xml import validate_xml
 from lino.utils.media import MediaFile
 
@@ -51,6 +52,7 @@ class XMLMaker(dd.Model):
         context = self.get_printable_context(ar)
         context.update(xml_element=xml_element)
         context.update(base64=base64)
+        context.update(myround=myround)
         xml = tpl.render(**context)
         # parts = [
         #     dd.plugins.accounting.xml_media_dir,

lino/modlib/linod/management/commands/linod.py

@@ -3,13 +3,11 @@
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 # import time
-import os
 import asyncio
-
 from django.conf import settings
 from django.core.management import BaseCommand, call_command
-from lino.api import dd, rt
-from lino.modlib.linod.mixins import start_log_server, start_task_runner
+from lino.api import dd
+from lino.modlib.linod.mixins import start_task_runner
 from lino.core.requests import BaseRequest
 
 if dd.plugins.linod.use_channels:
@@ -33,19 +31,6 @@ class Command(BaseCommand):
         #                     default=False)
 
     def handle(self, *args, **options):
-        log_sock_path = settings.SITE.log_sock_path
-
-        if log_sock_path and log_sock_path.exists():
-            if options.get("force"):
-                log_sock_path.unlink()
-            else:
-                raise Exception(
-                    f"log socket already exists: {log_sock_path}\n"
-                    "It's probable that a worker process is already running. "
-                    "Try: 'ps awx | grep linod' OR 'sudo supervisorctl status | grep worker'\n"
-                    "Or the last instance of the worker process did not finish properly. "
-                    "In that case remove the file and run this command again."
-                )
 
         if not dd.plugins.linod.use_channels:
             # print("20240424 Run Lino daemon without channels")
@@ -57,8 +42,8 @@ class Command(BaseCommand):
                 except settings.SITE.user_model.DoesNotExist:
                     u = None
                 ar = BaseRequest(user=u)
-                # ar = rt.login(dd.plugins.linod.daemon_user)
-                await asyncio.gather(start_log_server(), start_task_runner(ar))
+                # await asyncio.gather(start_log_server(), start_task_runner(ar))
+                await start_task_runner(ar)
                 # t1 = asyncio.create_task(settings.SITE.start_log_server())
                 # t2 = asyncio.create_task(start_task_runner(ar))
                 # await t1
@@ -84,7 +69,7 @@ class Command(BaseCommand):
             async def initiate_linod():
                 layer = get_channel_layer()
                 # if log_sock_path is not None:
-                await layer.send(CHANNEL_NAME, {"type": "log.server"})
+                # await layer.send(CHANNEL_NAME, {"type": "log.server"})
                 # await asyncio.sleep(1)
                 await layer.send(CHANNEL_NAME, {"type": "run.background.tasks"})
 

lino/modlib/linod/mixins.py

@@ -291,42 +291,3 @@ async def start_task_runner(ar=None, max_count=None):
             continue
         await ar.adebug("Let task runner sleep for %s seconds.", to_sleep)
         await asyncio.sleep(to_sleep)
-
-
-class LogReceiver(asyncio.Protocol):
-    # def connection_made(self, transport):
-    #     print("20231019 connection_made", transport)
-
-    def data_received(self, data: bytes):
-        data = pickle.loads(
-            data[4:]
-        )  # first four bytes gives the size of the rest of the data
-        record = logging.makeLogRecord(data)
-        # print("20231019 data_received", record)
-        # 20231019 server_logger.handle(record)
-        logger.handle(record)
-
-
-async def start_log_server():
-    # 'log.server' in linod.py
-    site = settings.SITE
-    log_sock_path = site.log_sock_path
-    if log_sock_path is None:
-        logger.info(
-            "No log server because there is no directory %s.", site.site_dir / "log"
-        )
-        return
-    if log_sock_path.exists():
-        raise Exception("Cannot start log server when socket file exists.")
-    logger.info("Log server starts listening on %s", log_sock_path)
-
-    def remove_sock_file():
-        logger.info("Remove socket file %s", site.log_sock_path)
-        site.log_sock_path.unlink(missing_ok=True)
-
-    site.register_shutdown_task(remove_sock_file)
-    loop = asyncio.get_running_loop()
-    server = await loop.create_unix_server(LogReceiver, log_sock_path)
-    # await server.serve_forever()
-    async with server:
-        await server.serve_forever()

lino/modlib/linod/routing.py

@@ -1,67 +1,70 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2022 Rumma & Ko Ltd
+# Copyright 2022-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from django.urls import re_path
+from django.conf import settings
 from django.core.asgi import get_asgi_application
-from django.utils.functional import LazyObject
 
-from channels.middleware import BaseMiddleware
-from channels.db import database_sync_to_async
-from channels.sessions import SessionMiddlewareStack
-from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
+if settings.SITE.plugins.linod.use_channels:
 
-from lino.core.auth import get_user
-from lino.modlib.notify.consumers import ClientConsumer
+    from django.urls import re_path
+    from django.utils.functional import LazyObject
+    from channels.middleware import BaseMiddleware
+    from channels.db import database_sync_to_async
+    from channels.sessions import SessionMiddlewareStack
+    from channels.routing import ProtocolTypeRouter, URLRouter, ChannelNameRouter
 
-from .utils import CHANNEL_NAME
-from .consumers import LinodConsumer
+    from lino.core.auth import get_user
+    from lino.modlib.notify.consumers import ClientConsumer
 
+    from .utils import CHANNEL_NAME
+    from .consumers import LinodConsumer
 
-class UserLazyObject(LazyObject):
-    """
-    Throw a more useful error message when scope['user'] is accessed before it's resolved
-    """
+    class UserLazyObject(LazyObject):
+        """
+        Throw a more useful error message when scope['user'] is accessed before it's resolved
+        """
 
-    def _setup(self):
-        raise ValueError("Accessing scope user before it is ready.")
+        def _setup(self):
+            raise ValueError("Accessing scope user before it is ready.")
 
+    async def _get_user(scope):
+        class Wrapper:
+            def __init__(self, session):
+                self.session = session
 
-async def _get_user(scope):
-    class Wrapper:
-        def __init__(self, session):
-            self.session = session
+        r = Wrapper(scope["session"])
+        return await database_sync_to_async(get_user)(r)
 
-    r = Wrapper(scope["session"])
-    return await database_sync_to_async(get_user)(r)
+    class AuthMiddleware(BaseMiddleware):
+        def populate_scope(self, scope):
+            # Make sure we have a session
+            if "session" not in scope:
+                raise ValueError("AuthMiddleware cannot find session in scope.")
+            # Add it to the scope if it's not there already
+            if "user" not in scope:
+                scope["user"] = UserLazyObject()
 
+        async def resolve_scope(self, scope):
+            scope["user"]._wrapped = await _get_user(scope)
 
-class AuthMiddleware(BaseMiddleware):
-    def populate_scope(self, scope):
-        # Make sure we have a session
-        if "session" not in scope:
-            raise ValueError("AuthMiddleware cannot find session in scope.")
-        # Add it to the scope if it's not there already
-        if "user" not in scope:
-            scope["user"] = UserLazyObject()
+        async def __call__(self, scope, receive=None, send=None):
+            self.populate_scope(scope)
+            await self.resolve_scope(scope)
+            return await self.inner(scope, receive, send)
 
-    async def resolve_scope(self, scope):
-        scope["user"]._wrapped = await _get_user(scope)
+    routes = [re_path(r"^WS/$", ClientConsumer.as_asgi())]
 
-    async def __call__(self, scope, receive=None, send=None):
-        self.populate_scope(scope)
-        await self.resolve_scope(scope)
-        return await self.inner(scope, receive, send)
+    protocol_mapping = dict(
+        websocket=SessionMiddlewareStack(AuthMiddleware(URLRouter(routes))),
+        channel=ChannelNameRouter({CHANNEL_NAME: LinodConsumer.as_asgi()}),
+        http=get_asgi_application(),
+    )
 
+    application = ProtocolTypeRouter(protocol_mapping)
 
-routes = [re_path(r"^WS/$", ClientConsumer.as_asgi())]
+    # raise Exception("20240424")
 
-protocol_mapping = dict(
-    websocket=SessionMiddlewareStack(AuthMiddleware(URLRouter(routes))),
-    channel=ChannelNameRouter({CHANNEL_NAME: LinodConsumer.as_asgi()}),
-    http=get_asgi_application(),
-)
+else:
 
-application = ProtocolTypeRouter(protocol_mapping)
-
-# raise Exception("20240424")
+    application = get_asgi_application()