lino 24.10.0__py3-none-any.whl → 24.10.1__py3-none-any.whl

lino/core/requests.py

@@ -6,6 +6,10 @@ See introduction in :doc:`/dev/ar` and API reference in
 :class:`lino.api.core.Request`.
 """
 
+# from past.utils import old_div
+
+import sys
+import json
 import html
 import logging
 from io import StringIO
@@ -14,6 +18,7 @@ from contextlib import contextmanager
 from types import GeneratorType
 from copy import copy, deepcopy
 from xml.sax.saxutils import escape
+from etgen import html as xghtml
 
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
@@ -22,17 +27,20 @@ from django.utils.translation import get_language, activate
 from django.utils import translation
 from django.utils import timezone
 from django.core.mail import send_mail
+from django.core.exceptions import ObjectDoesNotExist, SuspiciousOperation
 from django.core import exceptions
 from django.db import models
+from django.db.models.query import QuerySet
 from asgiref.sync import sync_to_async
 
 from lino.utils.html import E, tostring, iselement
-from lino.core import constants
 from lino.utils import AttrDict
 from lino.utils import MissingRow
 from lino.utils.html import html2text
+from lino.core import constants
 from lino.core import callbacks
 from lino.core import actions
+from lino.core.tables import AbstractTable
 from lino.core.boundaction import BoundAction
 from lino.core.signals import on_ui_created, pre_ui_save
 from lino.core.diff import ChangeWatcher
@@ -40,12 +48,23 @@ from lino.core.utils import getrqdata
 from lino.core.utils import obj2unicode
 from lino.core.utils import obj2str
 from lino.core.utils import UnresolvedModel
+from lino.core.utils import format_request
+from lino.core.utils import PhantomRow
+from lino.core.store import get_atomizer
 from lino.core.exceptions import ChangedAPI
 
-try:
+# try:
+#     from django.contrib.contenttypes.models import ContentType
+# except RuntimeError:
+#     pass
+
+if settings.SITE.is_installed("contenttypes"):
     from django.contrib.contenttypes.models import ContentType
-except RuntimeError:
-    pass
+else:
+    ContentType = None
+
+from .fields import RemoteField, FakeField, TableRow
+
 
 CATCHED_AJAX_EXCEPTIONS = (Warning, exceptions.ValidationError)
 
@@ -217,29 +236,6 @@ class ValidActionResponses(object):
     editing_mode = False
 
 
-class VirtualRow(object):
-    def __init__(self, **kw):
-        self.update(**kw)
-
-    def update(self, **kw):
-        for k, v in list(kw.items()):
-            setattr(self, k, v)
-
-    def get_row_permission(self, ar, state, ba):
-        if ba.action.readonly:
-            return True
-        return False
-
-
-class PhantomRow(VirtualRow):
-    def __init__(self, request, **kw):
-        self._ar = request
-        VirtualRow.__init__(self, **kw)
-
-    def __str__(self):
-        return str(self._ar.get_action_title())
-
-
 inheritable_attrs = frozenset(
     "user subst_user renderer requesting_panel master_instance logger".split()
 )
@@ -251,7 +247,58 @@ def bool2text(x):
     return _("No")
 
 
-class BaseRequest(object):
+
+class SearchQuerySet:
+    pass
+
+
+class SearchQuery:
+    pass
+
+
+if settings.SITE.is_installed("search"):
+    if settings.SITE.use_elasticsearch:
+        try:
+            from elasticsearch_django.models import SearchQuery
+        except ImportError:
+            pass
+    elif settings.SITE.use_solr:
+        try:
+            from haystack.query import SearchQuerySet
+        except ImportError:
+            pass
+
+WARNINGS_LOGGED = dict()
+
+
+def column_header(col):
+    # ~ if col.label:
+    # ~ return join_elems(col.label.split('\n'),sep=E.br)
+    # ~ return [unicode(col.name)]
+    label = col.get_label()
+    if label is None:
+        return col.name
+    return str(label)
+
+
+def sliced_data_iterator(qs, offset, limit):
+    # qs is either a Django QuerySet or iterable
+    # When limit is None or 0, offset cannot be -1
+    if offset is not None:
+        if isinstance(qs, QuerySet):
+            num = qs.count()
+        else:
+            num = len(qs)
+        if offset == -1:
+            page_num = num // limit
+            offset = limit * page_num
+        qs = qs[offset:num]
+    if limit is not None and limit != 0:
+        qs = qs[:limit]
+    return qs
+
+
+class BaseRequest:
     # Base class of all :term:`action requests <action request>`.
     user = None
     subst_user = None
@@ -272,23 +319,8 @@ class BaseRequest(object):
     xcallback_answers = {}
     row_meta = None
     logger = logger
-    _status = None  # cache when get_status() is called multiple times
     _alogger = None
-
-    @property
-    def alogger(self):
-        if self._alogger is None:
-            self._alogger = AttrDict(
-                {
-                    "info": sync_to_async(self.logger.info),
-                    "debug": sync_to_async(self.logger.debug),
-                    "warning": sync_to_async(self.logger.warning),
-                    "warn": sync_to_async(self.logger.warn),
-                    "error": sync_to_async(self.logger.error),
-                    "exception": sync_to_async(self.logger.exception),
-                }
-            )
-        return self._alogger
+    _status = None  # cache when get_status() is called multiple times
 
     def __init__(
         self,
@@ -297,10 +329,9 @@ class BaseRequest(object):
         hash_router=None,
         is_on_main_actor=True,
         permalink_uris=None,
-        **kw,
+        **kw
     ):
         self.response = dict()
-
         if request is not None:
             assert parent is None
             self.request = request
@@ -324,7 +355,8 @@ class BaseRequest(object):
                 else:
                     kw[k] = getattr(parent, k)
             kv = kw.setdefault("known_values", {})
-            kv.update(parent.known_values)
+            if parent.actor is self.actor:
+                kv.update(parent.known_values)
             # kw.setdefault('user', parent.user)
             # kw.setdefault('subst_user', parent.subst_user)
             # kw.setdefault('renderer', parent.renderer)
@@ -343,7 +375,9 @@ class BaseRequest(object):
         self.is_on_main_actor = is_on_main_actor
         self.permalink_uris = permalink_uris
         # self.hash_router = hash_router
+
         self.setup(**kw)
+
         if self.master is not None and settings.SITE.strict_master_check:
             if self.master_instance is None:
                 raise exceptions.BadRequest(
@@ -363,8 +397,6 @@ class BaseRequest(object):
         user=None,
         subst_user=None,
         current_project=None,
-        selected_pks=None,
-        selected_rows=None,
         master=None,
         master_instance=None,
         master_key=None,
@@ -388,9 +420,6 @@ class BaseRequest(object):
             renderer = settings.SITE.kernel.text_renderer
         self.renderer = renderer
         self.subst_user = subst_user
-        if selected_rows is not None:
-            self.selected_rows = selected_rows
-            assert selected_pks is None
         if xcallback_answers is not None:
             self.xcallback_answers = xcallback_answers
 
@@ -411,15 +440,23 @@ class BaseRequest(object):
                 )
             self.master_instance = self.actor.cast_master_instance(master_instance)
 
-        # set_selected_pks() is called when the master_instance has been set.
-        # e.g. SuggestedMovements.set_selected_pks() needs to know the voucher
-        # because the D/C of a DueMovement depends on the "target".
-
-        if selected_pks is not None:
-            self.set_selected_pks(*selected_pks)
-
         self.row_meta = dict(meta=True)
 
+    @property
+    def alogger(self):
+        if self._alogger is None:
+            self._alogger = AttrDict(
+                {
+                    "info": sync_to_async(self.logger.info),
+                    "debug": sync_to_async(self.logger.debug),
+                    "warning": sync_to_async(self.logger.warning),
+                    "warn": sync_to_async(self.logger.warn),
+                    "error": sync_to_async(self.logger.error),
+                    "exception": sync_to_async(self.logger.exception),
+                }
+            )
+        return self._alogger
+
     @contextmanager
     def capture_logger(self, level=logging.INFO):
         old_logger = self.logger
@@ -461,10 +498,64 @@ class BaseRequest(object):
         self.row_meta = dict(meta=True)
 
     def parse_req(self, request, rqdata, **kw):
-        """
-        Parse the given incoming HttpRequest and set up this action
+        """Parse the given incoming HttpRequest and set up this action
         request from it.
+
+        The `mt` url param is parsed only when needed. Usually it is
+        not needed because the `master_class` is constant and known
+        per actor. But there are exceptions:
+
+        - `master` is `ContentType`
+
+        - `master` is some abstract model
+
+        - `master` is not a subclass of Model, e.g.
+          :class:`lino_xl.lib.polls.AnswersByResponse`, a
+          virtual table that defines :meth:`get_row_by_pk
+          <lino.core.actors.Actor.get_row_by_pk>`.
+
         """
+        # logger.info("20120723 %s.parse_req() %s", self.actor, rqdata)
+        # ~ rh = self.ah
+
+        if "master_instance" not in kw:
+            kw.update(
+                master_type=rqdata.get(constants.URL_PARAM_MASTER_TYPE, None),
+                master_key=rqdata.get(constants.URL_PARAM_MASTER_PK, None),
+            )
+
+        # if settings.SITE.use_filterRow:
+        #     exclude = dict()
+        #     for f in self.ah.store.fields:
+        #         if f.field:
+        #             filterOption = rqdata.get(
+        #                 'filter[%s_filterOption]' % f.field.name)
+        #             if filterOption == 'empty':
+        #                 kw[f.field.name + "__isnull"] = True
+        #             elif filterOption == 'notempty':
+        #                 kw[f.field.name + "__isnull"] = False
+        #             else:
+        #                 filterValue = rqdata.get('filter[%s]' % f.field.name)
+        #                 if filterValue:
+        #                     if not filterOption:
+        #                         filterOption = 'contains'
+        #                     if filterOption == 'contains':
+        #                         kw[f.field.name + "__icontains"] = filterValue
+        #                     elif filterOption == 'doesnotcontain':
+        #                         exclude[f.field.name +
+        #                                 "__icontains"] = filterValue
+        #                     else:
+        #                         print("unknown filterOption %r" % filterOption)
+        #     if len(exclude):
+        #         kw.update(exclude=exclude)
+
+        if settings.SITE.use_gridfilters:
+            filter = rqdata.get(constants.URL_PARAM_GRIDFILTER, None)
+            if filter is not None:
+                filter = json.loads(filter)
+                kw["gridfilters"] = [constants.dict2kw(flt) for flt in filter]
+
+        # kw = ActionRequest.parse_req(self, request, rqdata, **kw)
         if settings.SITE.user_model:
             kw.update(user=request.user)
             kw.update(subst_user=request.subst_user)
@@ -483,10 +574,6 @@ class BaseRequest(object):
             # logger.info("20150130 b %s", tab)
             self.set_response(active_tab=tab)
 
-        if not "selected_pks" in kw and not "selected_rows" in kw:
-            selected = rqdata.getlist(constants.URL_PARAM_SELECTED)
-            kw.update(selected_pks=selected)
-
         kw.update(
             xcallback_answers={
                 id: rqdata[id]
@@ -506,6 +593,54 @@ class BaseRequest(object):
         # ~ except settings.SITE.user_model.DoesNotExist, e:
         # ~ pass
         # logger.info("20140503 ActionRequest.parse_req() %s", kw)
+
+        # if str(self.actor) == 'comments.CommentsByRFC':
+        #     print("20230426", kw)
+
+        quick_search = rqdata.get(constants.URL_PARAM_FILTER, None)
+        if quick_search:
+            kw.update(quick_search=quick_search)
+
+        sort = rqdata.get(constants.URL_PARAM_SORT, None)
+        if sort:
+            sortfld = self.actor.get_data_elem(sort)
+            if isinstance(sortfld, FakeField):
+                sort = sortfld.sortable_by
+                # sort might be None when user asked to sort a virtual
+                # field without sortable_by.
+            else:
+                sort = [sort]
+            # print("20231006 sort", sortfld, sort)
+            if sort is not None:
+
+                def si(k):
+                    if k[0] == "-":
+                        return k[1:]
+                    else:
+                        return "-" + k
+
+                sort_dir = rqdata.get(constants.URL_PARAM_SORTDIR, "ASC")
+                if sort_dir == "DESC":
+                    sort = [si(k) for k in sort]
+                    # sort = ['-' + k for k in sort]
+                # print("20171123", sort)
+                kw.update(order_by=sort)
+
+        if self.actor is not None and issubclass(self.actor, AbstractTable):
+            try:
+                offset = rqdata.get(constants.URL_PARAM_START, None)
+                if offset:
+                    kw.update(offset=int(offset))
+                limit = rqdata.get(constants.URL_PARAM_LIMIT, self.actor.preview_limit)
+                if limit:
+                    kw.update(limit=int(limit))
+            except ValueError:
+                # Example: invalid literal for int() with base 10:
+                # 'fdpkvcnrfdybhur'
+                raise SuspiciousOperation("Invalid value for limit or offset")
+
+            kw = self.actor.parse_req(request, rqdata, **kw)
+        # print("20171123 %s.parse_req() --> %s" % (self, kw))
         return kw
 
     def setup_from(self, other):
@@ -633,16 +768,17 @@ class BaseRequest(object):
         """
         # ~ print 20131003, selected_pks
         self.selected_rows = []
-        for pk in selected_pks:
-            if pk and pk != "-99998" and pk != "-99999":
-                self.selected_rows.append(self.get_row_by_pk(pk))
-        # try:
-        #     for pk in selected_pks:
-        #         if pk and pk != "-99998" and pk != "-99999":
-        #             self.selected_rows.append(self.get_row_by_pk(pk))
-        # except ObjectDoesNotExist as e:
-        #     raise exceptions.BadRequest(
-        #         "Invalid primary key {0} for {1} ({2})".format(pk, self.actor, e)) from None
+        # for pk in selected_pks:
+        #     if pk and pk != "-99998" and pk != "-99999":
+        #         self.selected_rows.append(self.get_row_by_pk(pk))
+        try:
+            for pk in selected_pks:
+                if pk and pk != "-99998" and pk != "-99999":
+                    self.selected_rows.append(self.get_row_by_pk(pk))
+        except ObjectDoesNotExist:
+            # raise exceptions.BadRequest(
+            raise ObjectDoesNotExist(
+                f"No row with primary key {pk} in {self.actor}") from None
         # self.selected_rows = filter(lambda x: x, self.selected_rows)
         # note: ticket #523 was because the GET contained an empty pk ("&sr=")
 
@@ -952,20 +1088,6 @@ class BaseRequest(object):
         # logger.info("20140430 set_content_type(%r)", ct)
         self.content_type = ct
 
-    def must_execute(self):
-        return True
-
-    def get_total_count(self):
-        """
-        TableRequest overrides this to return the number of rows.
-
-        For other requests we assume that there is one row.  This is used e.g.
-        when courses.StatusReport is shown in the the dashboard. A Report
-        returns always 1 because otherwise the dashboard believes it is empty.
-
-        """
-        return 1
-
     def get_data_value(self, obj, name):
         """
         Return the value of the virtual field `name` for this action
@@ -1015,7 +1137,7 @@ class BaseRequest(object):
         """
         return self.subst_user or self.user
 
-    def run(self, ia, *args, **kwargs):
+    def run(self, ia, *args, **kwargs):  # BaseRequest
         """
         Run the given :term:`instance action` `ia` in a child request of this
         request.
@@ -1520,43 +1642,369 @@ class ActionRequest(BaseRequest):
     - :meth:`lino.core.actors.Actor.request`
     - :meth:`lino.core.actions.Action.request`
 
-
     """
 
     create_kw = None
     renderer = None
-
     offset = None
     limit = None
     order_by = None
+    master = None
+    extra = None
+    title = None
+    filter = None
+    limit = None
+    offset = None
+
+    _data_iterator = None
+    _sliced_data_iterator = None
+    _insert_sar = None
 
     def __init__(
         self,
         actor=None,
-        unused_request=None,
         action=None,
-        unused_renderer=None,
         rqdata=None,
-        **kw,
+        **kw
     ):
         # print("20170116 ActionRequest.__init__()", actor, kw)
-        assert unused_renderer is None
-        assert unused_request is None
         self.actor = actor
         self.rqdata = rqdata
         self.bound_action = action or actor.default_action
-        BaseRequest.__init__(self, **kw)
+        super().__init__(**kw)
         if not actor.is_abstract():
             self.ah = actor.get_request_handle(self)
             # if self.ah.store is None:
             #     raise Exception("20240530 {} has no store!?".format(self.ah))
 
+    def parse_req(self, request, rqdata, **kw):
+        if not "selected_pks" in kw and not "selected_rows" in kw:
+            selected = rqdata.getlist(constants.URL_PARAM_SELECTED)
+            kw.update(selected_pks=selected)
+        return super().parse_req(request, rqdata, **kw)
+
+    def setup(
+        self,
+        known_values=None,
+        param_values=None,
+        action_param_values={},
+        quick_search=None,
+        order_by=None,
+        offset=None,
+        limit=None,
+        title=None,
+        filter=None,
+        gridfilters=None,
+        exclude=None,
+        selected_pks=None,
+        selected_rows=None,
+        extra=None,
+        **kw
+    ):
+        self.quick_search = quick_search
+        self.order_by = order_by
+        self.filter = filter
+        self.gridfilters = gridfilters
+        self.extra = extra
+
+        if title is not None:
+            self.title = title
+        if offset is not None:
+            self.offset = offset
+        if limit is not None:
+            self.limit = limit
+
+        if selected_rows is not None:
+            assert selected_pks is None
+            self.selected_rows = selected_rows
+
+        super().setup(**kw)
+
+        if self.bound_action is None:
+            return  # 20200825 e.g. a request on an abstract table
+        assert self.actor is not None
+        request = self.request
+
+        kv = dict()
+        for k, v in self.actor.known_values.items():
+            kv.setdefault(k, v)
+        if known_values:
+            kv.update(known_values)
+        self.known_values = kv
+
+        if self.actor.parameters is not None:
+            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)
+                    )
+
+            # New since 20120913.  E.g. newcomers.Newcomers is a
+            # simple pcsw.Clients with
+            # known_values=dict(client_state=newcomer) and since there
+            # is a parameter `client_state`, we override that
+            # parameter's default value.
+
+            for k, v in self.known_values.items():
+                if k in pv:
+                    pv[k] = v
+
+            # New since 20120914.  MyClientsByGroup has a `group` as
+            # master, this must also appear as `group` parameter
+            # value.  Lino now understands tables where the master_key
+            # is also a parameter.
+
+            if self.actor.master_key is not None:
+                if self.actor.master_key in pv:
+                    pv[self.actor.master_key] = self.master_instance
+            if param_values is None:
+                if self.actor.params_layout is None:
+                    pass  # 20200825 e.g. users.Users
+                    # raise Exception(
+                    #     "{} has parameters ({}) but no params_layout. {}".format(
+                    #     self.actor, self.actor.parameters, self.actor._setup_done))
+
+                elif request is not None:
+                    # call get_layout_handle to make sure that
+                    # params_store has been created:
+                    self.actor.params_layout.get_layout_handle()
+                    ps = self.actor.params_layout.params_store
+                    # print('20160329 requests.py', ps, self.actor.parameters)
+                    if ps is not None:
+                        pv.update(ps.parse_params(request))
+                    else:
+                        raise Exception(
+                            "20160329 params_layout {0} has no params_store "
+                            "in {1!r}".format(self.actor.params_layout, self.actor)
+                        )
+            else:
+                for k in param_values.keys():
+                    if k not in pv:
+                        raise Exception(
+                            "Invalid key '%s' in param_values of %s "
+                            "request (possible keys are %s)"
+                            % (k, self.actor, list(pv.keys()))
+                        )
+                pv.update(param_values)
+            # print("20160329 ok", pv)
+            self.param_values = AttrDict(**pv)
+            # self.actor.check_params(self.param_values)
+
+        action = self.bound_action.action
+        if action.parameters is not None:
+            if len(self.selected_rows) == 1:
+                apv = action.action_param_defaults(self, self.selected_rows[0])
+            else:
+                apv = action.action_param_defaults(self, None)
+                # msg = "20170116 selected_rows is {} for {!r}".format(
+                #     self.selected_rows, action)
+                # raise Exception(msg)
+            if request is not None:
+                apv.update(action.params_layout.params_store.parse_params(request))
+            self.action_param_values = AttrDict(**apv)
+            # action.check_params(action_param_values)
+            self.set_action_param_values(**action_param_values)
+        self.bound_action.setup_action_request(self)
+
+        self.actor.setup_request(self)
+
+        # if str(self.actor) == 'outbox.MyOutbox':
+        #     if self.master_instance is None:
+        #         raise Exception("20230426 b {}".format(self.master))
+
+        if issubclass(self.actor, AbstractTable):
+
+            self.exclude = exclude or self.actor.exclude
+            self.page_length = self.actor.page_length
+
+            if isinstance(self.actor.master_field, RemoteField):
+                # cannot insert rows in a slave table with a remote master
+                # field
+                self.create_kw = None
+            elif isinstance(self.master_instance, MissingRow):
+                self.create_kw = None  # 20230426
+            else:
+                self.create_kw = self.actor.get_filter_kw(self)
+
+        # set_selected_pks() needs the master_instance and the param_values to
+        # be set up. e.g. SuggestedMovements.set_selected_pks() needs to know
+        # the voucher because the D/C of a DueMovement depends on the "target".
+        # Or working.MySessionsByDay needs param_values
+
+        if selected_pks is not None:
+            # self.param_values = None
+            # print(f"20241003 {selected_pks}")
+            self.set_selected_pks(*selected_pks)
+
     def __str__(self):
         return "{0} {1}".format(self.__class__.__name__, self.bound_action)
 
     def __repr__(self):
         return "{0} {1}".format(self.__class__.__name__, self.bound_action)
 
+    def gen_insert_button(
+        self, target, button_attrs=dict(style="float: right;"), **values
+    ):
+        """
+        Generate an insert button using a cached insertable object.
+
+        This is functionally equivalent to saying::
+
+            if self.insert_action is not None:
+                ir = self.insert_action.request_from(ar)
+                if ir.get_permission():
+                    return ir.ar2button()
+
+        The difference is that gen_insert_button is more efficient when you do
+        this more than once during a single request.
+
+        `target` is the actor into which we want to insert an object.
+        `button_label` is the optional button label.
+        `values` is a dict of extra default values to apply to the insertable object.
+
+        First usage example is in :mod:`lino_xl.lib.calview`.
+
+        """
+        if self._insert_sar is None:
+            self._insert_sar = target.insert_action.request_from(self)
+        else:
+            assert self._insert_sar.actor is target
+        if self._insert_sar.get_permission():
+            st = self._insert_sar.get_status()
+            st["data_record"]["data"].update(values)
+            # obj = st['data_record']
+            # for k, v in values.items():
+            #     setattr(obj, k, v)
+            # print(20200302, st['data_record'])
+            return self._insert_sar.ar2button(**button_attrs)
+
+    def run(self, *args, **kw):
+        """
+        Runs this action request.
+        """
+        return self.bound_action.action.run_from_code(self, *args, **kw)
+
+    def execute(self):
+        """This will actually call the :meth:`get_data_iterator` and run the
+        database query.
+
+        Automatically called when either :attr:`data_iterator`
+        or :attr:`sliced_data_iterator` is accesed.
+
+        """
+        # print("20181121 execute", self.actor)
+        try:
+            self._data_iterator = self.get_data_iterator()
+        except Warning as e:
+            # ~ logger.info("20130809 Warning %s",e)
+            self.no_data_text = str(e)
+            self._data_iterator = []
+        except Exception as e:
+            if not settings.SITE.catch_layout_exceptions:
+                raise
+            # Report this exception. But since such errors may occur
+            # rather often and since exception loggers usually send an
+            # email to the local system admin, make sure to log each
+            # exception only once.
+            self.no_data_text = f"{e} (set catch_layout_exceptions to see details)"
+            self._data_iterator = []
+            w = WARNINGS_LOGGED.get(str(e))
+            if w is None:
+                WARNINGS_LOGGED[str(e)] = True
+                # raise
+                # logger.exception(e)
+                logger.warning(f"Error while executing {repr(self)}: {e}\n"
+                    "(Subsequent warnings will be silenced.)")
+
+        if self._data_iterator is None:
+            raise Exception(f"No data iterator for {self}")
+
+        if isinstance(self._data_iterator, GeneratorType):
+            # print 20150718, self._data_iterator
+            self._data_iterator = tuple(self._data_iterator)
+        if isinstance(self._data_iterator, (SearchQuery, SearchQuerySet)):
+            self._sliced_data_iterator = tuple(
+                self.actor.get_rows_from_search_query(self._data_iterator, self)
+            )
+        else:
+            self._sliced_data_iterator = sliced_data_iterator(
+                self._data_iterator, self.offset, self.limit
+            )
+        # logger.info("20171116 executed : %s", self._sliced_data_iterator)
+
+    def must_execute(self):
+        if issubclass(self.actor, AbstractTable):
+            return self._data_iterator is None
+        return True
+
+    def get_data_iterator_property(self):
+        if self._data_iterator is None:
+            self.execute()
+        return self._data_iterator
+
+    def get_sliced_data_iterator_property(self):
+        if self._sliced_data_iterator is None:
+            self.execute()
+        return self._sliced_data_iterator
+
+    data_iterator = property(get_data_iterator_property)
+    sliced_data_iterator = property(get_sliced_data_iterator_property)
+
+    def get_data_iterator(self):
+        assert issubclass(self.actor, AbstractTable)
+        self.actor.check_params(self.param_values)
+        if self.actor.get_data_rows is not None:
+            l = []
+            for row in self.actor.get_data_rows(self):
+                group = self.actor.group_from_row(row)
+                group.process_row(l, row)
+            return l
+        # ~ logger.info("20120914 tables.get_data_iterator %s",self)
+        # ~ logger.info("20120914 tables.get_data_iterator %s",self.actor)
+        # print("20181121 get_data_iterator", self.actor)
+        return self.actor.get_request_queryset(self)
+
+    def get_total_count(self):
+        """
+        Return the number of rows.
+
+        When actor is not a table, we assume that there is one row.  This is
+        used e.g. when courses.StatusReport is shown in the the dashboard. A
+        Report must return 1 because otherwise the dashboard believes it is
+        empty.
+
+        Calling `len()` on a QuerySet would execute the whole SELECT.
+        See `/blog/2012/0124`
+        """
+        if self.actor is None or not issubclass(self.actor, AbstractTable):
+            return 1
+        di = self.data_iterator
+        if isinstance(di, SearchQuery):
+            return di.total_hits
+        if isinstance(di, QuerySet):
+            return di.count()
+            # try:
+            #     return di.count()
+            # except Exception as e:
+            #     raise e.__class__("{} : {}".format(self, e))
+        # ~ if di is None:
+        # ~ raise Exception("data_iterator is None: %s" % self)
+        if True:
+            return len(di)
+        else:
+            try:
+                return len(di)
+            except TypeError:
+                raise TypeError("{0} has no length".format(di))
+
+    def __iter__(self):
+        return self.data_iterator.__iter__()
+
+    def __getitem__(self, i):
+        return self.data_iterator.__getitem__(i)
+
     def create_phantom_rows(self, **kw):
         # phantom row disturbs when there is an insert button in
         # the toolbar
@@ -1619,6 +2067,7 @@ class ActionRequest(BaseRequest):
         this request.
 
         """
+        # print("20230331 712 get_status() {}".format(self.subst_user))
         if self._status is not None and not kw:
             return self._status
         if self.actor.parameters:
@@ -1629,15 +2078,46 @@ class ActionRequest(BaseRequest):
             )
 
         kw = self.bound_action.action.get_status(self, **kw)
-
         bp = kw.setdefault("base_params", {})
-
         if self.current_project is not None:
             bp[constants.URL_PARAM_PROJECT] = self.current_project
-
         if self.subst_user is not None:
             # raise Exception("20230331")
             bp[constants.URL_PARAM_SUBST_USER] = self.subst_user.id
+        if self.quick_search:
+            bp[constants.URL_PARAM_FILTER] = self.quick_search
+
+        if self.order_by:
+            sort = self.order_by[0]
+            if sort.startswith("-"):
+                sort = sort[1:]
+                bp[constants.URL_PARAM_SORTDIR] = "DESC"
+            bp[constants.URL_PARAM_SORT] = sort
+
+        if self.known_values:
+            for k, v in self.known_values.items():
+                if self.actor.known_values.get(k, None) != v:
+                    bp[k] = v
+        if self.master_instance is not None:
+            if isinstance(self.master_instance, (models.Model, TableRow)):
+                bp[constants.URL_PARAM_MASTER_PK] = self.master_instance.pk
+                if ContentType is not None and isinstance(
+                    self.master_instance, models.Model
+                ):
+                    assert not self.master_instance._meta.abstract
+                    mt = ContentType.objects.get_for_model(
+                        self.master_instance.__class__
+                    ).pk
+                    bp[constants.URL_PARAM_MASTER_TYPE] = mt
+                # else:
+                #     logger.warning("20141205 %s %s",
+                #                    self.master_instance,
+                #                    ContentType)
+            else:  # if self.master is None:
+                # e.g. in accounting.MovementsByMatch the master is a `str`
+                bp[constants.URL_PARAM_MASTER_PK] = self.master_instance
+                # raise Exception("No master key for {} {!r}".format(
+                #     self.master_instance.__class__, self.master_instance))
         self._status = kw
         return kw
 
@@ -1707,106 +2187,6 @@ class ActionRequest(BaseRequest):
     def pk2url(self, pk):
         return self.get_detail_url(self.actor, pk)
 
-    def run(self, *args, **kw):
-        """
-        Runs this action request.
-        """
-        return self.bound_action.action.run_from_code(self, *args, **kw)
-
-    def setup(self, known_values=None, param_values=None, action_param_values={}, **kw):
-        BaseRequest.setup(self, **kw)
-        # ~ 20120111
-        # ~ self.known_values = known_values or self.report.known_values
-        # ~ if self.report.known_values:
-        # ~ d = dict(self.report.known_values)
-        kv = dict()
-        for k, v in self.actor.known_values.items():
-            kv.setdefault(k, v)
-        if known_values:
-            kv.update(known_values)
-        self.known_values = kv
-
-        request = self.request
-
-        if self.actor.parameters is not None:
-            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)
-                    )
-
-            # New since 20120913.  E.g. newcomers.Newcomers is a
-            # simple pcsw.Clients with
-            # known_values=dict(client_state=newcomer) and since there
-            # is a parameter `client_state`, we override that
-            # parameter's default value.
-
-            for k, v in self.known_values.items():
-                if k in pv:
-                    pv[k] = v
-
-            # New since 20120914.  MyClientsByGroup has a `group` as
-            # master, this must also appear as `group` parameter
-            # value.  Lino now understands tables where the master_key
-            # is also a parameter.
-
-            if self.actor.master_key is not None:
-                if self.actor.master_key in pv:
-                    pv[self.actor.master_key] = self.master_instance
-            if param_values is None:
-                if self.actor.params_layout is None:
-                    pass  # 20200825 e.g. users.Users
-                    # raise Exception(
-                    #     "{} has parameters ({}) but no params_layout. {}".format(
-                    #     self.actor, self.actor.parameters, self.actor._setup_done))
-
-                elif request is not None:
-                    # call get_layout_handle to make sure that
-                    # params_store has been created:
-                    self.actor.params_layout.get_layout_handle()
-                    ps = self.actor.params_layout.params_store
-                    # print('20160329 requests.py', ps, self.actor.parameters)
-                    if ps is not None:
-                        pv.update(ps.parse_params(request))
-                    else:
-                        raise Exception(
-                            "20160329 params_layout {0} has no params_store "
-                            "in {1!r}".format(self.actor.params_layout, self.actor)
-                        )
-            else:
-                for k in param_values.keys():
-                    if k not in pv:
-                        raise Exception(
-                            "Invalid key '%s' in param_values of %s "
-                            "request (possible keys are %s)"
-                            % (k, self.actor, list(pv.keys()))
-                        )
-                pv.update(param_values)
-            # print("20160329 ok", pv)
-            self.param_values = AttrDict(**pv)
-            # self.actor.check_params(self.param_values)
-
-        if self.bound_action is None:
-            return  # 20200825 e.g. a request on an abstract table
-
-        action = self.bound_action.action
-        if action.parameters is not None:
-            if len(self.selected_rows) == 1:
-                apv = action.action_param_defaults(self, self.selected_rows[0])
-            else:
-                apv = action.action_param_defaults(self, None)
-                # msg = "20170116 selected_rows is {} for {!r}".format(
-                #     self.selected_rows, action)
-                # raise Exception(msg)
-            if request is not None:
-                apv.update(action.params_layout.params_store.parse_params(request))
-            self.action_param_values = AttrDict(**apv)
-            # action.check_params(action_param_values)
-            self.set_action_param_values(**action_param_values)
-        self.bound_action.setup_action_request(self)
-
     def set_action_param_values(self, **action_param_values):
         apv = self.action_param_values
         for k in action_param_values.keys():
@@ -1818,121 +2198,318 @@ class ActionRequest(BaseRequest):
                 )
         apv.update(action_param_values)
 
-    def get_data_iterator(self):
-        raise NotImplementedError
-
     def get_base_filename(self):
         return str(self.actor)
         # ~ s = self.get_title()
         # ~ return s.encode('us-ascii','replace')
 
 
-class InstanceAction(object):
-    """
-    Volatile object that wraps a given action to be run on a given
-    model instance.
-
-    .. attribute:: bound_action
-
-        The bound action that will run.
-
-    .. attribute:: instance
-
-        The database object on which the action will run.
+    def to_rst(self, *args, **kw):
+        """Returns a string representing this table request in
+        reStructuredText markup.
 
-    .. attribute:: owner
-
-
-    """
-
-    def __init__(self, action, actor, instance, owner):
-        # ~ print "Bar"
-        # ~ self.action = action
-        if actor is None:
-            actor = instance.get_default_table()
-        self.bound_action = actor.get_action_by_name(action.action_name)
-        if self.bound_action is None:
-            raise Exception("%s has not action %r" % (actor, action))
-            # Happened 20131020 from lino_xl.lib.beid.eid_info() :
-            # When `use_eid_jslib` was False, then
-            # `Action.attach_to_actor` returned False.
-        self.instance = instance
-        self.owner = owner
-
-    def __str__(self):
-        return "{0} on {1}".format(self.bound_action, obj2str(self.instance))
-
-    def run_from_code(self, ar, *args, **kw):
-        """
-        Probably to be deprecated.
-        Run this action on this instance in the given session, updating
-        the response of the session.  Returns the return value of the
-        action.
         """
-        # raise Exception("20170129 is this still used?")
-        ar.selected_rows = [self.instance]
-        return self.bound_action.action.run_from_code(ar, *args, **kw)
+        stdout = sys.stdout
+        sys.stdout = StringIO()
+        self.table2rst(*args, **kw)
+        rv = sys.stdout.getvalue()
+        sys.stdout = stdout
+        return rv
 
-    def run_from_ui(self, ar, *args, **kwargs):
+    def table2rst(self, *args, **kwargs):
         """
-        Run this action on this instance in the given session, updating
-        the response of the session.  Returns nothing.
+        Print a reStructuredText representation of this table request to
+        stdout.
         """
-        # raise Exception("20170129 is this still used?")
-        # kw.update(selected_rows=[self.instance])
-        ar.selected_rows = [self.instance]
-        self.bound_action.action.run_from_ui(ar, *args, **kwargs)
+        settings.SITE.kernel.text_renderer.show_table(self, *args, **kwargs)
 
-    def request_from(self, ses, **kwargs):
+    def table2xhtml(self, **kwargs):
         """
-        Create an action request on this instance action without running
-        the action.
+        Return an HTML representation of this table request.
         """
-        kwargs.update(selected_rows=[self.instance])
-        kwargs.update(parent=ses)
-        ar = self.bound_action.request(**kwargs)
-        return ar
+        t = xghtml.Table()
+        self.dump2html(t, self.sliced_data_iterator, **kwargs)
+        e = t.as_element()
+        # print "20150822 table2xhtml", tostring(e)
+        # if header_level is not None:
+        #     return E.div(E.h2(str(self.actor.label)), e)
+        return e
 
-    def run_from_session(self, ses, **kwargs):
+    def dump2html(
+        self,
+        tble,
+        data_iterator,
+        column_names=None,
+        header_links=False,
+        max_width=None,  # ignored
+        hide_sums=None,
+    ):
         """
-        Run this instance action in a child request of given session.
+        Render this table into an existing :class:`etgen.html.Table`
+        instance.  This central method is used by all Lino
+        renderers.
 
-        Additional arguments are forwarded to the action.
-        Returns the response of the child request.
-        Doesn't modify response of parent request.
-        """
-        ar = self.request_from(ses, **kwargs)
-        self.bound_action.action.run_from_code(ar)
-        return ar.response
+        Arguments:
 
-    def __call__(self, *args, **kwargs):
-        """
-        Run this instance action in an anonymous base request.
+        `tble` An instance of :class:`etgen.html.Table`.
 
-        Additional arguments are forwarded to the action.
-        Returns the response of the base request.
-        """
-        if len(args) and isinstance(args[0], BaseRequest):
-            raise ChangedAPI("20181004")
-        ar = self.bound_action.request()
-        self.run_from_code(ar, *args, **kwargs)
-        return ar.response
+        `data_iterator` the iterable provider of table rows.  This can
+        be a queryset or a list.
 
-    def as_button_elem(self, ar, label=None, **kwargs):
-        return settings.SITE.kernel.row_action_button(
-            self.instance, ar, self.bound_action, label, **kwargs
-        )
+        `column_names` is an optional string with space-separated
+        column names.  If this is None, the table's
+        :attr:`column_names <lino.core.tables.Table.column_names>` is
+        used.
 
-    def as_button(self, *args, **kwargs):
-        """Return a HTML chunk with a "button" which, when clicked, will
-        execute this action on this instance.  This is being used in
-        the :ref:`lino.tutorial.polls`.
+        `header_links` says whether to render column headers clickable
+        with a link that sorts the table.
 
+        `hide_sums` : whether to hide sums. If this is not given, use
+        the :attr:`hide_sums <lino.core.tables.Table.hide_sums>` of
+        the :attr:`actor`.
         """
-        return tostring(self.as_button_elem(*args, **kwargs))
+        ar = self
+        tble.attrib.update(self.renderer.tableattrs)
+        tble.attrib.setdefault("name", self.bound_action.full_name())
+
+        grid = ar.ah.grid_layout.main
+        # from lino.core.widgets import GridWidget
+        # if not isinstance(grid, GridWidget):
+        #     raise Exception("20160529 %r is not a GridElement", grid)
+        columns = grid.columns
+        fields, headers, cellwidths = ar.get_field_info(column_names)
+        columns = fields
+
+        sums = [fld.zero for fld in columns]
+        if not self.ah.actor.hide_headers:
+            headers = [
+                x
+                for x in grid.headers2html(
+                    self, columns, headers, header_links, **self.renderer.cellattrs
+                )
+            ]
+            # if cellwidths and self.renderer.is_interactive:
+            if cellwidths:
+                totwidth = sum([int(w) for w in cellwidths])
+                widths = [str(int(int(w) * 100 / totwidth)) + "%" for w in cellwidths]
+                for i, td in enumerate(headers):
+                    # td.set('width', six.text_type(cellwidths[i]))
+                    td.set("width", widths[i])
+            tble.head.append(xghtml.E.tr(*headers))
+        # ~ print 20120623, ar.actor
+        recno = 0
+        for obj in data_iterator:
+            cells = ar.row2html(recno, columns, obj, sums, **self.renderer.cellattrs)
+            if cells is not None:
+                recno += 1
+                tble.body.append(xghtml.E.tr(*cells))
+
+        if recno == 0:
+            tble.clear()
+            tble.body.append(str(ar.no_data_text))
+
+        if hide_sums is None:
+            hide_sums = ar.actor.hide_sums
+
+        if not hide_sums:
+            has_sum = False
+            for i in sums:
+                if i:
+                    has_sum = True
+                    break
+            if has_sum:
+                cells = ar.sums2html(columns, sums, **self.renderer.cellattrs)
+                tble.body.append(xghtml.E.tr(*cells))
+
+    def get_field_info(ar, column_names=None):
+        """
+        Return a tuple `(fields, headers, widths)` which expresses which
+        columns, headers and widths the user wants for this
+        request. If `self` has web request info (:attr:`request` is
+        not None), checks for GET parameters cn, cw and ch.  Also
+        calls the tables's :meth:`override_column_headers
+        <lino.core.actors.Actor.override_column_headers>` method.
+        """
+        from lino.modlib.users.utils import with_user_profile
+        from lino.core.layouts import ColumnsLayout
+
+        def getit():
+            if ar.request is None:
+                columns = None
+            else:
+                data = getrqdata(ar.request)
+                columns = [str(x) for x in data.getlist(constants.URL_PARAM_COLUMNS)]
+            if columns:
+                all_widths = data.getlist(constants.URL_PARAM_WIDTHS)
+                hiddens = [
+                    (x == "true") for x in data.getlist(constants.URL_PARAM_HIDDENS)
+                ]
+                fields = []
+                widths = []
+                ah = ar.actor.get_handle()
+                for i, cn in enumerate(columns):
+                    col = None
+                    for e in ah.grid_layout.main.columns:
+                        if e.name == cn:
+                            col = e
+                            break
+                    if col is None:
+                        raise Exception(
+                            "No column named %r in %s"
+                            % (cn, ar.ah.grid_layout.main.columns)
+                        )
+                    if not hiddens[i]:
+                        fields.append(col)
+                        widths.append(int(all_widths[i]))
+            else:
+                if column_names:
+                    ll = ColumnsLayout(column_names, datasource=ar.actor)
+                    lh = ll.get_layout_handle()
+                    columns = lh.main.columns
+                    columns = [e for e in columns if not e.hidden]
+                else:
+                    ah = ar.actor.get_request_handle(ar)
+
+                    columns = ah.grid_layout.main.columns
+                    # print(20160530, ah, columns, ah.grid_layout.main)
+
+                # render them so that babelfields in hidden_languages
+                # get hidden:
+                for e in columns:
+                    e.value = e.ext_options()
+                    # try:
+                    #     e.value = e.ext_options()
+                    # except AttributeError as ex:
+                    #     raise AttributeError("20160529 %s : %s" % (e, ex))
+                #
+                columns = [e for e in columns if not e.value.get("hidden", False)]
+
+                columns = [e for e in columns if not e.hidden]
+
+                # if str(ar.actor) == "isip.ExamPolicies":
+                # from lino.modlib.extjs.elems import is_hidden_babel_field
+                # print("20180103", [c.name for c in columns])
+                # print("20180103", [c.field for c in columns])
+                # print("20180103", [c.value['hidden'] for c in columns])
+                # print("20180103", [
+                #     is_hidden_babel_field(c.field) for c in columns])
+                # print("20180103", [
+                #     getattr(c.field, '_babel_language', None)
+                #     for c in columns])
+                widths = ["%d" % (col.width or col.preferred_width) for col in columns]
+                # print("20180831 {}".format(widths))
+                # ~ 20130415 widths = ["%d%%" % (col.width or col.preferred_width) for col in columns]
+                # ~ fields = [col.field._lino_atomizer for col in columns]
+                fields = columns
+
+            headers = [column_header(col) for col in fields]
+
+            # if str(ar.actor).endswith("DailySlave"):
+            #     print("20181022", fields[0].field.verbose_name)
+
+            oh = ar.actor.override_column_headers(ar)
+            if oh:
+                for i, e in enumerate(columns):
+                    header = oh.get(e.name, None)
+                    if header is not None:
+                        headers[i] = header
+                # ~ print 20120507, oh, headers
+
+            return fields, headers, widths
+
+        u = ar.get_user()
+        if u is None:
+            return getit()
+        else:
+            return with_user_profile(u.user_type, getit)
+
+    def row2html(self, recno, columns, row, sums, **cellattrs):
+        has_numeric_value = False
+        cells = []
+        for i, col in enumerate(columns):
+            v = col.field._lino_atomizer.full_value_from_object(row, self)
+            if v is None:
+                td = E.td(**cellattrs)
+            else:
+                nv = col.value2num(v)
+                if nv != 0:
+                    sums[i] += nv
+                    has_numeric_value = True
+                td = col.value2html(self, v, **cellattrs)
+                # print("20240506 {} {}".format(col.__class__, tostring(td)))
+            col.apply_cell_format(td)
+            self.actor.apply_cell_format(self, row, col, recno, td)
+            cells.append(td)
+        if self.actor.hide_zero_rows and not has_numeric_value:
+            return None
+        return cells
+
+    def row2text(self, fields, row, sums):
+        """
+        Render the given `row` into an iteration of text cells, using the given
+        list of `fields` and collecting sums into `sums`.
+        """
+        # print(20160530, fields)
+        for i, fld in enumerate(fields):
+            if fld.field is not None:
+                sf = get_atomizer(row.__class__, fld.field, fld.field.name)
+                # print(20160530, fld.field.name, sf)
+                if False:
+                    try:
+                        getter = sf.full_value_from_object
+                        v = getter(row, self)
+                    except Exception as e:
+                        raise Exception("20150218 %s: %s" % (sf, e))
+                        # was used to find bug 20130422:
+                        yield "%s:\n%s" % (fld.field, e)
+                        continue
+                else:
+                    getter = sf.full_value_from_object
+                    v = getter(row, self)
 
-    def get_row_permission(self, ar):
-        state = self.bound_action.actor.get_row_state(self.instance)
-        # logger.info("20150202 ia.get_row_permission() %s using %s",
-        #             self, state)
-        return self.bound_action.get_row_permission(ar, self.instance, state)
+                if v is None:
+                    # if not v:
+                    yield ""
+                else:
+                    sums[i] += fld.value2num(v)
+                    # # In case you want the field name in error message:
+                    # try:
+                    #     sums[i] += fld.value2num(v)
+                    # except Exception as e:
+                    #     raise e.__class__("%s %s" % (fld.field, e))
+                    yield fld.format_value(self, v)
+
+    def sums2html(self, columns, sums, **cellattrs):
+        sums = {fld.name: sums[i] for i, fld in enumerate(columns)}
+        return [
+            fld.sum2html(self, sums, i, **cellattrs) for i, fld in enumerate(columns)
+        ]
+
+    def get_title(self):
+        # print(20200125, self.title, self.master_instance)
+        if self.title is not None:
+            return self.title
+        # if self.master_instance is not None:
+        #     self.master_instance
+        return self.actor.get_title(self)
+
+    def __repr__(self):
+        kw = dict()
+        if self.master_instance is not None:
+            kw.update(master_instance=obj2str(self.master_instance))
+        if self.filter is not None:
+            kw.update(filter=repr(self.filter))
+        if self.known_values:
+            kw.update(known_values=self.known_values)
+        if self.requesting_panel:
+            kw.update(requesting_panel=self.requesting_panel)
+        u = self.get_user()
+        if u is not None:
+            kw.update(user=u.username)
+        if False:  # self.request:
+            kw.update(request=format_request(self.request))
+        return "<%s %s(%s)>" % (
+            self.__class__.__name__,
+            self.bound_action.full_name(),
+            kw,
+        )