lino 23.12.2__tar.gz → 23.12.3__tar.gz

{lino-23.12.2 → lino-23.12.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lino
-Version: 23.12.2
+Version: 23.12.3
 Summary: A framework for writing desktop-like sustainably free web applications using Django and ExtJS or React
 Home-page: https://gitlab.com/lino-framework/lino
 Author: Rumma & Ko Ltd

{lino-23.12.2 → lino-23.12.3}/lino/config/admin_main_base.html

@@ -11,17 +11,7 @@
 {% if user.is_authenticated %}
     {% block hello_user %}
         {% if not site.plugins.system.use_dashboard_layouts or not ar.renderer.support_dashboard_layout %}
-        <p>{{_("Quick links:")}}
-        {% for ql in site.get_quicklink_items(user.user_type) %}
-          {% if ql.bound_action.get_bound_action_permission(ar) %}
-          [{{tostring(ar.menu_item_button(ql))}}]
-          {% endif %}
-        {% endfor %}
-        {% if ar.renderer.front_end.autorefresh_seconds %}
-        <a href="javascript:Lino.autorefresh();">autorefresh</a>
-        {% endif %}
-        [<a href={{"javascript:"+site.kernel.default_renderer.reload_js()}} style="text-decoration:none">{{_("Refresh")}}</a>]
-        </p>
+        <p>{{_("Quick links:")}} {{site.get_quicklinks_html(ar, user)}}
         {% endif %}
         <p>{{_("Hi, %(user)s!") % dict(user=user)}}
         {% for msg in site.get_welcome_messages(ar) %}

{lino-23.12.2 → lino-23.12.3}/lino/core/actors.py

@@ -215,8 +215,8 @@ class ActorMetaClass(type):
 # class Actor(metaclass=ActorMetaClass, type('NewBase', (actions.Parametrizable, Permittable), {}))):
 class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     """
-    The base class for all actors.  Subclassed by :class:`AbstractTable
-    <lino.core.tables.AbstractTable>`, :class:`Table
+    The base class for all actors (:term:`data view`).  Subclassed by
+    :class:`AbstractTable <lino.core.tables.AbstractTable>`, :class:`Table
     <lino.core.dbtables.Table>`, :class:`ChoiceList
     <lino.core.choicelists.ChoiceList>` and :class:`Frame
     <lino.core.frames.Frame>`.
@@ -578,6 +578,50 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
             s |= cls._state_to_disabled_actions.get(state.name, set())
         return s
 
+    @classmethod
+    def get_handle(self):
+        """
+        Return a static handle for this actor.
+        """
+        #~ assert ar is None or isinstance(ui,UI), \
+            #~ "%s.get_handle() : %r is not a BaseUI" % (self,ui)
+        if self.get_handle_name is not None:
+            raise Exception(
+                "Tried to get static handle for %s (get_handle_name is %r)"
+                % (self, self.get_handle_name))
+        return self._get_handle(None, _handle_attr_name)
+
+    @classmethod
+    def _get_handle(self, ar, hname):
+        # don't inherit from parent!
+        h = self.__dict__.get(hname, None)
+        # logger.info("18072017, h:|%s|, hname:|%s| #1955"%(h, hname))
+        if h is None:
+            h = self._handle_class(self)
+            # don't store the handle instance when an exception occurs during
+            # setup_handle. Because if the exception is caught by calling code,
+            # the unfinished handle would remain in memory and get used by
+            # subsequent calls, causing tracebacks like "AttributeError:
+            # 'TableHandle' object has no attribute 'store'"
+            setattr(self, hname, h)
+
+            # In released versions the following should be True. We might want
+            # to catch exceptions only for debugging purposes.
+
+            if True:
+                settings.SITE.kernel.setup_handle(h, ar)
+            else:
+                try:
+                    settings.SITE.kernel.setup_handle(h, ar)
+                except Exception as e:
+                    # traceback.print_exc()
+                    logger.warning("%s setup_handle failed with %s (change actors.py to see more)", self, e)
+                    delattr(self, hname)
+                    # raise
+
+        # logger.info("18072017, h:|%s|, h.store:|%s|, #1955"%(h, getattr(h,'store',None)))
+        return h
+
     @classmethod
     def get_request_handle(self, ar):
         """
@@ -589,6 +633,21 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
             return self._get_handle(ar, _handle_attr_name)
         return self._get_handle(ar, self.get_handle_name(ar))
 
+    @classmethod
+    def has_handle(self, ui):
+        return self.__dict__.get(_handle_attr_name, False)
+
+    @classmethod
+    def clear_handle(self):
+        """
+        When an actor has dynamic columns which depend on database
+        content, then its layout handle may not persist between
+        different Django test cases because a handle from a first
+        test case may refer to elements which no longer exist in a
+        second test case.
+        """
+        setattr(self, _handle_attr_name, None)
+
     @classmethod
     def get_navinfo(cls, ar, obj):
         """
@@ -616,21 +675,6 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     def is_abstract(cls):
         return cls.abstract
 
-    @classmethod
-    def has_handle(self, ui):
-        return self.__dict__.get(_handle_attr_name, False)
-
-    @classmethod
-    def clear_handle(self):
-        """
-        When an actor has dynamic columns which depend on database
-        content, then its layout handle may not persist between
-        different Django test cases because a handle from a first
-        test case may refer to elements which no longer exist in a
-        second test case.
-        """
-        setattr(self, _handle_attr_name, None)
-
     @classmethod
     def on_analyze(self, site):
         pass
@@ -643,50 +687,6 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     def do_setup(self):
         pass
 
-    @classmethod
-    def get_handle(self):
-        """
-        Return a static handle for this actor.
-        """
-        #~ assert ar is None or isinstance(ui,UI), \
-            #~ "%s.get_handle() : %r is not a BaseUI" % (self,ui)
-        if self.get_handle_name is not None:
-            raise Exception(
-                "Tried to get static handle for %s (get_handle_name is %r)"
-                % (self, self.get_handle_name))
-        return self._get_handle(None, _handle_attr_name)
-
-    @classmethod
-    def _get_handle(self, ar, hname):
-        # don't inherit from parent!
-        h = self.__dict__.get(hname, None)
-        # logger.info("18072017, h:|%s|, hname:|%s| #1955"%(h, hname))
-        if h is None:
-            h = self._handle_class(self)
-            # don't store the handle instance when an exception occurs during
-            # setup_handle. Because if the exception is caught by calling code,
-            # the unfinished handle would remain in memory and get used by
-            # subsequent calls, causing tracebacks like "AttributeError:
-            # 'TableHandle' object has no attribute 'store'"
-            setattr(self, hname, h)
-
-            # In released versions the following should be True. We might want
-            # to catch exceptions only for debugging purposes.
-
-            if True:
-                settings.SITE.kernel.setup_handle(h, ar)
-            else:
-                try:
-                    settings.SITE.kernel.setup_handle(h, ar)
-                except Exception as e:
-                    # traceback.print_exc()
-                    logger.warning("%s setup_handle failed with %s (change actors.py to see more)", self, e)
-                    delattr(self, hname)
-                    # raise
-
-        # logger.info("18072017, h:|%s|, h.store:|%s|, #1955"%(h, getattr(h,'store',None)))
-        return h
-
     # @classmethod
     # def update_field(cls, name, **kwargs):
     #     cls._pending_field_updates.append((name, kwargs)) xxx
@@ -832,7 +832,6 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     @classmethod
     def hide_editing(cls, user_type):
         """
-
         Whether users of the given :term:`user type` can edit in this
         :term:`data window`.
 
@@ -1247,7 +1246,6 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
             # return str(self)
         return E.div(*forcetext([ar.obj2html(obj)]))
 
-
     @classmethod
     def override_column_headers(self, ar, **kwargs):
         """A hook to dynamically override the column headers. This has no
@@ -1687,15 +1685,14 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         """
         Return or yield a list of screenshots to generate for this actor.
         Not yet stable. Don't override this.
-        Don't worry if you don't understand.
         """
         return []
 
     @classmethod
     def slave_as_html(cls, master, ar):
         """
-        Creates and returns the method to be used when :attr:`display_mode`
-        is DISPLAY_MODE_HTML.
+        Execute this slave view on the given master and render it as plain html.
+        Used when :attr:`display_mode` is ``DISPLAY_MODE_HTML``.
         """
         ar = cls.request(
             master, request=ar.request,
@@ -1772,6 +1769,39 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         #         p.append(btn)
         return p
 
+    @classmethod
+    def columns_to_paragraph(cls, self, ar=None, fmt=None):
+        """
+        Represent the given row as a paragraph with a comma-separated list of
+        the values of the fields in the column_names of this actor.
+        """
+        if ar is None:
+            return str(self)
+        # cols = ar.actor.get_detail_layout().main
+        cols = cls.get_list_layout().main.columns
+        cols = [c for c in cols if not c.value.get('hidden')]
+        if fmt is None:
+            def fmt(obj, col):
+                # return str(type(col))
+                v = col.value_from_object(obj, ar)
+                if v is None:
+                    return None
+                else:
+                    try:
+                        v = col.format_value(ar, v)
+                    except Exception as e:
+                        # v = "{} in {}".format(e, col.name)
+                        return col.name + "?!"
+                # return v
+                return "{}:{}".format(col.get_label(), v)
+
+        values = [fmt(self, c) for c in cols]
+        values = [v for v in values if v is not None]
+        s = ", ".join(values)
+        # s = str(ar.actor)
+        # print("20231218", s)  # self, ar.actor.get_list_layout().main.columns)
+        return s
+
     @classmethod
     def error2str(self, e):
         return error2str(self, e)

{lino-23.12.2 → lino-23.12.3}/lino/core/fields.py

@@ -1306,10 +1306,6 @@ class TableRow(object):
         yield "<h1>{}</h1>".format(self)
 
     def as_paragraph(self, ar):
-        """Return a rich text that represents the given row as a list item.
-
-        See :ref:`dev.as_paragraph`.
-        """
         return str(self)
 
     def save_existing_instance(self, ar):

{lino-23.12.2 → lino-23.12.3}/lino/core/site.py

@@ -57,7 +57,7 @@ from lino.core.plugin import Plugin
 from lino.core import constants
 
 from lino import assert_django_code, DJANGO_DEFAULT_LANGUAGE
-from etgen.html import E, join_elems
+from etgen.html import E, join_elems, tostring
 from lino.core.utils import get_models, is_logserver
 
 # from lino.utils.html2text import html2text
@@ -2994,6 +2994,20 @@ site. :manage:`diag` is a command-line shortcut to this.
             if ql.bound_action.get_view_permission(user_type):
                 yield ql
 
+    def get_quicklinks_html(self, ar, user):
+        qll = []
+        for ql in self.get_quicklink_items(user.user_type):
+            if ql.bound_action.get_bound_action_permission(ar):
+                qll.append(tostring(ar.menu_item_button(ql)))
+        if getattr(ar.renderer.front_end, 'autorefresh_seconds', 0) > 0:
+            qll.append('<a href="javascript:Lino.autorefresh();">autorefresh</a>')
+        if False:
+            qll.append('<a href="javascript:{}" style="text-decoration:none">{}</a>'.format(
+                self.kernel.default_renderer.reload_js(), _("Refresh")))
+
+        return " | ".join(qll)
+
+
     def get_quicklinks(self):
         """
         Return or yield a sequence of quick link descriptors to be added to the

{lino-23.12.2 → lino-23.12.3}/lino/core/tables.py

@@ -102,7 +102,7 @@ class TableHandle(object):
     """
     For every table we create one "handle" per renderer.
 
-    See also :meth:`lino.core.actors.Actor.setup_handle` which is called during
+    See also :meth:`lino.core.actors.Actor.setup_handle`, which is called during
     startup and sets more attributes.
 
     """

{lino-23.12.2 → lino-23.12.3}/lino/management/commands/initdb.py

@@ -93,11 +93,11 @@ class Command(BaseCommand):
         parser.add_argument('--noinput', action='store_false',
                             dest='interactive', default=True,
                             help='Do not prompt for input of any kind.'),
-        parser.add_argument('--nobuildcache', action='store_false',
-                            dest='buildcache', default=True,
-                            help='Does nothing.'),
-        parser.add_argument('--remove-media', action='store_true',
-                            dest='remove_media', default=False,
+        # parser.add_argument('--nobuildcache', action='store_false',
+        #                     dest='buildcache', default=True,
+        #                     help='Does nothing.'),
+        parser.add_argument('--removemedia', action='store_true',
+                            dest='removemedia', default=False,
                             help='Remove all files in the settings.MEDIA_ROOT directory.'),
         parser.add_argument('--database', action='store', dest='database',
                             default=DEFAULT_DB_ALIAS,
@@ -159,23 +159,23 @@ class Command(BaseCommand):
         dbname = settings.DATABASES[using]['NAME']
         engine = settings.DATABASES[using]['ENGINE']
 
-        buildcache = options.pop('buildcache')
-        remove_media = options.pop('remove_media')
+        # buildcache = options.pop('buildcache')
+        removemedia = options.pop('removemedia')
         assert str(settings.SITE.media_root) == settings.MEDIA_ROOT
         mroot = settings.SITE.media_root
         if not mroot.exists():
-            remove_media = False
+            removemedia = False
 
         if interactive:
             msg = "We are going to flush your database ({})".format(dbname)
-            if remove_media:
-                msg += " AND REMOVE ALL FILES BELOW {}".format(mroot)
+            if removemedia:
+                msg += "\nAND REMOVE ALL FILES BELOW {}".format(mroot)
             msg += ".\nAre you sure (y/n) ?"
             if not confirm(msg):
                 raise CommandError("User abort.")
 
         # mroot = Path(settings.MEDIA_ROOT)
-        if remove_media:
+        if removemedia:
             remove_tree(mroot)
 
         fixtures = options.pop('fixtures', args)  # don't keep this option

{lino-23.12.2 → lino-23.12.3}/lino/management/commands/prep.py

@@ -4,21 +4,30 @@
 
 from pathlib import Path
 from django.core.management import call_command
+from django.core.management.base import BaseCommand, CommandError
 from django.conf import settings
 from django.db import DEFAULT_DB_ALIAS
 from rstgen.utils import confirm
-from lino.management.commands.initdb import Command as BaseCommand
-from lino.management.commands.initdb import CommandError
+# from lino.management.commands.initdb import Command as BaseCommand
+# from lino.management.commands.initdb import CommandError
 
 
 class Command(BaseCommand):
     help = "Flush the database and load the default demo fixtures."
 
+    def add_arguments(self, parser):
+        super().add_arguments(parser)
+        parser.add_argument('--noinput', action='store_false',
+                            dest='interactive', default=True,
+                            help='Do not prompt for input of any kind.'),
+        parser.add_argument('--keepmedia', action='store_true',
+                            dest='keepmedia', default=False,
+                            help='Do not remove media files.'),
+
     def handle(self, *args, **options):
-        fixtures = options.get('fixtures', args)
-        if len(fixtures) > 0:
+        if len(args) > 0:
             raise CommandError(
-                "This command takes no arguments (got %r)" % fixtures)
+                "This command takes no arguments (got %r)" % args)
 
         if settings.SITE.readonly:
             settings.SITE.logger.info(
@@ -31,15 +40,18 @@ class Command(BaseCommand):
                 "No need to `prep` slave site '%s'.", settings.SETTINGS_MODULE)
             return
 
-        args = settings.SITE.demo_fixtures
-        if isinstance(args, str):
-            args = args.split()
-        options['fixtures'] = args
-
         if settings.SITE.is_installed('search') and settings.SITE.use_elasticsearch:
             call_command('createindexes', '-i')
 
-        options.update(remove_media=True)
-        super().handle(**options)
+        verbosity = options.get('verbosity')
+        args = settings.SITE.demo_fixtures
+        kwargs = dict()
+        if isinstance(args, str):
+            args = args.split()
+        kwargs['interactive'] = options.get('interactive')
+        kwargs['verbosity'] = verbosity
+        if not options.pop('keepmedia'):
+            kwargs['removemedia'] = True
+        call_command('initdb', *args, **kwargs)
 
         settings.SITE.kernel.mark_virgin()

{lino-23.12.2 → lino-23.12.3}/lino/modlib/changes/__init__.py

@@ -21,8 +21,8 @@ class Plugin(ad.Plugin):
     needs_plugins = [
         'lino.modlib.users', 'lino.modlib.gfks']
 
-    remove_after = None
-    # remove_after = 6*30
+    # remove_after = None
+    remove_after = 30
 
 
     def setup_explorer_menu(config, site, user_type, m):

{lino-23.12.2 → lino-23.12.3}/lino/modlib/changes/models.py

@@ -201,7 +201,8 @@ if remove_after:
     @dd.schedule_daily()
     def delete_older_changes(ar):
         days = datetime.timedelta(days=remove_after)
-        qs = Change.objects.filter(time_lt=timezone.now() - days)
+        # django.core.exceptions.FieldError: Cannot resolve keyword 'time_lt' into field. Choices are: changed_fields, diff, id, list_item, master, master_id, master_type, master_type_id, name_column, navigation_panel, object, object_id, object_type, object_type_id, overview, time, type, user, user_id, workflow_buttons
+        qs = Change.objects.filter(time__lt=timezone.now() - days)
         if qs.count() > 0:
             ar.logger.info(
                 "Removing %d changes older than %d days.",

{lino-23.12.2 → lino-23.12.3}/lino/modlib/linod/choicelists.py

@@ -14,8 +14,6 @@ from lino.core.roles import SiteStaff
 
 class Procedure(dd.Choice):
     func: Callable
-    # every_unit: str
-    # every_value: int
     kwargs: dict
 
     def __init__(self, func, **kwargs):
@@ -23,13 +21,13 @@ class Procedure(dd.Choice):
         super().__init__(name, name, name)
         self.func = func
         self.kwargs = kwargs
-        # self.every_unit = every_unit
-        # self.every_value = every_value
 
     async def run(self, ar):
         # raise Exception("20231014 Procedure.run()", self)
         # await database_sync_to_async(self.func)(ar)
-        await sync_to_async(self.func)(ar)
+        return await sync_to_async(self.func)(ar)
+        # return sync_to_async(self.func)(ar)
+        # return self.func(ar)
 
     def __repr__(self):
         return f"Procedures.{self.value}"
@@ -41,20 +39,12 @@ class Procedures(dd.ChoiceList):
     max_length = 100
     item_class = Procedure
     column_names = "value name text kwargs"
-    # column_names = "value name text every_unit every_value"
     required_roles = dd.login_required(SiteStaff)
 
     @dd.virtualfield(dd.CharField(_("Suggested recurrency")))
     def kwargs(cls, choice, ar):
         return ", ".join(["{}={}".format(*i) for i in sorted(choice.kwargs.items())])
 
-    # @dd.virtualfield(dd.CharField(_("Recurrency")))
-    # def every_unit(cls, choice, ar):
-    #     return choice.every_unit
-    #
-    # @dd.virtualfield(dd.CharField(_("Repeat every")))
-    # def every_value(cls, choice, ar):
-    #     return choice.every_value
 
 
 class LogLevel(dd.Choice):

{lino-23.12.2 → lino-23.12.3}/lino/modlib/linod/models.py

@@ -125,7 +125,8 @@ class BackgroundTask(Sequenced, RecurrenceSet):
         # print("20231102 full_clean")
         await database_sync_to_async(self.full_clean)()
         # print("20231102 save")
-        await database_sync_to_async(self.save)()
+        # await database_sync_to_async(self.save)()
+        await self.asave()
         with ar.capture_logger(self.log_level.num_value) as out:
             ar.info("Start %s...", self)
             # ar.info("Start %s using %s...", self, self.log_level)
@@ -141,7 +142,8 @@ class BackgroundTask(Sequenced, RecurrenceSet):
         self.last_end_time = timezone.now()
         self.message = "<pre>" + self.message + "</pre>"
         await database_sync_to_async(self.full_clean)()
-        await database_sync_to_async(self.save)()
+        # await database_sync_to_async(self.save)()
+        await self.asave()
 
     def __str__(self):
         r = "{} #{} {}".format(

{lino-23.12.2 → lino-23.12.3}/lino/modlib/search/models.py

@@ -4,6 +4,7 @@
 
 import re
 from html import escape
+from lxml import etree
 from django.conf import settings
 
 from lino.api import rt, dd, _
@@ -118,15 +119,19 @@ class SiteSearchBase(dd.VirtualTable):
             lst = matches.get(de, None)
             if lst:
                 chunks.append(de.name + ":" + lst)
-        from lxml import etree
         s = ', '.join(chunks)
         s = "<span>" + s + "</span>"
-        try:
-            return etree.fromstring(s)
-        except Exception as e:
-            raise Exception("{} : {}".format(e, s))
-        # return etree.fromstring(', '.join(chunks))
-        # return E.raw(', '.join(chunks))
+
+        if False:
+            # removed 20231218 because it caused a server traceback when
+            # displaying search results for "rumma & ko" 
+            try:
+                return etree.fromstring(s)
+            except Exception as e:
+                raise Exception("{} : {}".format(e, s))
+            # return etree.fromstring(', '.join(chunks))
+            # return E.raw(', '.join(chunks))
+        return s
 
 class SiteSearch(SiteSearchBase):
 

{lino-23.12.2 → lino-23.12.3}/lino/setup_info.py

@@ -7,7 +7,7 @@ import sys
 
 SETUP_INFO = dict(
     name='lino',
-    version='23.12.2',
+    version='23.12.3',
     description="A framework for writing desktop-like sustainably free "
                 "web applications using Django and ExtJS or React",
     license='COPYING',

{lino-23.12.2 → lino-23.12.3}/lino.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lino
-Version: 23.12.2
+Version: 23.12.3
 Summary: A framework for writing desktop-like sustainably free web applications using Django and ExtJS or React
 Home-page: https://gitlab.com/lino-framework/lino
 Author: Rumma & Ko Ltd