lino 25.7.1__py3-none-any.whl → 25.7.3__py3-none-any.whl

lino/__init__.py

@@ -31,7 +31,7 @@ from django import VERSION
 from django.apps import AppConfig
 from django.conf import settings
 import warnings
-__version__ = '25.7.1'
+__version__ = '25.7.3'
 
 # import setuptools  # avoid UserWarning "Distutils was imported before Setuptools"?
 

lino/api/doctest.py

@@ -14,6 +14,7 @@ tested document. It includes
 
 """
 
+from lino.mixins.clonable import Clonable
 from lino.utils.fieldutils import get_fields, fields_help
 from lino.core.boundaction import BoundAction
 from lino.core.tables import AbstractTable
@@ -23,7 +24,9 @@ from lino.core.actions import ShowTable
 from lino.core.menus import Menu
 from lino.utils.html import html2text
 from lino.utils import dbhash
-from lino.core.utils import full_model_name, get_models
+from lino.core.utils import get_models
+from lino.core.utils import full_model_name
+from lino.core.utils import full_model_name as fmn
 from lino.utils.diag import visible_for
 from lino.sphinxcontrib.actordoc import menuselection_text
 from lino import logger
@@ -83,6 +86,8 @@ HttpQuery = collections.namedtuple(
 
 # settings.SITE.is_testing = True
 
+ADMIN_FRONT_END = settings.SITE.kernel.editing_front_end
+
 
 def get_json_dict(username, uri, an="detail", **kwargs):
     url = "/api/{0}?fmt=json&an={1}".format(uri, an)
@@ -381,27 +386,28 @@ def walk_menu_items(username=None, severe=True):
         mnu = settings.SITE.get_site_menu(user_type)
         items = []
         for mi in mnu.walk_items():
-            if mi.bound_action:
+            if ba := mi.bound_action:
                 item = menuselection_text(mi)
                 # item += " ({})".format(mi)
                 item += " : "
-                if isinstance(mi.bound_action.action, ShowTable) and not mi.params:
+                if isinstance(ba.action, ShowTable) and not mi.params:
                     # url = settings.SITE.kernel.default_ui.renderer.request_handler()
-                    # sar = mi.bound_action.request(parent=ar)
+                    # sar = ba.request(parent=ar)
                     if False:
-                        url = ar.get_permalink(mi.bound_action, mi.instance)
+                        url = ar.get_permalink(ba, mi.instance)
                     else:
-                        mt = mi.bound_action.actor
+                        mt = ba.actor
                         baseurl = "api/{}/{}".format(mt.app_label, mt.__name__)
                         kwargs = dict(fmt="json")
-                        url = settings.SITE.buildurl(baseurl, **kwargs)
+                        # url = settings.SITE.buildurl(baseurl, **kwargs)
+                        url = ADMIN_FRONT_END.build_plain_url(baseurl, **kwargs)
+
                     try:
                         response = test_client.get(url)
                         # response = test_client.get(url,
                         #                            REMOTE_USER=str(username))
                         result = check_json_result(
-                            response, None, "GET %s for user %s" % (url, username)
-                        )
+                            response, None, f"GET {url} for user {username}")
                         item += str(result["count"])
                         # Also ask in display_mode "list" to cover assert_safe() bugs.
                         # But not e.g. UserRoles because it's not on a model and doesn't have a list mode
@@ -409,10 +415,10 @@ def walk_menu_items(username=None, severe=True):
                             kwargs[
                                 constants.URL_PARAM_DISPLAY_MODE
                             ] = constants.DISPLAY_MODE_LIST
-                            url = settings.SITE.buildurl(baseurl, **kwargs)
+                            url = ADMIN_FRONT_END.build_plain_url(baseurl, **kwargs)
                             response = test_client.get(url)
                             result = check_json_result(
-                                response, None, "GET %s for user %s" % (url, username)
+                                response, None, f"GET {url} for user {username}"
                             )
                             # if ar is not None:
                             #     sar = mt.request(parent=ar)
@@ -743,7 +749,7 @@ def show_change_watchers():
         ws = m.change_watcher_spec
         if ws:
             rows.append(
-                [full_model_name(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
+                [fmn(m), ws.master_key, " ".join(sorted(ws.ignored_fields))]
             )
     print(rstgen.table(headers, rows, max_width=40))
 
@@ -798,3 +804,26 @@ def checkdb(m, num):
     if m.objects.count() != num:
         raise Exception(
             f"Model {m} should have {num} rows but has {m.objects.count()}")
+
+
+def show_clonables():
+    """
+    Print a list of all :class:`Clonable <lino.mixins.clonable.Clonable>`
+    models, together with their related slaves, i.e. the data that will be
+    cloned in cascade with their master.
+    """
+    items = []
+    for m in get_models():
+        if issubclass(m, Clonable):
+            rels = []
+            if (obj := m.objects.first()) is not None:
+                new, related = obj.duplication_plan()
+                for fk, qs in related:
+                    rels.append(f"{fmn(qs.model)}.{fk.name}")
+            if len(rels):
+                x = ", ".join(rels)
+                items.append(f"{fmn(m)} : {x}")
+            else:
+                items.append(fmn(m))
+    items = sorted(items)
+    print(rstgen.ul(items).strip())

lino/core/__init__.py

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

lino/core/actions.py

@@ -11,7 +11,7 @@ from django.utils.encoding import force_str
 from django.utils.translation import gettext
 from lino.core import constants
 from lino.core import keyboard
-from lino.core.exceptions import ChangedAPI
+# from lino.core.exceptions import ChangedAPI
 from .utils import traverse_ddh_fklist
 from .utils import navinfo
 from .utils import obj2unicode
@@ -37,20 +37,17 @@ class Action(Parametrizable, Permittable):
     save_action_name = None
     disable_primary_key = True
     keep_user_values = False
-    icon_name = None
+    icon_name: str = None
     ui5_icon_name = None
     react_icon_name = None
     hidden_elements = frozenset()
     combo_group = None
     parameters: dict[str, Any] | None = None
-
     use_param_panel = False
     no_params_window = False
     sort_index = 90
     help_text = None
-
     auto_save = True
-
     extjs_main_panel = None
     js_handler = None
     action_name = None
@@ -67,6 +64,7 @@ class Action(Parametrizable, Permittable):
     show_in_plain = False
     show_in_toolbar = True
     show_in_workflow = False
+    buddy_name: str = None
     custom_handler = False
     select_rows = True
     http_method = "GET"
@@ -100,6 +98,13 @@ class Action(Parametrizable, Permittable):
                 raise Exception(
                     "Unkonwn icon_name '{0}'".format(self.icon_name))
 
+        params = {}
+        if self.parameters is not None:
+            params.update(self.parameters)
+        self.setup_parameters(params)
+        if len(params):
+            self.parameters = params
+
         register_params(self)
 
         if self.callable_from is not None:
@@ -153,6 +158,9 @@ class Action(Parametrizable, Permittable):
 
         return decorator
 
+    def setup_parameters(self, params):
+        pass
+
     def get_help_text(self, ba):
         if ba is ba.actor.default_action:
             if self.default_record_id is not None:
@@ -966,7 +974,7 @@ class ShowEditor(Action):
     show_in_toolbar = False
 
     def __init__(self, fieldname, *args, **kwargs):
-        self.fieldname = fieldname
+        self.buddy_name = fieldname
         super().__init__(*args, **kwargs)
 
     def run_from_ui(self, ar, **kwargs):
@@ -978,7 +986,7 @@ class ShowEditor(Action):
                     ar.master_instance.__class__).pk
             })
         ar.set_response(goto_url=ar.renderer.front_end.build_plain_url(
-            "api", *ar.actor.actor_id.split("."), str(ar.selected_rows[0].pk), self.fieldname, **kw))
+            "api", *ar.actor.actor_id.split("."), str(ar.selected_rows[0].pk), self.buddy_name, **kw))
 
 
 # Some actions are described by a single action instance used by most actors:

lino/core/actors.py

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

lino/core/atomizer.py

@@ -309,10 +309,10 @@ def fields_list(model, field_names):
     Return a set with the names of the specified fields, checking
     whether each of them exists.
 
-    Arguments: `model` is any subclass of `django.db.models.Model`. It
-    may be a string with the full name of a model
-    (e.g. ``"myapp.MyModel"``).  `field_names` is a single string with
-    a space-separated list of field names.
+    Arguments: `model` is any subclass of `django.db.models.Model`. It may be a
+    string with the full name of a model (e.g. ``"myapp.MyModel"``).
+    `field_names` is an iterable of field names or a single string with a
+    space-separated list of field names.
 
     If one of the names refers to a dummy field, this name will be ignored
     silently.
@@ -326,16 +326,17 @@ def fields_list(model, field_names):
     iterable on the fields.
     """
     lst = set()
-    names_list = field_names.split()
+    if isinstance(field_names, str):
+        field_names = field_names.split()
 
-    for name in names_list:
+    for name in field_names:
         if name == "*":
             explicit_names = set()
             for name in names_list:
                 if name != "*":
                     explicit_names.add(name)
             for de in fields.wildcard_data_elems(model):
-                if not isinstance(de, DummyField):
+                if not isinstance(de, fields.DummyField):
                     if de.name not in explicit_names:
                         if fields.use_as_wildcard(de):
                             lst.add(de.name)
@@ -343,7 +344,7 @@ def fields_list(model, field_names):
             e = model.get_data_elem(name)
             if e is None:
                 raise fields.FieldDoesNotExist(
-                    "No data element %r in %s" % (name, model))
+                    f"No data element '{name}' in {model}")
             if not hasattr(e, "name"):
                 raise fields.FieldDoesNotExist(
                     "%s %r in %s has no name" % (e.__class__, name, model)

lino/core/auth/utils.py

@@ -73,7 +73,8 @@ class AnonymousUser:
 
 
 def activate_social_auth_testing(
-    globals_dict, google=True, github=True, wikimedia=True, facebook=True
+    globals_dict, google=True, github=True, wikimedia=True, facebook=True,
+    smart_id=False
 ):
     """
     Used for testing a development server.
@@ -97,6 +98,13 @@ def activate_social_auth_testing(
         # 'social_core.backends.google.GoogleOAuth2',
         # 'social_core.backends.google.GoogleOAuth',
         # 'social_core.backends.facebook.FacebookOAuth2',
+    if smart_id:
+        Site.social_auth_backends.append("lino.utils.smart_id.SmartID")
+        # https://oauth.ee/docs
+        globals_dict.update(
+            SOCIAL_AUTH_SMART_ID_KEY="xxx",
+            SOCIAL_AUTH_SMART_ID_SECRET="yyy",
+        )
     if wikimedia:
         Site.social_auth_backends.append("social_core.backends.mediawiki.MediaWiki")
         globals_dict.update(

lino/core/callbacks.py

@@ -72,9 +72,9 @@ class Callback(object):
         - func: a callable to be executed when user selects this choice
         - the label of the button
         """
-        assert not name in self.choices_dict
+        assert name not in self.choices_dict
         allowed_names = ("yes", "no", "ok", "cancel")
-        if not name in allowed_names:
+        if name not in allowed_names:
             raise Exception("Sorry, name must be one of %s" % allowed_names)
         cbc = CallbackChoice(name, func, label)
         self.choices.append(cbc)

lino/core/elems.py

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

lino/core/fields.py

@@ -370,6 +370,9 @@ class FakeField(object):
         # if self.verbose_name is None and self.name:
         #     self.verbose_name = self.name.replace('_', ' ')
 
+    def get(self, *args, **kwargs):
+        return None
+
 
 class RemoteField(FakeField):
     """
@@ -1489,7 +1492,6 @@ class TableRow(object):
 
     def save_existing_instance(self, ar):
         watcher = ChangeWatcher(self)
-        # print("20210213 save_existing_instance", ar.ah, ar.rqdata, self.disabled_fields)
         ar.ah.store.form2obj(ar, ar.rqdata, self, False)
         self.full_clean()
         pre_ui_save.send(sender=self.__class__, instance=self, ar=ar)

lino/core/kernel.py

@@ -230,25 +230,15 @@ class Kernel(object):
 
             Model.django2lino(model)
 
-            if isinstance(model.hidden_columns, str):
-                model.hidden_columns = frozenset(
-                    atomizer.fields_list(model, model.hidden_columns)
-                )
-
-            if isinstance(model.active_fields, str):
-                model.active_fields = frozenset(
-                    atomizer.fields_list(model, model.active_fields)
-                )
+            if model.allow_cascaded_copy is None:
+                model.allow_cascaded_copy = model.allow_cascaded_delete
 
-            if isinstance(model.allow_cascaded_delete, str):
-                model.allow_cascaded_delete = frozenset(
-                    atomizer.fields_list(model, model.allow_cascaded_delete)
-                )
-
-            if isinstance(model.allow_cascaded_copy, str):
-                model.allow_cascaded_copy = frozenset(
-                    atomizer.fields_list(model, model.allow_cascaded_copy)
-                )
+            # 'suppress_cascaded_copy'
+            for k in ('hidden_columns', 'active_fields',
+                      'allow_cascaded_delete', 'allow_cascaded_copy'):
+                # resolve_fields_list(model, k, frozenset, frozenset())
+                if (v := getattr(model, k, None)) is not None:
+                    setattr(model, k, atomizer.fields_list(model, v))
 
             # Note how to inherit this from from parent model.
             if model.quick_search_fields is None:
@@ -610,6 +600,7 @@ class Kernel(object):
             # print("\n".join(["- {0.url_prefix} --> {0.app_name} {1}".format(p, hash(p))
             #     for p in self.web_front_ends]))
 
+        editing_wf = None
         for p in self.web_front_ends:
             if p.ui_handle_attr_name is not None:
                 editing_wf = p
@@ -686,6 +677,7 @@ class Kernel(object):
         # trigger creation of params_layout.params_store and
         # virtual fields in LightWeightContainer
         for res in actors.actors_list:
+            field_actions = dict()
             for ba in res.get_actions():
                 # ba._started = True
                 if ba.help_text is None:
@@ -694,6 +686,10 @@ class Kernel(object):
                     ba.action.params_layout.get_layout_handle()
                 if ba.action.is_window_action():
                     ba.get_layout_handel()
+                if ba.action.buddy_name:
+                    lst = field_actions.setdefault(ba.action.buddy_name, [])
+                    lst.append(ba)
+            res._field_actions = field_actions
 
         # logger.info("20161219 kernel_startup done")
 

lino/core/layouts.py

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