lino 25.7.1__py3-none-any.whl → 25.7.2__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.7.1'
+__version__ = '25.7.2'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/doctest.py

@@ -83,6 +83,8 @@ HttpQuery = collections.namedtuple(
 
 # settings.SITE.is_testing = True
 
+ADMIN_FRONT_END = settings.SITE.kernel.editing_front_end
+
 
 def get_json_dict(username, uri, an="detail", **kwargs):
     url = "/api/{0}?fmt=json&an={1}".format(uri, an)
@@ -381,27 +383,28 @@ def walk_menu_items(username=None, severe=True):
         mnu = settings.SITE.get_site_menu(user_type)
         items = []
         for mi in mnu.walk_items():
-            if mi.bound_action:
+            if ba := mi.bound_action:
                 item = menuselection_text(mi)
                 # item += " ({})".format(mi)
                 item += " : "
-                if isinstance(mi.bound_action.action, ShowTable) and not mi.params:
+                if isinstance(ba.action, ShowTable) and not mi.params:
                     # url = settings.SITE.kernel.default_ui.renderer.request_handler()
-                    # sar = mi.bound_action.request(parent=ar)
+                    # sar = ba.request(parent=ar)
                     if False:
-                        url = ar.get_permalink(mi.bound_action, mi.instance)
+                        url = ar.get_permalink(ba, mi.instance)
                     else:
-                        mt = mi.bound_action.actor
+                        mt = ba.actor
                         baseurl = "api/{}/{}".format(mt.app_label, mt.__name__)
                         kwargs = dict(fmt="json")
-                        url = settings.SITE.buildurl(baseurl, **kwargs)
+                        # url = settings.SITE.buildurl(baseurl, **kwargs)
+                        url = ADMIN_FRONT_END.build_plain_url(baseurl, **kwargs)
+
                     try:
                         response = test_client.get(url)
                         # response = test_client.get(url,
                         #                            REMOTE_USER=str(username))
                         result = check_json_result(
-                            response, None, "GET %s for user %s" % (url, username)
-                        )
+                            response, None, f"GET {url} for user {username}")
                         item += str(result["count"])
                         # Also ask in display_mode "list" to cover assert_safe() bugs.
                         # But not e.g. UserRoles because it's not on a model and doesn't have a list mode
@@ -409,10 +412,10 @@ def walk_menu_items(username=None, severe=True):
                             kwargs[
                                 constants.URL_PARAM_DISPLAY_MODE
                             ] = constants.DISPLAY_MODE_LIST
-                            url = settings.SITE.buildurl(baseurl, **kwargs)
+                            url = ADMIN_FRONT_END.build_plain_url(baseurl, **kwargs)
                             response = test_client.get(url)
                             result = check_json_result(
-                                response, None, "GET %s for user %s" % (url, username)
+                                response, None, f"GET {url} for user {username}"
                             )
                             # if ar is not None:
                             #     sar = mt.request(parent=ar)

lino/core/__init__.py

@@ -10,7 +10,6 @@ For some modules the documentation has already been migrated to prosa:
 .. autosummary::
    :toctree:
 
-    actors
     boundaction
     callbacks
     choicelists
@@ -31,7 +30,6 @@ For some modules the documentation has already been migrated to prosa:
     layouts
     menus
     merge
-    model
     permissions
     renderer
     requests

lino/core/actions.py

@@ -11,7 +11,7 @@ from django.utils.encoding import force_str
 from django.utils.translation import gettext
 from lino.core import constants
 from lino.core import keyboard
-from lino.core.exceptions import ChangedAPI
+# from lino.core.exceptions import ChangedAPI
 from .utils import traverse_ddh_fklist
 from .utils import navinfo
 from .utils import obj2unicode
@@ -37,20 +37,17 @@ class Action(Parametrizable, Permittable):
     save_action_name = None
     disable_primary_key = True
     keep_user_values = False
-    icon_name = None
+    icon_name: str = None
     ui5_icon_name = None
     react_icon_name = None
     hidden_elements = frozenset()
     combo_group = None
     parameters: dict[str, Any] | None = None
-
     use_param_panel = False
     no_params_window = False
     sort_index = 90
     help_text = None
-
     auto_save = True
-
     extjs_main_panel = None
     js_handler = None
     action_name = None
@@ -67,6 +64,7 @@ class Action(Parametrizable, Permittable):
     show_in_plain = False
     show_in_toolbar = True
     show_in_workflow = False
+    buddy_name: str = None
     custom_handler = False
     select_rows = True
     http_method = "GET"
@@ -966,7 +964,7 @@ class ShowEditor(Action):
     show_in_toolbar = False
 
     def __init__(self, fieldname, *args, **kwargs):
-        self.fieldname = fieldname
+        self.buddy_name = fieldname
         super().__init__(*args, **kwargs)
 
     def run_from_ui(self, ar, **kwargs):
@@ -978,7 +976,7 @@ class ShowEditor(Action):
                     ar.master_instance.__class__).pk
             })
         ar.set_response(goto_url=ar.renderer.front_end.build_plain_url(
-            "api", *ar.actor.actor_id.split("."), str(ar.selected_rows[0].pk), self.fieldname, **kw))
+            "api", *ar.actor.actor_id.split("."), str(ar.selected_rows[0].pk), self.buddy_name, **kw))
 
 
 # Some actions are described by a single action instance used by most actors:

lino/core/actors.py

@@ -3,8 +3,8 @@
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """This defines :class:`Actor` and related classes.
 
-See :doc:`/dev/actors`.
-
+Introduction see :doc:`/dev/actors`.
+Class reference see :doc:`/src/lino/core/actors`.
 
 """
 
@@ -215,138 +215,21 @@ class ActorMetaClass(type):
 # class Actor(metaclass=ActorMetaClass, type('NewBase', (actions.Parametrizable, Permittable), {}))):
 class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
     """
-    The base class for all actors (:term:`data table`).  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>`.
-
-    .. attribute:: known_values
-
-        A `dict` of `fieldname` -> `value` pairs that specify "known values".
-
-        Requests will automatically be filtered to show only existing
-        records with those values.  This is like :attr:`filter`, but new
-        instances created in this Table will automatically have these
-        values set.
-
-    .. attribute:: welcome_message_when_count
-
-       Set this to an integer (e.g. 0) to tell Lino to make a generic
-       welcome message "You have X items in Y" when the number of rows
-       in this table is *greater than* the given integer.
-
-    The following class methods are `None` in the default
-    implementation. Subclass can define them.
-
-    .. classmethod:: get_handle_name(self, ar)
-
-        Most actors use the same UI handle for each request.  But
-        e.g. :class:`lino_welfare.modlib.debts.models.PrintEntriesByBudget`
-        and :class:`lino_xl.lib.events.EventsByType` override this to
-        implement dynamic columns depending on it's master_instance.
-
-
-    .. classmethod:: get_welcome_messages(self, ar)
-
-        If a method of this name is defined on an actor, then it must
-        be a class method that takes an :class:`ar
-        <lino.core.requests.BaseRequest>` as single argument and
-        returns or yields a list of :term:`welcome messages <welcome
-        message>` (messages to be displayed in the welcome block of
-        :xfile:`admin_main.html`).
-
-        Note that this handler will be called independently of whether
-        the user has permission to view the actor or not.
     """
 
     _detail_action_class = None
 
     obvious_fields = set()
-    """A set of names of fields that are considered :term:`obvious field`.  """
-
     required_roles = set([SiteUser])
-    """See :doc:`/dev/perms`."""
-
     model = None
-    """The model on which this table iterates.
-
-    The :term:`application developer` can specify either the model class itself
-    or a string of type ``'app.Model'``.
-
-    If this is not `None`, it should be a subclass of
-    :class:`lino.core.fields.TableRow`.
-
-    """
-
-    # actions = None
-    # """An :class:`AttrDict <atelier.utils.AttrDict>` containing the
-    # actions available on this actor.
-    #
-    # """
-
     only_fields = None
-
     default_display_modes = None
-    """
-    Which :term:`display mode` to use in a :term:`slave panel`,
-    depending on available width.
-
-    See :ref:`dg.table.default_display_modes`.
-    """
-
     # extra_display_modes = set()
     # extra_display_modes = {constants.DISPLAY_MODE_SUMMARY}
     extra_display_modes = {constants.DISPLAY_MODE_HTML}
-    """
-    A set of additional display modes to make available when rendering this table.
-
-    See :ref:`dg.dd.table.extra_display_modes`.
-    """
-
     app_label = None
-    """
-    Specify this if you want to "override" an existing actor.
-
-    The default value is deduced from the module where the subclass is
-    defined.
-
-    Note that this attribute is not inherited from base classes.
-
-    :func:`lino.core.dbtables.table_factory` also uses this.
-    """
-
     master = None
-    """The class of master instances for requests on this table.
-
-    Application code usually doesn't need to specify this because it
-    is automatically set on actors whose :attr:`master_key` is
-    specified.
-
-    Setting this to something else than `None` will turn the table
-    into a :term:`slave table`.
-
-    If the :attr:`master` is something else than a database model
-    (e.g. a ChoiceList), then the actor must also define a
-    :meth:`get_master_instance` method.
-
-    """
-
     master_key = None
-    """The name of a field of this table's :attr:`model` that
-    points to its :attr:`master`.
-
-    The field named by :attr:`master_key` should usually be a
-    :class:`ForeignKey` field.
-
-    Special cases: :class:`lino_xl.lib.cal.EntriesByGuest` shows the entries
-    having a presence pointing to this guest.
-
-    The :attr:`master_key` is automatically added to :attr:`hidden_columns`.
-
-
-    """
-
     details_of_master_template = _("%(details)s of %(master)s")
 
     parameters = None
@@ -458,39 +341,12 @@ class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
     get_handle_name = None
 
     abstract = True
-    """
-    Set this to `True` to prevent Lino from generating useless
-    JavaScript if this is just an abstract base class to be inherited
-    by other actors.
-
-    Note that this class attribute is not inherited to subclasses.
-
-    """
     sum_text_column = 0
 
     preview_limit = None
 
     handle_uploaded_files = None
-    """
-    Handler for uploaded files.
-    Same remarks as for :attr:`lino.core.actors.Actor.disabled_fields`.
-    """
-
     default_record_id = None
-    """
-    Turn this table into a :doc:`single-row table </topics/singlerow>`.
-
-    When this is not `None`, you must also implement a custom version of
-    :meth:`get_row_by_pk` that returns the same :term:`database row` regardless
-    the given :term:`primary key`.
-
-    This must currently be either `None` or ``'row'`` (or ``'myself'``).
-
-    TODO: Rename this to `single_row` and make it a simple boolean so that the
-    application developer can say ``single_row = True`` instead of
-    ``default_record_id = 'row'``.
-
-    """
 
     def __init__(self, *args, **kw):
         raise Exception("Actors should never get instantiated")
@@ -1682,11 +1538,6 @@ class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
 
     @classmethod
     def get_toolbar_actions(self, parent, user_type):
-        """
-        Return a list of actions for which a button should exist in the
-        toolbar of the specified "parent" action.
-        """
-
         for ba in self.get_button_actions(parent):
             if ba.action.show_in_toolbar and ba.get_view_permission(user_type):
                 if ba.action.readonly or not self.hide_editing(user_type):
@@ -1703,14 +1554,6 @@ class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
 
     @classmethod
     def get_button_actions(self, parent):
-        """
-        Return a sorted list of actions that should be available as
-        buttons in the specified `parent` (a window action).
-
-        This is used (1) by :meth:`get_toolbar_actions` and (2) to
-        reduce the list of disabled actions in `disabled_fields` to
-        those which make sense.  `dbtables.make_disabled_fields`
-        """
         if not parent.opens_a_window:
             # return []
             raise Exception(
@@ -1720,9 +1563,6 @@ class Actor(Parametrizable, Permittable, metaclass=ActorMetaClass):
 
     @classmethod
     def get_actions(self):
-        """
-        Return a sorted list of all bound actions offered by this actor.
-        """
         return self._actions_list
 
     @classmethod

lino/core/elems.py

@@ -1103,7 +1103,7 @@ class ForeignKeyElement(ComplexRemoteComboFieldElement):
         if actor is None:
             return kw
 
-        if settings.SITE.kernel.web_front_ends[0].app_label == "react":
+        if settings.SITE.kernel.editing_front_end.app_label == "react":
             options = dict(
                 related_actor_id=actor.actor_id, allowBlank=kw.get(
                     "allowBlank", False)

lino/core/fields.py

@@ -370,6 +370,9 @@ class FakeField(object):
         # if self.verbose_name is None and self.name:
         #     self.verbose_name = self.name.replace('_', ' ')
 
+    def get(self, *args, **kwargs):
+        return None
+
 
 class RemoteField(FakeField):
     """

lino/core/kernel.py

@@ -610,6 +610,7 @@ class Kernel(object):
             # print("\n".join(["- {0.url_prefix} --> {0.app_name} {1}".format(p, hash(p))
             #     for p in self.web_front_ends]))
 
+        editing_wf = None
         for p in self.web_front_ends:
             if p.ui_handle_attr_name is not None:
                 editing_wf = p
@@ -686,6 +687,7 @@ class Kernel(object):
         # trigger creation of params_layout.params_store and
         # virtual fields in LightWeightContainer
         for res in actors.actors_list:
+            field_actions = dict()
             for ba in res.get_actions():
                 # ba._started = True
                 if ba.help_text is None:
@@ -694,6 +696,10 @@ class Kernel(object):
                     ba.action.params_layout.get_layout_handle()
                 if ba.action.is_window_action():
                     ba.get_layout_handel()
+                if ba.action.buddy_name:
+                    lst = field_actions.setdefault(ba.action.buddy_name, [])
+                    lst.append(ba)
+            res._field_actions = field_actions
 
         # logger.info("20161219 kernel_startup done")
 

lino/core/layouts.py

@@ -4,7 +4,6 @@
 
 """
 
-from lino import logger
 import re
 
 from django.conf import settings
@@ -14,6 +13,8 @@ from django.db.models.fields import NOT_PROVIDED
 from django.db.models.fields.related import ForeignObject
 # from django.contrib.contenttypes.fields import GenericRelation
 
+from lino import logger
+from lino.utils import jsgen
 from lino.core import constants
 from lino.core import atomizer
 from lino.core import fields
@@ -222,6 +223,7 @@ class LayoutHandle:
         if len(elems) == 1 and elemname != "main":
             elems[0].setup(**kwargs)
             return elems[0]
+
         from lino.core.elems import create_layout_panel
 
         return create_layout_panel(self, elemname, vertical, elems, **kwargs)
@@ -813,16 +815,12 @@ class ActionParamsLayout(ParamsLayout):
     url_param_name = constants.URL_PARAM_FIELD_VALUES
 
     def setup_element(self, lh, e):
-        from lino.utils import jsgen
-
         e.declare_type = jsgen.DECLARE_THIS
 
     def get_choices_url(self, ui, field, **kw):
-        return settings.SITE.kernel.web_front_ends[0].build_plain_url(
+        return settings.SITE.kernel.editing_front_end.build_plain_url(
             "apchoices",
             self._datasource.defining_actor.app_label,
             self._datasource.defining_actor.__name__,
             self._datasource.action_name,
-            field.name,
-            **kw,
-        )
+            field.name, **kw)

lino/core/model.py

@@ -994,6 +994,7 @@ LINO_MODEL_ATTRIBS = (
     "_lino_tables",
     "show_in_site_search",
     "allow_merge_action",
+    "get_overview_elems",
 )
 
 

lino/core/plugin.py

@@ -65,7 +65,7 @@ class Plugin:
                 raise Exception("%s has no attribute %s" % (self, k))
             setattr(self, k, v)
 
-    def get_required_plugins(self):
+    def get_needed_plugins(self):
         return self.needs_plugins
 
     def get_used_libs(self, html=None):

lino/core/renderer.py

@@ -498,7 +498,7 @@ class HtmlRenderer(Renderer):
         return E.p(*buttons)
 
     def get_home_url(self, *args, **kw):
-        return settings.SITE.kernel.web_front_ends[0].build_plain_url(*args, **kw)
+        return settings.SITE.kernel.editing_front_end.build_plain_url(*args, **kw)
 
     def obj2url(self, ar, obj):
         ba = obj.get_detail_action(ar)

lino/core/requests.py

@@ -1842,10 +1842,9 @@ class ActionRequest(BaseRequest):
             pv = self.actor.param_defaults(self)
             for k in pv.keys():
                 if k not in self.actor.parameters:
-                    raise Exception(
-                        "%s.param_defaults() returned invalid keyword %r"
-                        % (self.actor, k)
-                    )
+                    msg = f"{self.actor} param_defaults() returned keyword {k}"
+                    msg += f" (must be one of {sorted(self.actor.parameters.keys())})"
+                    raise Exception(msg)
 
             # New since 20120913.  E.g. newcomers.Newcomers is a
             # simple pcsw.Clients with

lino/core/site.py

@@ -862,7 +862,7 @@ class Site(object):
             needed_by = ip
             # while needed_by.needed_by is not None:
             #     needed_by = needed_by.needed_by
-            for dep in ip.get_required_plugins():
+            for dep in ip.get_needed_plugins():
                 k2 = dep.rsplit(".")[-1]
                 if k2 not in self.plugins:
                     install_plugin(dep, needed_by=needed_by)

lino/core/utils.py

@@ -664,10 +664,11 @@ class Parametrizable:
     parameters = None
     params_layout = None
     params_panel_hidden = True
-    params_panel_pos = "top"  # allowed values "top", "bottom", "left" and "right"
+    params_panel_pos = "bottom"  # allowed values "top", "bottom", "left" and "right"
     use_detail_param_panel = False
 
     _params_layout_class = NotImplementedError
+    _field_actions = dict()
 
     def get_window_layout(self, actor):
         return self.params_layout
@@ -1238,11 +1239,12 @@ def register_params(cls):
             cls.params_layout = cls._params_layout_class.join_str.join(
                 cls.parameters.keys()
             )
+    if cls.params_layout is not None:
         install_layout(cls, "params_layout", cls._params_layout_class)
 
-    # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
-    elif cls.params_layout is not None:
-        raise Exception("{} has a params_layout but no parameters".format(cls))
+    # # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
+    # elif cls.params_layout is not None:
+    #     raise Exception("{} has a params_layout but no parameters".format(cls))
 
     # if isinstance(cls, type) and cls.__name__.endswith("Users"):
     # # if isinstance(cls, type) and cls.model is not None and cls.model.__name__ == "User":

lino/help_texts.py

@@ -312,7 +312,6 @@ help_texts = {
     'lino.core.model.Model.create_from_choice' : _("""Called when a learning combo has been submitted. Create a persistent database object if the given text contains enough information."""),
     'lino.core.model.Model.choice_text_to_dict' : _("""Return a dict of the fields to fill when the given text contains enough information for creating a new database object."""),
     'lino.core.model.Model.allow_cascaded_delete' : _("""A set of names of ForeignKey or GenericForeignKey fields of this model that allow for cascaded delete."""),
-    'lino.core.model.Model.disabled_fields' : _("""Return a set of field names that should be disabled (i.e. not editable) for this database object."""),
     'lino.core.model.Model.__str__' : _("""Return a translatable text that describes this database row."""),
     'lino.core.model.Model.as_str' : _("""Return a translatable text that describes this database row. Unlike __str__() this method gets an action request when it is called, so it knows the context."""),
     'lino.core.model.Model.get_str_words' : _("""Yield a series of words that describe this database row in plain text."""),
@@ -705,11 +704,13 @@ help_texts = {
     'lino.modlib.weasyprint.WeasyHtmlBuildMethod' : _("""Renders the input template and returns the unmodified output as plain HTML."""),
     'lino.modlib.weasyprint.WeasyPdfBuildMethod' : _("""Like WeasyBuildMethod, but the rendered HTML is then passed through weasyprint which converts from HTML to PDF."""),
     'lino.core.model.Model' : _("""Lino extension of Django’s database model. This is a subclass of Django’s Model class (django.db.models.Model)."""),
+    'lino.core.model.Model.__init__' : _("""The first positional argument is the optional label, other arguments should be specified as keywords and can be any of the existing class attributes."""),
     'lino.core.model.Model.overview' : _("""A multi-paragraph representation of this database row."""),
     'lino.core.model.Model.navigation_panel' : _("""A virtual field that displays the navigation panel for this row. This may be included in a detail layout, usually either on the left or the right side with full height."""),
     'lino.core.model.Model.workflow_buttons' : _("""Shows the current workflow state of this database row and a list of available workflow actions."""),
     'lino.core.model.Model.workflow_state_field' : _("""Optional default value for the workflow_state_field of all data tables based on this model."""),
     'lino.core.model.Model.workflow_owner_field' : _("""Optional default value for workflow_owner_field on all data tables based on this model."""),
+    'lino.core.model.Model.disabled_fields' : _("""Return a set of field names that should be disabled (i.e. not editable) for this database object."""),
     'lino.core.model.Model.FOO_changed' : _("""Called when field FOO of an instance of this model has been modified through the user interface."""),
     'lino.core.model.Model.FOO_choices' : _("""Return a queryset or list of allowed choices for field FOO."""),
     'lino.core.model.Model.create_FOO_choice' : _("""For every field named “FOO” for which a chooser exists, if the model also has a method called “create_FOO_choice”, then this chooser will be a learning chooser. That is, users can enter text into the combobox, and Lino will create a new database object from it."""),

lino/mixins/registrable.py

@@ -118,12 +118,14 @@ class Registrable(model.Model):
         # yield 'date'
 
     def disabled_fields(self, ar):
+        rv = super().disabled_fields(ar)
         if not self.state.is_editable:
             # return self._registrable_fields
             # Copy _registrable_fields otherwise _registrable_fields get
             # modified as more disabled fields are added to the set.
-            return self._registrable_fields.copy()
-        return super().disabled_fields(ar)
+            # return self._registrable_fields.copy()
+            rv |= self._registrable_fields
+        return rv
 
     def get_row_permission(self, ar, state, ba):
         """Only rows in an editable state may be edited.

lino/modlib/extjs/views.py

@@ -463,6 +463,13 @@ class ApiElement(View):
                 else:
                     datarec = ar.elem2rec_detailed(elem)
                 datarec.update(**vm)
+
+                fa = dict()
+                for k, lst in rpt._field_actions.items():
+                    fa[k] = [ar.row_action_button(elem, ba) for ba in lst]
+                if fa:
+                    datarec.update(field_actions=fa)
+
                 return json_response(datarec)
 
             after_show = ar.get_status(record_id=pk)

lino/modlib/linod/__init__.py

@@ -50,7 +50,7 @@ class Plugin(ad.Plugin):
         m = m.add_menu(mg.app_label, mg.verbose_name)
         m.add_action("linod.Procedures")
 
-    def get_required_plugins(self):
+    def get_needed_plugins(self):
         # We don't use needs_plugins because it depends on use_channels. We must
         # not install the plugin when the Python package isn't installed because
         # otherwise `pm install` fails with ModuleNotFoundError: No module named

lino/modlib/memo/__init__.py

@@ -50,7 +50,7 @@ class Plugin(ad.Plugin):
     """The front end to use when writing previews.
 
     If this is `None`, Lino will use the default :term:`front end`
-    (:attr:`lino.core.site.Site.web_front_ends`).
+    (:attr:`lino.core.site.Site.editing_front_end`).
 
     Used on sites that are available through more than one web front ends.  The
     :term:`server administrator` must then decide which front end is the primary
@@ -115,7 +115,6 @@ class Plugin(ad.Plugin):
     def post_site_startup(self, site):
         if self.front_end is None:
             self.front_end = site.kernel.editing_front_end
-            # web_front_ends[0]
         else:
             self.front_end = site.plugins.resolve(self.front_end)
 

lino/modlib/office/roles.py

@@ -1,7 +1,6 @@
 # Copyright 2015-2023 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-from lino.core.roles import UserRole
 from lino.modlib.uploads.roles import UploadsReader
 
 

lino/modlib/printing/actions.py

@@ -294,19 +294,15 @@ class EditTemplate(BasePrintAction):
             ar.confirm(ok, msg, _("Are you sure?"))
 
 
-class ClearCacheAction(Action):
+class ClearCache(Action):
     sort_index = 51
     url_action_name = "clear"
     label = _("Clear cache")
     icon_name = "printer_delete"
 
-    # def disabled_for(self,obj,request):
-    #     if not obj.build_time:
-    #         return True
-
     def get_action_permission(self, ar, obj, state):
         # obj may be None when Lino asks whether this action
-        # should be visible in the UI
+        # should be visible in the table toolbar
         if obj is not None and not obj.build_time:
             return False
         return super().get_action_permission(ar, obj, state)