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

lino/__init__.py

@@ -26,11 +26,7 @@ defines no models, some template files, a series of :term:`django-admin commands
 
 """
 
-__version__ = '24.9.4'
-
-# from __future__ import unicode_literals
-# from __future__ import absolute_import
-# from builtins import str
+__version__ = '24.10.1'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/doctest.py

@@ -7,9 +7,9 @@ A selection of names to be used in tested documents.
 
 import six  # TODO: remove here and then run all doctests
 import logging
-import django
 import sqlparse
-
+from urllib.parse import urlencode
+import django
 django.setup()
 from lino.core.constants import *
 from lino.api.shell import *
@@ -63,12 +63,18 @@ HttpQuery = collections.namedtuple(
 
 def get_json_dict(username, uri, an="detail", **kwargs):
     url = "/api/{0}?fmt=json&an={1}".format(uri, an)
-    for k, v in kwargs.items():
-        url += "&{}={}".format(k, v)
+    if kwargs:
+        url += "&" + urlencode(kwargs, True)
+    # for k, v in kwargs.items():
+    #     url += "&{}={}".format(k, v)
     test_client.force_login(rt.login(username).user)
     res = test_client.get(url, REMOTE_USER=username)
     assert res.status_code == 200
-    return json.loads(res.content.decode())
+    s = res.content.decode()
+    try:
+        return json.loads(s)
+    except Exception as e:
+        raise Exception(f"GET {url} got non-JSON response:\n{s}") from None
 
 
 def get_json_soup(username, uri, fieldname, **kwargs):
@@ -314,7 +320,7 @@ def get_fields(model, fieldnames=None, columns=None):
             get_field = model.get_data_elem
             if fieldnames is None:
                 fieldnames = model.column_names
-                # get_handle().list_layout.main.columns
+                # get_handle().grid_layout.main.columns
         else:
             get_field = model.parameters.get
             if fieldnames is None:
@@ -773,3 +779,20 @@ def show_change_watchers():
                 [full_model_name(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
             )
     print(table(headers, rows, max_width=40))
+
+def show_display_modes():
+    """
+    Show the availble display modes per actor.
+    """
+    dml = sorted(constants.DISPLAY_MODES - constants.BASIC_DISPLAY_MODES)
+    headers = ["actor"]
+    headers += dml
+    rows = []
+    for a in sorted(actors.actors_list, key=str):
+        if not a.is_abstract():
+            rows.append(
+                [str(a)] + [
+                    ("x" if dm in a.extra_display_modes else "")
+                        for dm in dml]
+            )
+    print(table(headers, rows))

lino/core/__init__.py

@@ -39,7 +39,6 @@ For some modules the documentation has already been migrated to prosa:
     signals
     store
     tables
-    tablerequest
     urls
     userprefs
     user_types

lino/core/actions.py

@@ -33,7 +33,7 @@ from .utils import resolve_model
 from .utils import navinfo
 from .utils import Parametrizable
 from .utils import traverse_ddh_fklist
-from .requests import InstanceAction
+from .utils import InstanceAction
 
 
 def discover_choosers():
@@ -85,7 +85,10 @@ def resolve_layout(cls, k, spec, layout_class, **options):
 def install_layout(cls, k, layout_class, **options):
     """
     - `cls` is the actor (a class object)
-    - `k` is one of 'detail_layout', 'insert_layout', 'params_layout', 'card_layout', 'list_layout'
+
+    - `k` is one of 'grid_layout', 'detail_layout', 'insert_layout',
+      'params_layout', 'card_layout', 'list_layout'
+
     - `layout_class`
 
     """
@@ -437,6 +440,8 @@ class Action(Parametrizable, Permittable):
     On actions that opens_a_window this must be a unique one-letter
     string expressing the window type.
 
+    See `constants.WINDOW_TYPES`.
+
     Allowed values are:
 
     - None : opens_a_window is False
@@ -486,6 +491,12 @@ class Action(Parametrizable, Permittable):
 
         register_params(self)
 
+        if self.callable_from is not None:
+            for c in self.callable_from:
+                if not c in constants.WINDOW_TYPES:
+                    raise Exception(f"Invalid window_type spec {c} in {self}")
+
+
     def __get__(self, instance, owner):
         """
         When a model has an action "foo", then getting an attribute
@@ -785,7 +796,7 @@ class ShowTable(TableAction):
     use_param_panel = True
     show_in_workflow = False
     opens_a_window = True
-    window_type = "t"
+    window_type = constants.WINDOW_TYPE_TABLE
     action_name = "grid"
     select_rows = False
     callable_from = None
@@ -809,7 +820,7 @@ class ShowDetail(Action):
     icon_name = "application_form"
     ui5_icon_name = "sap-icon://detail-view"
     opens_a_window = True
-    window_type = "d"
+    window_type = constants.WINDOW_TYPE_DETAIL
     show_in_workflow = False
     save_action_name = "submit_detail"
     callable_from = "t"
@@ -893,7 +904,7 @@ class ShowInsert(TableAction):
     show_in_workflow = False
     show_in_side_toolbar = True
     opens_a_window = True
-    window_type = "i"
+    window_type = constants.WINDOW_TYPE_INSERT
     hide_navigator = True  # 20210509
     hide_top_toolbar = True  # 20210509
     sort_index = 10
@@ -1342,11 +1353,7 @@ class DeleteSelected(MultipleRowAction):
     sort_index = 30
     readonly = False
     show_in_workflow = False
-    # required_roles = set([SiteUser])
-    # ~ callable_from = (ShowTable,ShowDetail)
-    # ~ needs_selection = True
     label = _("Delete")
-    # ~ url_action_name = 'delete'
     hotkey = keyboard.DELETE  # (ctrl=True)
 
     # ~ client_side = True

lino/core/actors.py

@@ -27,10 +27,10 @@ from lino.utils import MissingRow
 from lino.core import fields
 from lino.core import actions
 from lino.core import layouts
-from lino.core.requests import ActionRequest
+from lino.core import constants
 from lino.core.boundaction import BoundAction
 from lino.core.exceptions import ChangedAPI
-from lino.core.constants import _handle_attr_name, CHOICES_BLANK_FILTER_VALUE
+from lino.core.constants import _handle_attr_name
 from lino.core.permissions import add_requirements, Permittable
 from lino.core.utils import resolve_model
 from lino.core.utils import error2str
@@ -162,22 +162,12 @@ class ActorMetaClass(type):
 
         cls = super().__new__(meta, classname, bases, classDict)
 
-        # ~ if not classDict.has_key('label'):
-        # ~ cls.label = ClassProperty(cls.get_actor_label)
-        # ~ meta.label = property(cls.get_actor_label.im_func) # 20130906
-        # ~ if not classDict.has_key('known_values'):
-        # ~ cls.known_values = ClassProperty(cls.get_known_values)
-        # ~ meta.known_values = property(cls.get_known_values.im_func) # 20130906
-        """
-        On 20110822 I thought "A Table always gets the app_label of its model,
-        you cannot set this yourself in a subclass
-        because otherwise it gets complex when inheriting reports from other
-        app_labels."
-        On 20110912 I cancelled change 20110822 because PersonsByOffer
-        should clearly get app_label 'jobs' and not 'contacts'.
-
-        """
-
+        # On 20110822 I thought "A Table always gets the app_label of its model,
+        # you cannot set this yourself in a subclass
+        # because otherwise it gets complex when inheriting reports from other
+        # app_labels."
+        # On 20110912 I cancelled change 20110822 because PersonsByOffer
+        # should clearly get app_label 'jobs' and not 'contacts'.
         if classDict.get("app_label", None) is None:
             # Figure out the app_label by looking one level up.
             # For 'django.contrib.sites.models', this would be 'sites'.
@@ -291,7 +281,17 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     # """
 
     only_fields = None
-    display_mode = None
+
+    default_display_modes = None
+
+    # extra_display_modes = set()
+    # extra_display_modes = {constants.DISPLAY_MODE_SUMMARY}
+    extra_display_modes = {constants.DISPLAY_MODE_HTML}
+    """
+    A set of additional display modes to make available when rendering this table.
+
+    See :ref:`dg.dd.table.extra_display_modes`.
+    """
 
     app_label = None
     """
@@ -428,6 +428,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
     default_action = None
     actor_id = None
 
+    grid_layout = None
     detail_layout = None
     insert_layout = None
     card_layout = None
@@ -730,8 +731,12 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
 
         if hasattr(cls, "required"):
             raise ChangedAPI(
-                "{0} must convert `required` to `required_roles`".format(cls)
+                f"{cls} must convert `required` to `required_roles`"
             )
+        if hasattr(cls, "display_mode"):
+            # cls.default_display_modes = {k:v for k, v in cls.display_mode}
+            # logger.info(f"{cls} uses deprecated `display_mode`, please convert to `default_display_modes`.")
+            raise ChangedAPI(f"{cls} must convert `display_mode` to `default_display_modes`")
 
         master = getattr(cls, "master", None)
         if isinstance(master, str):
@@ -760,6 +765,45 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                     cls.virtual_fields["detail_link"] = de
                     # cls.add_virtual_field('detail_link', de)
 
+        if cls.abstract:
+            return
+
+        edm = set()  # extra display modes to add automatically
+        if cls.default_display_modes is not None:
+            for v in cls.default_display_modes.values():
+                if v not in constants.DISPLAY_MODES:
+                    raise Exception(f"Invalid display mode {v} in {cls}")
+                if v not in constants.BASIC_DISPLAY_MODES:
+                    # be sure to have our copy the extra_display_modes set
+                    # if str(cls) == "comments.Comments":
+                    #     print(f"20240929 extra_display_modes is {cls.extra_display_modes}, we add {v}")
+                    # cls.extra_display_modes = cls.extra_display_modes | {v}
+                    edm.add(v)
+
+        if cls.card_layout is not None:
+            edm.add(constants.DISPLAY_MODE_CARDS)
+        if 'row_as_paragraph' in cls.__dict__:
+            edm.add(constants.DISPLAY_MODE_LIST)
+        # if 'row_as_page' in cls.__dict__:
+        #     edm.add(constants.DISPLAY_MODE_STORY)
+        if model is not None:
+            if model.extra_display_modes is not None:
+                for v in model.extra_display_modes:
+                    if v not in constants.DISPLAY_MODES:
+                        raise Exception(f"Invalid display mode {v} in {model}.extra_display_modes")
+                edm |= model.extra_display_modes
+            if 'as_paragraph' in model.__dict__:
+                edm.add(constants.DISPLAY_MODE_LIST)
+            if 'as_page' in model.__dict__:
+                edm.add(constants.DISPLAY_MODE_STORY)
+            # no need to automatically add summary because it's in default_display_modes of every table
+            # if 'as_summary_item' in model.__dict__:
+            #     edm.add(constants.DISPLAY_MODE_SUMMARY)
+        if len(edm) > 0:
+            # if str(cls) == "comments.Comments":
+            #     print(f"20240929 {cls} extra_display_modes add {edm}")
+            cls.extra_display_modes = cls.extra_display_modes | edm
+
     @classmethod
     def init_layouts(cls):
         # 20200430 this was previously part of class_init, but is now called in
@@ -1238,7 +1282,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
                 yield t
         for k in self.simple_parameters:
             v = getattr(ar.param_values, k)
-            if v and v != CHOICES_BLANK_FILTER_VALUE:
+            if v and v != constants.CHOICES_BLANK_FILTER_VALUE:
                 if v is True:
                     # For BooleanField no need to add "True" in the title
                     yield str(self.parameters[k].verbose_name)
@@ -1605,10 +1649,10 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         return wl.get_layout_handle()
 
     @classmethod
-    def get_list_layout(cls, *args):
+    def get_grid_layout(cls, *args):
         assert cls.default_action is not None
         ah = cls.get_handle()
-        return ah.get_list_layout()
+        return ah.get_grid_layout()
 
     @classmethod
     def get_detail_elems(cls):
@@ -1739,6 +1783,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         Return an action request on this actor.
         """
         kw.update(actor=self)
+        from lino.core.requests import ActionRequest
         return ActionRequest(*args, **kw)
 
     @classmethod
@@ -1788,11 +1833,16 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         # welfare/docs/specs/weleup/weleup1r.rst
         # kwargs.update(request=ar.request)
         kwargs.update(parent=ar)
-
-        ar = cls.request(master, **kwargs)
-        ar.renderer = settings.SITE.kernel.default_renderer
-        el = ar.table2xhtml()
-        toolbar = ar.plain_toolbar_buttons()
+        kwargs.update(renderer=settings.SITE.kernel.default_renderer)
+        try:
+            ar = cls.request(master_instance=master, **kwargs)
+            el = ar.table2xhtml()
+            toolbar = ar.plain_toolbar_buttons()
+        except Exception as e:
+            msg = f"20241004 Error in {repr(ar)}: {e}"
+            raise Exception(msg) from e
+            logger.warning(msg)
+            return msg
         if len(toolbar):
             el = E.div(el, E.p(*toolbar))
         return el
@@ -1831,6 +1881,25 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         # assert_safe(html_text)  # temporary 20240506
         return format_html(DIVTPL, html_text)
 
+    @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_table_summary(cls, obj, ar):
         """
@@ -1892,7 +1961,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         if ar is None:
             return str(self)
         # cols = ar.actor.get_detail_layout().main
-        cols = cls.get_list_layout().main.columns
+        cols = cls.get_grid_layout().main.columns
         cols = [c for c in cols if not c.value.get("hidden")]
         if fmt is None:
 
@@ -1914,7 +1983,7 @@ class Actor(actions.Parametrizable, Permittable, metaclass=ActorMetaClass):
         values = [v for v in values if v is not None]
         s = ", ".join(values)
         # s = str(ar.actor)
-        # print("20231218", s)  # self, ar.actor.get_list_layout().main.columns)
+        # print("20231218", s)  # self, ar.actor.get_grid_layout().main.columns)
         return s
 
     @classmethod

lino/core/choicelists.py

@@ -368,28 +368,43 @@ class ChoiceList(with_metaclass(ChoiceListMeta, tables.AbstractTable)):
     """A string with the name of a choice to be used as default value for
     fields using this list.
 
+    Usage example in :mod:`lino_xl.lib.clients.models`::
+
+        class ClientStates(dd.Workflow):
+            required_roles = dd.login_required(ContactsStaff)
+            verbose_name_plural = _("Client states")
+            default_value = 'newcomer'
+
+        add = ClientStates.add_item
+        add('10', _("Newcomer"), 'newcomer')
+        add('20', _("Refused"), 'refused')
+        add('30', _("Coached"), 'coached')
+        add('50', _("Former"), 'former')
+
+    And :mod:`lino_avant.lib.avanti.models` overrides it::
+
+        from lino_xl.lib.clients.choicelists import ClientStates
+        ClientStates.default_value = 'coached'
+
     Note that this specifies the *default* default value for *all*
     :class:`ChoiceListField <lino.core.choicelists.ChoiceListField>`
     of this choicelist, including parameter fields.
 
+    The disadvantage is that when somebody *does not* want your default value,
+    then they must explicitly specify `default=''` when defining a field on your
+    choicelist.
+
     You can remove that "default default value" for all tables by
     specifying `default=''`. There are two places where you can
     specify this: (a) on the parameter field itself (which then
     applies to all subtables) or (b) just on one table. For example
     (excerpt from :mod:`lino_avanti.lib.avanti`)::
 
-        from lino_xl.lib.clients.choicelists import ClientStates
-        ClientStates.default_value = 'coached'
-
         parameters = ObservedDateRange(
             ...
             client_state=ClientStates.field(blank=True, default=''))
 
-    Note that the default values of parameter fields of a table that
-    is used as the *models default table* will apply for the choices
-    of pointers to that model. Concrete use case is the choicelist of
-    `cal.Guest.partner` in :ref:`avanti`, which should show only
-    coached clients.  So instead of above code we actually now do::
+    Example for (b)::
 
         class MyClients(My, Clients):
             @classmethod
@@ -398,9 +413,11 @@ class ChoiceList(with_metaclass(ChoiceListMeta, tables.AbstractTable)):
                 kw.update(client_state='')
                 return kw
 
-    The disadvantage is that when somebody *does not* want your default value,
-    then they must explicitly specify `default=''` when defining a field on your
-    choicelist.
+    Note that the default values of parameter fields of a table that
+    is used as the *model's default table* will apply for the choices
+    of pointers to that model. Concrete use case is the choicelist of
+    `cal.Guest.partner` in :ref:`avanti`, which we want to show only
+    coached clients.
 
     """
 

lino/core/constants.py

@@ -47,22 +47,38 @@ URL_PARAM_WINDOW_TYPE = "wt"
 
 WINDOW_TYPE_TABLE = "t"
 WINDOW_TYPE_DETAIL = "d"
-WINDOW_TYPE_CARDS = "c"
-WINDOW_TYPE_GALLERIA = "g"
 WINDOW_TYPE_INSERT = "i"
 WINDOW_TYPE_PARAMS = "p"
 
+WINDOW_TYPES = {
+    WINDOW_TYPE_TABLE, WINDOW_TYPE_DETAIL, WINDOW_TYPE_INSERT,
+    WINDOW_TYPE_PARAMS
+}
+
 URL_PARAM_DISPLAY_MODE = "dm"
 
-DISPLAY_MODE_TABLE = "grid"  # deprecated
 DISPLAY_MODE_GRID = "grid"
 DISPLAY_MODE_DETAIL = "detail"
+DISPLAY_MODE_HTML = "html"
 DISPLAY_MODE_SUMMARY = "summary"
 DISPLAY_MODE_LIST = "list"
 DISPLAY_MODE_CARDS = "cards"
 DISPLAY_MODE_GALLERY = "gallery"
 DISPLAY_MODE_STORY = "story"
-DISPLAY_MODE_HTML = "html"
+
+DISPLAY_MODES = {
+    DISPLAY_MODE_GRID,
+    DISPLAY_MODE_DETAIL,
+    DISPLAY_MODE_HTML,
+    DISPLAY_MODE_SUMMARY,
+    DISPLAY_MODE_LIST,
+    DISPLAY_MODE_CARDS,
+    DISPLAY_MODE_GALLERY,
+    DISPLAY_MODE_STORY}
+
+BASIC_DISPLAY_MODES = {
+    DISPLAY_MODE_GRID,
+    DISPLAY_MODE_DETAIL}
 
 # ~ URL_PARAM_EUSER = 'euser'
 # ~ URL_PARAM_EUSER = 'su'

lino/core/dashboard.py

@@ -7,9 +7,13 @@
 
 from lino.api import _
 from lino.core.permissions import Permittable
+from lino.core.requests import ActionRequest
+from lino.core.tables import AbstractTable
+# from lino.core.actions import ShowTable
 from lino.utils.html import E, tostring, assert_safe
 from django.utils.html import mark_safe
 
+
 class DashboardItem(Permittable):
     """Base class for all dashboard items.
 
@@ -51,9 +55,6 @@ class DashboardItem(Permittable):
         This is a helper function for shared use by :class:`ActorItem`
         and :class:`RequestItem`.
         """
-        from lino.core.tables import TableRequest
-        from lino.core.requests import ActionRequest
-
         assert ar.user is sar.user
         # T = sar.actor
         # print("20210112 render_request()", sar.actor, sar)
@@ -72,22 +73,22 @@ class DashboardItem(Permittable):
             yield tostring(E.h2(str(sar.actor.get_title_base(sar)), " ", *elems))
 
         assert sar.renderer is not None
-        if isinstance(sar, TableRequest):
+        if isinstance(sar, ActionRequest):
             # TODO 20220930 until now, dashboard was always acting as if
-            # display_mode was DISPLAY_MODE_TABLE
-            # if sar.actor.display_mode == constants.DISPLAY_MODE_TABLE
-
-            for e in sar.renderer.table2story(sar, **kwargs):
-                # assert_safe(tostring(e))
-                yield tostring(e)
-        elif isinstance(sar, ActionRequest):
-            # example : courses.StatusReport in dashboard
-            yield sar.renderer.show_story(
-                ar, sar.actor.get_story(None, ar), **kwargs)
-            # for e in sar.renderer.show_story(
-            #     ar, sar.actor.get_story(None, ar), **kwargs):
-            #     # assert_safe(tostring(e))
-            #     yield tostring(e)
+            # display_mode was DISPLAY_MODE_GRID
+            if issubclass(sar.actor, AbstractTable):
+            # if isinstance(sar.bound_action.action, ShowTable):
+                for e in sar.renderer.table2story(sar, **kwargs):
+                    # assert_safe(tostring(e))
+                    yield tostring(e)
+            else:
+                # example : courses.StatusReport in dashboard
+                yield sar.renderer.show_story(
+                    ar, sar.actor.get_story(None, ar), **kwargs)
+                # for e in sar.renderer.show_story(
+                #     ar, sar.actor.get_story(None, ar), **kwargs):
+                #     # assert_safe(tostring(e))
+                #     yield tostring(e)
         else:
             raise Exception("20240908 Cannot render {}".format(sar))
             yield "Cannot render {}".format(sar)