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

lino/core/dbtables.py

@@ -28,14 +28,13 @@ from lino.core import actions
 from lino.core.model import Model
 from lino.core import actors
 from lino.core import constants
-from lino.core.tablerequest import TableRequest
 
 from lino.core.choicelists import ChoiceListField
 from .utils import models_by_base
 # from .fields import get_data_elem_from_model
 
 from lino.core.utils import resolve_model, get_field, UnresolvedModel
-from lino.core.tables import AbstractTable, TableRequest
+from lino.core.tables import AbstractTable
 from lino.core.gfks import ContentType, GenericForeignKey
 
 INVALID_MK = "Invalid master_key '{0}' in {1} : {2}"
@@ -129,9 +128,9 @@ def rc_name(rptclass):
     return rptclass.app_label + "." + rptclass.__name__
 
 
-def has_fk(rr, name):
-    if isinstance(rr, TableRequest):
-        return rr.actor.master_key == name
+def has_fk(ar, name):
+    if isinstance(ar, ActionRequest) and ar.actor is not None:
+        return ar.actor.master_key == name
     return False
 
 
@@ -212,7 +211,6 @@ class Table(AbstractTable):
 
     @classmethod
     def init_layouts(cls):
-        # if cls.list_layout is None:
         if cls.model is not None and issubclass(cls.model, Model):
             if not cls.abstract:
                 for tbl in cls.__mro__:
@@ -222,7 +220,7 @@ class Table(AbstractTable):
                     if issubclass(tbl, actors.Actor):
                         cls.list_layout = "list_item"
                         break
-        super(Table, cls).init_layouts()
+        super().init_layouts()
 
     @classmethod
     def add_quick_search_filter(cls, qs, search_text):
@@ -237,7 +235,7 @@ class Table(AbstractTable):
 
     @classmethod
     def get_chooser_for_field(self, fieldname):
-        ch = super(Table, self).get_chooser_for_field(fieldname)
+        ch = super().get_chooser_for_field(fieldname)
         if ch is not None:
             return ch
         if self.model is not None:
@@ -292,7 +290,7 @@ class Table(AbstractTable):
             for ds in yield_model_detail_sets(self.model):
                 yield ds
 
-        for s in super(Table, self).get_detail_sets():
+        for s in super().get_detail_sets():
             yield s
 
     # @classmethod
@@ -302,25 +300,6 @@ class Table(AbstractTable):
     # return vf
     # return cls.model._meta.get_field(name)
 
-    @classmethod
-    def get_table_story(cls, obj, ar):
-        sar = cls.request(parent=ar, master_instance=obj, is_on_main_actor=False)
-        html = mark_safe("")
-        for i, obj in enumerate(sar.data_iterator):
-            if i == cls.preview_limit:
-                break
-            s = obj.as_story_item(sar)
-            # assert_safe(s)  # temporary 20240506
-            html += s
-        if cls.insert_action is not None:
-            if not cls.editable:
-                return html
-            ir = cls.insert_action.request_from(sar)
-            if ir.get_permission():
-                html = tostring(ir.ar2button()) + html
-        # assert_safe(html)  # temporary 20240506
-        return html
-
     @classmethod
     def get_pk_field(self):
         return self.model._meta.pk
@@ -334,19 +313,28 @@ class Table(AbstractTable):
         Note: `ar` may not be None.
 
         """
-        return self.model.objects.get(pk=pk)
+        # return self.model.objects.get(pk=pk)
+        # raise Exception("20240929")
+        qs = self.get_request_queryset(ar)
         # qs = self.model.get_request_queryset(ar)
-        # try:
-        #     return qs.get(pk=pk)
-        #     # return self.get_queryset(ar).get(pk=pk)
+        # str(qs.query)
+
+        # return qs.get(pk=pk)
+        try:
+            return qs.get(pk=pk)
         # except ValueError:
         #     return None
-        # except self.model.DoesNotExist:
-        #     # import sqlparse
-        #     # sql = str(qs.query).replace('"', '')
-        #     # sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
-        #     # raise Exception("20240324 {}, {}".format(ar.param_values, sql))
-        #     return None
+        except self.model.DoesNotExist:
+            # sql = qs.query
+            # import sqlparse
+            # sql = str(sql).replace('"', '')
+            # sql = sqlparse.format(sql, reindent=True, keyword_case='upper')
+            # raise self.model.DoesNotExist(f"No row {pk} in {ar} ({sql})")
+            raise self.model.DoesNotExist(f"No row {pk} in {ar}") from None
+            # from django.core.exceptions import ObjectDoesNotExist
+            # assert isinstance(exc, ObjectDoesNotExist)
+            # raise exc
+            # return None
 
     # @classmethod
     # def disabled_actions(self, ar, obj):  # no longer used since 20170909
@@ -520,7 +508,7 @@ class Table(AbstractTable):
                     self.master_field = fk
                     # self.hidden_columns |= set([fk.name])
 
-        super(Table, self).class_init()
+        super().class_init()
 
         if self.order_by is not None:
             if not isinstance(self.order_by, (list, tuple)):
@@ -547,7 +535,7 @@ class Table(AbstractTable):
 
     @classmethod
     def do_setup(self):
-        super(Table, self).do_setup()
+        super().do_setup()
         # AbstractTable.do_setup(self)
         if self.model is None:
             return
@@ -567,7 +555,7 @@ class Table(AbstractTable):
 
     @classmethod
     def make_disabled_fields(cls, obj, ar):
-        s = super(Table, cls).make_disabled_fields(obj, ar)
+        s = super().make_disabled_fields(obj, ar)
 
         if obj is not None and ar is not None:
             s |= obj.disabled_fields(ar)
@@ -605,8 +593,7 @@ class Table(AbstractTable):
         if self.delete_action is None:
             return "No delete_action"
         if not self.get_row_permission(
-            obj, ar, self.get_row_state(obj), self.delete_action
-        ):
+            obj, ar, self.get_row_state(obj), self.delete_action):
             # print "20130222 ar is %r" % ar
             # logger.info("20130225 dbtables.disable_delete no permission")
             return _("You have no permission to delete this row.")
@@ -634,23 +621,25 @@ class Table(AbstractTable):
                 qs = qs.exclude(**ar.exclude)
                 # qs = qs.exclude(ar.exclude)
 
-            # 20200425
-            spv = dict()
-            for k in self.simple_parameters:
-                v = getattr(ar.param_values, k)
-                # if "room" in k:
-                # print("20200423", k, v, self.simple_parameters, ar.param_values)
-                if v == constants.CHOICES_BLANK_FILTER_VALUE:
-                    spv[k + "__isnull"] = True
-                elif v == constants.CHOICES_NOT_BLANK_FILTER_VALUE:
-                    spv[k + "__isnull"] = False
-                elif v is not None:
-                    spv[k] = v
-                    # print("20240506 {} = {}".format(k, v))
-                    ar.known_values[k] = v  # make it an obvious field
-
-            qs = self.model.add_param_filter(qs, **spv)
-            # qs = self.model.add_param_filter(qs, **ar.param_values)
+            if ar.param_values is not None:
+                spv = dict()
+                for k in self.simple_parameters:
+                    v = getattr(ar.param_values, k)
+                    # if "room" in k:
+                    # print("20200423", k, v, self.simple_parameters, ar.param_values)
+                    if v == constants.CHOICES_BLANK_FILTER_VALUE:
+                        spv[k + "__isnull"] = True
+                    elif v == constants.CHOICES_NOT_BLANK_FILTER_VALUE:
+                        spv[k + "__isnull"] = False
+                    elif v is not None:
+                        spv[k] = v
+                        # print("20240506 {} = {}".format(k, v))
+                        # e.g. in MyTickets 'user' should be an obvious field
+                        # 20241004 caused #5768:
+                        ar.known_values[k] = v  # make it an obvious field
+
+                qs = self.model.add_param_filter(qs, **spv)
+                # qs = self.model.add_param_filter(qs, **ar.param_values)
 
             if self.filter:
                 qs = qs.filter(self.filter)

lino/core/elems.py

@@ -854,11 +854,11 @@ class TextFieldElement(FieldElement):
 
     def get_field_options(self, **kw):
         kw = super().get_field_options(**kw)
-        if isinstance(self.field, fields.VirtualField) and self.field.simple_elem:
-            kw["virtualField"] = True
-            kw["noHeaderDecore"] = True
-            kw["noEditorHeader"] = True
-            kw["alwaysEditable"] = True
+        # if isinstance(self.field, fields.VirtualField) and self.field.simple_elem:
+        #     kw["virtualField"] = True
+        #     kw["noHeaderDecore"] = True
+        #     kw["noEditorHeader"] = True
+        #     kw["alwaysEditable"] = True
         kw["format"] = self.format
         return kw
 
@@ -2311,8 +2311,8 @@ class Panel(Container):
 
 
 class GridElement(Container):
-    """Represents a Lino.GridPanel, i.e. the widget used to represent a
-    table or a slave table.
+    """Represents a Lino.GridPanel, i.e. the widget used to render a
+    table in :term:`grid mode`.
 
     """
 
@@ -2343,14 +2343,13 @@ class GridElement(Container):
         self.actor = rpt
         if len(columns) == 0:
             self.rh = rpt.get_handle()
-            if not hasattr(self.rh, "list_layout"):
+            if not hasattr(self.rh, "grid_layout"):
                 raise Exception(
-                    "Handle for {0} (model {1}) has no list_layout".format(
+                    "Handle for {0} (model {1}) has no grid_layout".format(
                         rpt, rpt.model
                     )
                 )
-            columns = self.rh.list_layout.main.columns
-            # columns = self.rh.list_layout._main.elements
+            columns = self.rh.grid_layout.main.columns
         w = 0
         for e in columns:
             w += e.width or e.preferred_width
@@ -2433,20 +2432,15 @@ class SlaveContainer(GridElement):
     slaves = None
 
     def __init__(self, layout_handle, name, rpt, *columns, **kw):
-        dms = [dm[1] for dm in rpt.display_mode]
         slaves = dict()
-        if constants.DISPLAY_MODE_STORY in dms:
+        if constants.DISPLAY_MODE_STORY in rpt.extra_display_modes:
             slaves["story"] = get_story_element(layout_handle, rpt, name, **kw)
-        if constants.DISPLAY_MODE_LIST in dms:
+        if constants.DISPLAY_MODE_LIST in rpt.extra_display_modes:
             slaves["list"] = get_list_element(layout_handle, rpt, name, **kw)
-        # if constants.DISPLAY_MODE_HTML in dms:
-        #     slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
-        # if constants.DISPLAY_MODE_SUMMARY in dms:
-        #     slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
-        # slaves["story"] = get_story_element(layout_handle, rpt, name, **kw)
-        # slaves["list"] = get_list_element(layout_handle, rpt, name, **kw)
-        slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
-        slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
+        if constants.DISPLAY_MODE_SUMMARY in rpt.extra_display_modes:
+            slaves["summary"] = get_summary_element(layout_handle, rpt, name, **kw)
+        if constants.DISPLAY_MODE_HTML in rpt.extra_display_modes:
+            slaves["html"] = get_htmlbox_element(layout_handle, rpt, name, **kw)
         if slaves:
             self.slaves = slaves
         super().__init__(layout_handle, name, rpt, *columns, **kw)
@@ -2845,13 +2839,11 @@ def create_layout_element(lh, name, **kw):
 
         # print("20240317", de, lh)
         if isinstance(lh.layout, FormLayout):
-            # When a table is specified in the layout of a
-            # DetailWindow, then it will be rendered as a panel that
-            # displays a "summary" of that table. The panel will have
-            # a tool button to "open that table in its own
-            # window". The format of that summary is defined by the
-            # `display_mode` of the table.
-
+            # When a table is specified in the layout of a DetailWindow, then it
+            # will be rendered as a :term:`slave panel`. The panel will have a
+            # tool button to "open that table in its own window". The display
+            # mode of that summary is defined by the `default_display_modes` of
+            # the table.
             if lh.ui.renderer.extjs_version is not None:
                 if de.label is not None:
                     js = (
@@ -2871,17 +2863,18 @@ def create_layout_element(lh, name, **kw):
                     kw.update(label="{} {}".format(de.get_label(), tostring(btn)))
 
             if (
-                len(de.display_mode) > 1
+                len(de.default_display_modes) > 1
                 and lh.ui.renderer.front_end.media_name == "react"
             ):
+                # print(f"20240928 {de} in {lh} gets SlaveContainer")
                 return SlaveContainer(lh, name, de, **kw)
 
             dm = de.get_display_mode()
-            if dm in [
-                constants.DISPLAY_MODE_TABLE,
+            if dm in {
+                constants.DISPLAY_MODE_GRID,
                 constants.DISPLAY_MODE_CARDS,
                 constants.DISPLAY_MODE_GALLERY
-            ]:
+            }:
                 kw.update(hide_top_toolbar=True)
                 if de.preview_limit is not None:
                     kw.update(preview_limit=de.preview_limit)

lino/core/fields.py

@@ -322,7 +322,7 @@ class FakeField(object):
             setattr(self, k, v)
 
     def __repr__(self):
-        # copied from django Field 
+        # copied from django Field
         path = "%s.%s" % (self.__class__.__module__, self.__class__.__qualname__)
         name = getattr(self, "name", None)
         if name is not None:
@@ -561,10 +561,10 @@ class VirtualField(FakeField):
     (because they inherit from that class).
     """
 
-    simple_elem = False
-    """
-    Used in :meth:`get_field_options` to set :term:`front end` rendering options.
-    """
+    # simple_elem = False
+    # """
+    # Used in :meth:`get_field_options` to set :term:`front end` rendering options.
+    # """
 
     def __init__(self, return_type, get=return_none, **kwargs):
         """
@@ -579,7 +579,7 @@ class VirtualField(FakeField):
         self.return_type = return_type  # a Django Field instance
         self.get = get
 
-        self.simple_elem = kwargs.get("simple_elem", self.simple_elem)
+        # self.simple_elem = kwargs.get("simple_elem", self.simple_elem)
 
         # if isinstance(return_type, FakeField):
         #     sortable_by = return_type.sortable_by
@@ -1217,6 +1217,12 @@ class TableRow(object):
 
     _lino_default_table = None
     _widget_options = {}
+    extra_display_modes = None
+    """
+    A set of extra display modes to make available on actors that use this model.
+
+    See :ref:`dg.dd.table.extra_display_modes`.
+    """
 
     pk = None
 
@@ -1363,7 +1369,7 @@ class TableRow(object):
         return tostring(self.as_summary_item(ar, **kwargs))
 
     def as_story_item(self, ar, **kwargs):
-        kwargs.update(display_mode="story")
+        kwargs.update(display_mode=constants.DISPLAY_MODE_STORY)
         return mark_safe("".join(self.as_page(ar, **kwargs)))
 
     def as_page(self, ar, **kwargs):

lino/core/kernel.py

@@ -877,12 +877,12 @@ class Kernel(object):
 
         if isinstance(h, tables.TableHandle):
             he = set(h.actor.hidden_columns | h.actor.hidden_elements)
-            ll = layouts.ColumnsLayout(
+            gl = layouts.ColumnsLayout(
                 h.actor.get_column_names(ar), h.actor, hidden_elements=he
             )
-            h.list_layout = ll.get_layout_handle()
+            h.grid_layout = gl.get_layout_handle()
         else:
-            h.list_layout = None
+            h.grid_layout = None
 
         if h.actor.params_layout:
             h.params_layout_handle = h.actor.make_params_layout_handle()

lino/core/model.py

@@ -33,7 +33,8 @@ from .utils import obj2unicode
 from .utils import class_dict_items
 from .signals import receiver, on_ui_created, pre_ui_delete, pre_ui_save, post_ui_save
 from .workflows import ChangeStateAction
-from .tablerequest import TableRequest, sliced_data_iterator
+from .requests import ActionRequest, sliced_data_iterator
+from .tables import AbstractTable
 
 try:
     import bleach
@@ -633,7 +634,8 @@ class Model(models.Model, fields.TableRow):
 
     @fields.htmlbox()
     def navigation_panel(self, ar):
-        if not isinstance(ar, TableRequest):
+        # if not isinstance(ar, ActionRequest):
+        if ar is None or ar.actor is None or not issubclass(ar.actor, AbstractTable):
             return None
         items = []
         navinfo = ar.actor.get_navinfo(ar, self)
@@ -937,6 +939,7 @@ LINO_MODEL_ATTRIBS = (
     "save_watched_instance",
     "save_existing_instance",
     "_widget_options",
+    "extra_display_modes",
     "set_widget_options",
     "get_widget_options",
     "get_chooser_for_field",

lino/core/renderer.py

@@ -197,7 +197,7 @@ class HtmlRenderer(Renderer):
         import rstgen
 
         if display_mode == constants.DISPLAY_MODE_CARDS:
-            layout = ar.actor.card_layout or actor.list_layout
+            layout = ar.actor.card_layout or ar.actor.list_layout
             lh = layout.get_layout_handle()
         else:
             lh = ar.bound_action.get_layout_handel()
@@ -275,14 +275,18 @@ class HtmlRenderer(Renderer):
         Silently ignores the parameters `stripped` and `header_links`
         since for HTML these options have no meaning.
         """
-        # print("20231227")
         if display_mode is None:
             display_mode = ar.actor.get_display_mode()
-        # yield E.p(display_mode)
-        if not nosummary:
-            if display_mode == constants.DISPLAY_MODE_SUMMARY:
-                yield ar.actor.get_table_summary(ar.master_instance, ar)
-                return
+            if nosummary and display_mode == constants.DISPLAY_MODE_SUMMARY:
+                display_mode = constants.DISPLAY_MODE_GRID
+        else:
+            assert display_mode in ar.actor.extra_display_modes | constants.BASIC_DISPLAY_MODES
+            if nosummary:
+                raise Exception("Both nosummary and display_mode were specified")
+
+        if display_mode == constants.DISPLAY_MODE_SUMMARY:
+            yield ar.actor.get_table_summary(ar.master_instance, ar)
+            return
 
         if header_level is not None:
             k = "h" + str(header_level)
@@ -294,6 +298,10 @@ class HtmlRenderer(Renderer):
             yield ar.actor.get_table_as_list(ar.master_instance, ar)
             return
 
+        if display_mode == constants.DISPLAY_MODE_STORY:
+            yield ar.actor.get_table_story(ar.master_instance, ar)
+            return
+
         yield ar.table2xhtml(**kwargs)
 
         # if show_toolbar:
@@ -434,7 +442,7 @@ class HtmlRenderer(Renderer):
     def quick_add_buttons(self, ar):
         """Returns a HTML chunk that displays "quick add buttons" for the
         given :class:`action request
-        <lino.core.dbtables.TableRequest>`: a button :guilabel:`[New]`
+        <lino.core.request.ActionRequest>`: a button :guilabel:`[New]`
         followed possibly (if the request has rows) by a
         :guilabel:`[Show last]` and a :guilabel:`[Show all]` button.
 
@@ -621,7 +629,7 @@ class HtmlRenderer(Renderer):
 
         """
         from lino.core.actors import Actor
-        from lino.core.tables import TableRequest
+        from lino.core.tables import AbstractTable
         from lino.core.requests import ActionRequest
         # print(f"20240908 show_story {ar}")
 
@@ -638,19 +646,18 @@ class HtmlRenderer(Renderer):
                     ar = item.default_action.request(parent=ar)
                     # 20200501 elems.extend(self.table2story(ar, **kwargs))
                     elems += [tostring(e) for e in self.table2story(ar, **kwargs)]
-                elif isinstance(item, TableRequest):
-                    # print(f"20240908 TableRequest {item}")
-                    assert item.renderer is not None
-                    # 20200501 elems.extend(self.table2story(item, **kwargs))
-                    elems += [tostring(e)
-                        for e in self.table2story(item, **kwargs)]
                 elif isinstance(item, ActionRequest):
-                    # example : courses.StatusReport in dashboard
                     assert item.renderer is not None
-                    # 20200501 elems.append(self.show_story(ar, item.actor.get_story(None, ar), **kwargs))
-                    elems += [tostring(e)
-                        for e in self.show_story(
-                            ar, item.actor.get_story(None, ar), **kwargs)]
+                    if issubclass(item.actor, AbstractTable):
+                        # 20200501 elems.extend(self.table2story(item, **kwargs))
+                        elems += [tostring(e)
+                            for e in self.table2story(item, **kwargs)]
+                    else:
+                        # example : courses.StatusReport in dashboard
+                        # 20200501 elems.append(self.show_story(ar, item.actor.get_story(None, ar), **kwargs))
+                        elems += [tostring(e)
+                            for e in self.show_story(
+                                ar, item.actor.get_story(None, ar), **kwargs)]
                 elif isinstance(item, DashboardItem):
                     elems.extend(item.render(ar, **kwargs))
                     # elems += [tostring(e) for e in item.render(ar, **kwargs)]
@@ -810,7 +817,7 @@ class TextRenderer(HtmlRenderer):
         stripped=True,
         show_urls=False,
         display_mode=None,
-        **kwargs,
+        **kwargs
     ):
         """
         Render the given table request as reStructuredText to stdout.  See
@@ -819,19 +826,24 @@ class TextRenderer(HtmlRenderer):
         self.show_urls = show_urls
         if display_mode is None:
             display_mode = ar.actor.get_display_mode()
-            # display_mode = [dmi[1] for dmi in ar.actor.display_mode if dmi[0] is None][0]
-        # if ar.actor.master is not None and not nosummary:
+            if nosummary and display_mode == constants.DISPLAY_MODE_SUMMARY:
+                display_mode = constants.DISPLAY_MODE_GRID
+        else:
+            if display_mode not in ar.actor.extra_display_modes | constants.BASIC_DISPLAY_MODES:
+                raise Exception(f"Invalid display mode {display_mode} for {ar.actor}")
+            if nosummary:
+                raise Exception("Both nosummary and display_mode were specified")
+        # print(f"20240929 {nosummary} {display_mode} {ar}")
         # yield "20240506 {}".format(ar)
-        if not nosummary:
-            if display_mode == constants.DISPLAY_MODE_SUMMARY:
-                s = to_rst(
-                    ar.actor.get_table_summary(ar.master_instance, ar),
-                    stripped=stripped,
-                )
-                if stripped:
-                    s = s.strip()
-                yield s
-                return
+        if display_mode == constants.DISPLAY_MODE_SUMMARY:
+            s = to_rst(
+                ar.actor.get_table_summary(ar.master_instance, ar),
+                stripped=stripped,
+            )
+            if stripped:
+                s = s.strip()
+            yield s
+            return
 
         if display_mode == constants.DISPLAY_MODE_CARDS:
             for row in ar.sliced_data_iterator:
@@ -919,7 +931,7 @@ class TextRenderer(HtmlRenderer):
     def show_story(self, ar, story, stripped=True, **kwargs):
         """Render the given story as reStructuredText to stdout."""
         from lino.core.actors import Actor
-        from lino.core.tables import TableRequest
+        from lino.core.tables import AbstractTable
         from lino.core.requests import ActionRequest
 
         try:
@@ -931,13 +943,14 @@ class TextRenderer(HtmlRenderer):
                     self.show_table(ar, stripped=stripped, **kwargs)
                 elif isinstance(item, DashboardItem):
                     self.show_story(ar, item.get_story(ar), stripped, **kwargs)
-                elif isinstance(item, TableRequest):
-                    self.show_table(item, stripped=stripped, **kwargs)
-                    # print(item.table2rst(*args, **kwargs))
                 elif isinstance(item, ActionRequest):
-                    # example : courses.StatusReport in dashboard
                     assert item.renderer is not None
-                    self.show_story(ar, item.actor.get_story(None, ar), **kwargs)
+                    if issubclass(item.actor, AbstractTable):
+                        self.show_table(item, stripped=stripped, **kwargs)
+                        # print(item.table2rst(*args, **kwargs))
+                    else:
+                        # example : courses.StatusReport in dashboard
+                        self.show_story(ar, item.actor.get_story(None, ar), **kwargs)
                 elif isiterable(item):
                     self.show_story(ar, item, stripped, **kwargs)
                     # for i in self.show_story(ar, item, *args, **kwargs):