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

lino/core/store.py

@@ -20,7 +20,7 @@ Other usages:
 
 - render tables as text
   (:meth:`lino.core.renderer.TextRenderer.show_table` and
-  :meth:`lino.core.tablerequest.TableRequest.row2text`)
+  :meth:`lino.core.requests.ActionRequest.row2text`)
 
 """
 
@@ -45,11 +45,11 @@ from lino.core import fields
 from lino.core import actors
 from lino.core import actions
 from lino.core import frames
+from lino.core.utils import PhantomRow
 from lino.utils import choosers
 from lino.utils import curry
 from lino.utils import iif
 from lino.utils.format_date import fds
-from lino.core.requests import PhantomRow
 from lino.utils import IncompleteDate
 from lino.core.utils import DelayedValue
 
@@ -861,7 +861,7 @@ class FileFieldStoreField(StoreField):
 
 class MethodStoreField(StoreField):
     """Deprecated. See `/blog/2012/0327`.
-    Still used for display_mode 'html'.
+    Still used for DISPLAY_MODE_HTML.
     """
 
     def full_value_from_object(self, obj, ar=None):
@@ -870,7 +870,7 @@ class MethodStoreField(StoreField):
             self.name,
             unbound_meth.__code__.co_varnames,
         )
-        # print self.field.name
+        # print(f"20241003 {self.field.name} {ar} full_value_from_object()")
         return unbound_meth(obj, ar)
 
     def value_from_object(self, obj, request=None):
@@ -879,7 +879,7 @@ class MethodStoreField(StoreField):
             self.name,
             unbound_meth.__code__.co_varnames,
         )
-        # print self.field.name
+        # print(f"20241003 {self.field.name} value_from_object()")
         return unbound_meth(obj, request)
 
     # def obj2list(self,request,obj):
@@ -1192,7 +1192,7 @@ class Store(BaseStore):
         # temporary dict used by collect_fields and add_field_for
         # self.df2sf = {}
         self.all_fields = []
-        self.list_fields = []
+        self.grid_fields = []
         self.detail_fields = []
         self.card_fields = []
         self.item_fields = []
@@ -1202,11 +1202,11 @@ class Store(BaseStore):
             if not isinstance(sf, StoreField):
                 raise Exception("20210623 {} is not a StoreField".format(sf))
             self.all_fields.append(sf)
-            self.list_fields.append(sf)
+            self.grid_fields.append(sf)
             self.detail_fields.append(sf)
 
         if not issubclass(rh.actor, frames.Frame):
-            self.collect_fields(self.list_fields, rh.get_list_layout())
+            self.collect_fields(self.grid_fields, rh.get_grid_layout())
 
         form = rh.actor.detail_layout
         if form:
@@ -1235,7 +1235,7 @@ class Store(BaseStore):
         if self.pk is not None:
             self.pk_index = 0
             found = False
-            for fld in self.list_fields:
+            for fld in self.grid_fields:
                 """
                 Django's Field.__cmp__() does::
 
@@ -1251,8 +1251,8 @@ class Store(BaseStore):
                 self.pk_index += fld.list_values_count
             if not found:
                 raise Exception(
-                    "Primary key %r not found in list_fields %s"
-                    % (self.pk, [f.field for f in self.list_fields])
+                    "Primary key %r not found in grid_fields %s"
+                    % (self.pk, [f.field for f in self.grid_fields])
                 )
 
         actor_editable = True  # not rh.actor.hide_editing(None)
@@ -1273,14 +1273,14 @@ class Store(BaseStore):
             f for f in self.all_fields if not isinstance(f, VirtStoreField)
         ] + [f for f in self.all_fields if isinstance(f, VirtStoreField)]
         self.all_fields = tuple(self.all_fields)
-        self.list_fields = tuple(self.list_fields)
+        self.grid_fields = tuple(self.grid_fields)
         self.detail_fields = tuple(self.detail_fields)
         self.card_fields = tuple(self.card_fields)
         self.item_fields = tuple(self.item_fields)
 
     def collect_fields(self, fields, *layouts):
         """`fields` is a pointer to either `self.detail_fields` or
-        `self.list_fields`.  Each of these must contain a primary key
+        `self.grid_fields`.  Each of these must contain a primary key
         field.
 
         """
@@ -1370,7 +1370,7 @@ class Store(BaseStore):
 
     def column_names(self):
         l = []
-        for fld in self.list_fields:
+        for fld in self.grid_fields:
             l += fld.column_names()
         return l
 
@@ -1390,10 +1390,10 @@ class Store(BaseStore):
         # logger.info("20120107 Store %s row2list(%s)", self.report.model, dd.obj2str(row))
         l = []
         if isinstance(row, PhantomRow):
-            for fld in self.list_fields:
+            for fld in self.grid_fields:
                 fld.value2list(ar, None, l, row)
         else:
-            for fld in self.list_fields:
+            for fld in self.grid_fields:
                 if fld.delayed_value:
                     # self.actor.collect_extra_fields(fld)
                     v = DelayedValue(ar, fld.name, row)
@@ -1413,7 +1413,7 @@ class Store(BaseStore):
         for fld in fields:
             if fld is None:
                 continue
-            # logger.info("20140429 Store.row2dict %s", fld)
+            # logger.info("20241003 Store.row2dict %s", fld)
             if fld.delayed_value:
                 # self.actor.collect_extra_fields(fld)
                 v = DelayedValue(ar, fld.name, row)

lino/core/tables.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2009-2023 Rumma & Ko Ltd
+# Copyright 2009-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """Defines the classes :class:`AbstractTable` and
 :class:`VirtualTable`.
@@ -15,13 +15,13 @@ from django.db import models
 from django.db.utils import OperationalError, ProgrammingError
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _
+from django.core.exceptions import BadRequest
 
 from lino.core import actors
 from lino.core import actions
 from lino.core import fields
 from lino.core import constants
 from lino.core.utils import resolve_fields_list
-from lino.core.tablerequest import TableRequest
 
 # class InvalidRequest(Exception):
 #     pass
@@ -114,7 +114,7 @@ class TableHandle(object):
     def setup_layouts(self):
         if self._layouts is not None:
             return
-        self._layouts = [self.list_layout]
+        self._layouts = [self.grid_layout]
 
     def get_actor_url(self, *args, **kw):
         return settings.SITE.kernel.get_actor_url(self.actor, *args, **kw)
@@ -122,12 +122,12 @@ class TableHandle(object):
     def submit_elems(self):
         return []
 
-    def get_list_layout(self):
+    def get_grid_layout(self):
         self.setup_layouts()
         return self._layouts[0]
 
     def get_columns(self):
-        lh = self.get_list_layout()
+        lh = self.get_grid_layout()
         # ~ print 20110315, layout._main.columns
         return lh.main.columns
 
@@ -229,7 +229,7 @@ class AbstractTable(actors.Actor):
     it. e.g. in case they need local filtering.
 
     This will be called with a
-    :class:`lino.core.requests.TableRequest` object and is expected to
+    :class:`lino.core.requests.ActionRequest` object and is expected to
     return or yield the list of "rows"::
 
         @classmethod
@@ -315,32 +315,44 @@ class AbstractTable(actors.Actor):
     Usually such a warning means that there is something wrong.
     """
 
-    display_mode = (
-        (70, constants.DISPLAY_MODE_SUMMARY),
-        (None, constants.DISPLAY_MODE_TABLE),
-    )
+    default_display_modes = {
+        70: constants.DISPLAY_MODE_SUMMARY,
+        None: constants.DISPLAY_MODE_GRID
+    }
     """
-    A tuple of `(width, display_mode)` items used to select a :term:`display
-    mode` depending on the available width (in characters) on the client.
+    Which :term:`display mode` to use in a :term:`slave panel`,
+    depending on available width.
 
-    The last item should have a width of `None`.
-
-    See also :meth:`get_display_mode` and :ref:`dev.format`.
+    See :ref:`dg.table.default_display_modes`.
     """
 
     @classmethod
-    def get_display_mode(cls, available_width=None):
-        """Given the available width, return the :term:`display mode` to use."""
-        current_choice = (0, None)
-        for dmi in cls.display_mode:
-            if available_width is not None:
-                if dmi[0] is None and current_choice[0] == 0:
-                    current_choice = (0, dmi[1])
-                elif available_width > dmi[0] > current_choice[0]:
-                    current_choice = dmi
-            elif dmi[0] is None:
-                return dmi[1]
-        return current_choice[1]
+    # def get_display_mode(cls, available_width=None):
+    def get_display_mode(cls):
+        """Return the fallback :term:`display mode` to use."""
+        return cls.default_display_modes[None]
+        # rv = cls.default_display_modes[None]
+        # if available_width is not None:
+        #     found = None
+        #     for w, v in cls.default_display_modes.items():
+        #         if w is not None and w <= available_width:
+        #             if found is None:
+        #                 found = w
+        #                 rv = v
+        #             elif found > w:
+        #                 found = w
+        #                 rv = v
+        # return rv
+        # current_choice = (0, None)
+        # for dmi in cls.display_mode:
+        #     if available_width is not None:
+        #         if dmi[0] is None and current_choice[0] == 0:
+        #             current_choice = (0, dmi[1])
+        #         elif available_width > dmi[0] > current_choice[0]:
+        #             current_choice = dmi
+        #     elif dmi[0] is None:
+        #         return dmi[1]
+        # return current_choice[1]
 
     max_render_depth = 2
     """
@@ -613,6 +625,7 @@ method in order to sort the rows of the queryset.
                     logger.warning(msg)
                     # raise Exception(msg)
                     # raise PermissionDenied(msg)
+                    # raise BadRequest(msg)
                     # master_instance = None
                     return  # cannot add rows to this table
             kw[self.master_field.name] = master_instance
@@ -628,19 +641,20 @@ method in order to sort the rows of the queryset.
 
     @classmethod
     def request(self, master_instance=None, **kw):
-        """Return a new :class:`TableRequest
-        <lino.core.tablerequest.TableRequest>` on this table.
+        """Return a new :class:`ActionRequest
+        <lino.core.requests.ActionRequest>` on this table.
 
-        If this is a slave table, the :attr:`master_instance
-        <lino.core.tablerequest.TableRequest.master_instance>` can be
+        The :attr:`master_instance
+        <lino.core.requests.ActionRequest.master_instance>` can be
         specified as optional first positional argument.
 
         """
+        from lino.core.requests import ActionRequest
         kw.update(actor=self)
         if master_instance is not None:
             kw.update(master_instance=master_instance)
         kw.setdefault("action", self.default_action)
-        return TableRequest(**kw)
+        return ActionRequest(**kw)
 
     @classmethod
     def run_action_from_console(self, pk=None, an=None):

lino/core/utils.py

@@ -953,3 +953,137 @@ def DelayedValue(ar, fieldname, obj):
 #
 #     def __repr__(self):
 #         return "DelayedValue({})".format(self.url)
+
+
+class InstanceAction:
+    """
+    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.
+
+    .. 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)
+
+    def run_from_ui(self, ar, *args, **kwargs):
+        """
+        Run this action on this instance in the given session, updating
+        the response of the session.  Returns nothing.
+        """
+        # 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)
+
+    def request_from(self, ses, **kwargs):
+        """
+        Create an action request on this instance action without running
+        the action.
+        """
+        kwargs.update(selected_rows=[self.instance])
+        kwargs.update(parent=ses)
+        ar = self.bound_action.request(**kwargs)
+        return ar
+
+    def run_from_session(self, ses, **kwargs):
+        """
+        Run this instance action in a child request of given session.
+
+        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
+
+    def __call__(self, *args, **kwargs):
+        """
+        Run this instance action in an anonymous base request.
+
+        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
+
+    def as_button_elem(self, ar, label=None, **kwargs):
+        return settings.SITE.kernel.row_action_button(
+            self.instance, ar, self.bound_action, label, **kwargs
+        )
+
+    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`.
+
+        """
+        return tostring(self.as_button_elem(*args, **kwargs))
+
+    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)
+
+
+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())

lino/mixins/dupable.py

@@ -266,7 +266,7 @@ DupableChecker.activate()
 class SimilarObjects(dd.VirtualTable):
     """Shows the other objects that are similar to this one."""
 
-    display_mode = ((None, constants.DISPLAY_MODE_SUMMARY),)
+    default_display_modes = {None: constants.DISPLAY_MODE_SUMMARY}
     master = dd.Model
     abstract = True
 

lino/modlib/bootstrap3/views.py

@@ -23,7 +23,7 @@ from lino.core import constants
 
 # from lino.core import auth
 from lino.core.requests import BaseRequest
-from lino.core.tablerequest import TableRequest
+from lino.core.tables import AbstractTable
 from lino.core.views import action_request
 from lino.core.utils import navinfo
 from lino.utils.html import E, tostring
@@ -82,7 +82,7 @@ def table2html(ar, as_main=True):
     """Represent the given table request as an HTML table.
 
     `ar` is the request to be rendered, an instance of
-    :class:`lino.core.tablerequest.TableRequest`.
+    :class:`lino.core.requests.ActionRequest`.
 
     The returned HTML enclosed in a ``<div>`` tag and generated using
     :mod:`etgen.html`.
@@ -191,7 +191,8 @@ class List(View):
             heading=ar.get_title(),
         )
 
-        if isinstance(ar, TableRequest):
+        # if isinstance(ar, ActionRequest):
+        if ar .actor is not None and issubclass(ar.actor, AbstractTable):
             context.update(main=table2html(ar))
         else:
             context.update(main=layout2html(ar, None))

lino/modlib/checkdata/models.py

@@ -180,7 +180,7 @@ class MessagesByOwner(Messages):
 
     master_key = "owner"
     column_names = "message checker user #fixable *"
-    display_mode = ((None, constants.DISPLAY_MODE_SUMMARY),)
+    default_display_modes = {None: constants.DISPLAY_MODE_SUMMARY}
 
 
 # This was the first use case of a slave table with something else than a model

lino/modlib/comments/mixins.py

@@ -51,7 +51,7 @@ class AddCommentField(dd.VirtualField):
     """
 
     editable = True
-    simple_elem = True
+    # simple_elem = True
 
     def __init__(self, slave_table):
         t = models.TextField(_("Add comment"), blank=True)
@@ -94,7 +94,7 @@ class Commentable(MemoReferrable):
 
     create_comment_template = _("Created new {model} {obj}.")
 
-    add_comment = AddCommentField("comments.CommentsByRFC")
+    # add_comment = AddCommentField("comments.CommentsByRFC")
 
     def on_commented(self, comment, ar, cw):
         pass