lino 25.5.2__py3-none-any.whl → 25.5.3__py3-none-any.whl

lino/core/elems.py

@@ -32,10 +32,11 @@ from lino import logger
 
 from lino.core import layouts
 from lino.core import fields
-from lino.core.actions import Action, Permittable
 from lino.core import constants
-from lino.core.gfks import GenericRelation, GenericRel
 from lino.core import choicelists
+from lino.core import actions
+from lino.core.gfks import GenericRelation, GenericRel
+from lino.core.permissions import Permittable
 from lino.modlib.bootstrap3.views import table2html
 
 from lino.utils.jsgen import VisibleComponent
@@ -50,12 +51,10 @@ from lino.core.actors import qs2summary
 
 from lino.core.layouts import (
     FormLayout,
-    ParamsLayout,
     ColumnsLayout,
-    ActionParamsLayout,
     DummyPanel,
 )
-
+from lino.core.layouts import ParamsLayout, ActionParamsLayout
 from lino.utils.mldbc.fields import BabelCharField, BabelTextField
 from lino.core import tables
 from lino.core.gfks import GenericForeignKey
@@ -1801,13 +1800,12 @@ class LightWeightContainer(HtmlBoxElement):
 
     """
 
-    def __init__(self, lh, slave, name, return_type, **kwargs):
+    def __init__(self, lh, slave, name, meth, **kwargs):
         box = fields.HtmlBox(
-            slave.label, name=name, help_text=slave.help_text, delayed_value=True
+            slave.get_label(), name=name, help_text=slave.help_text, delayed_value=True
         )
-
-        box._return_type_for_method = return_type
-        fld = fields.VirtualField(box, return_type)
+        box._return_type_for_method = meth
+        fld = fields.VirtualField(box, meth, verbose_name=slave.get_label())
         # self.value = dict(value=dict(data=""))  # compare react.views.DelayedValue
         # self.value = dict(data="")  # compare react.views.DelayedValue
         # assert box.delayed_value == True
@@ -1844,7 +1842,6 @@ class SlaveSummaryPanel(LightWeightContainer):
 
 class StoryElement(LightWeightContainer):
     """
-
     The panel used to display objects as plain html generated by
     :meth:`as_summary_row <lino.core.fields.TableRow.as_summary_row>` when
     `display_mode` is `DISPLAY_MODE_STORY`.
@@ -1860,6 +1857,11 @@ class ListElement(LightWeightContainer):
         super().__init__(lh, slave, name, slave.get_table_as_list, **kw)
 
 
+class TilesElement(LightWeightContainer):
+    def __init__(self, lh, slave, name, **kw):
+        super().__init__(lh, slave, name, slave.get_table_as_tiles, **kw)
+
+
 class ManyRelatedObjectElement(HtmlBoxElement):
     def __init__(self, lh, relobj, **kw):
         name = relobj.field.remote_field.related_name
@@ -2448,6 +2450,8 @@ class SlaveContainer(GridElement):
         slaves = dict()
         if constants.DISPLAY_MODE_STORY in rpt.extra_display_modes:
             slaves["story"] = get_story_element(layout_handle, rpt, name, **kw)
+        if constants.DISPLAY_MODE_TILES in rpt.extra_display_modes:
+            slaves["tiles"] = get_tiles_element(layout_handle, rpt, name, **kw)
         if constants.DISPLAY_MODE_LIST in rpt.extra_display_modes:
             slaves["list"] = get_list_element(layout_handle, rpt, name, **kw)
         if constants.DISPLAY_MODE_SUMMARY in rpt.extra_display_modes:
@@ -2721,18 +2725,23 @@ def create_layout_panel(lh, name, vertical, elems, **kwargs):
     return Panel(lh, name, vertical, *elems, **pkw)
 
 
-def get_story_element(lh, de, name, **kw):
-    e = StoryElement(lh, de, name, **kw)
+def get_display_element(lh, de, name, cls, **kwargs):
+    e = cls(lh, de, name, **kwargs)
     e.add_requirements(*de.required_roles)
     lh.add_data_elem(e.field)
     return e
 
 
+def get_story_element(lh, de, name, **kw):
+    return get_display_element(lh, de, name, StoryElement, **kw)
+
+
+def get_tiles_element(lh, de, name, **kw):
+    return get_display_element(lh, de, name, TilesElement, **kw)
+
+
 def get_list_element(lh, de, name, **kw):
-    e = ListElement(lh, de, name, **kw)
-    e.add_requirements(*de.required_roles)
-    lh.add_data_elem(e.field)
-    return e
+    return get_display_element(lh, de, name, ListElement, **kw)
 
 
 def get_htmlbox_element(lh, de, name, **kw):
@@ -2908,15 +2917,18 @@ def create_layout_element(lh, name, **kw):
             elif dm == constants.DISPLAY_MODE_HTML:
                 return get_htmlbox_element(lh, de, name, **kw)
 
-            elif dm == constants.DISPLAY_MODE_STORY:
-                return get_story_element(lh, de, name, **kw)
-
             elif dm == constants.DISPLAY_MODE_SUMMARY:
                 return get_summary_element(lh, de, name, **kw)
 
             elif dm == constants.DISPLAY_MODE_LIST:
                 return get_list_element(lh, de, name, **kw)
 
+            elif dm == constants.DISPLAY_MODE_STORY:
+                return get_story_element(lh, de, name, **kw)
+
+            elif dm == constants.DISPLAY_MODE_TILES:
+                return get_tiles_element(lh, de, name, **kw)
+
             # elif dm == 'reactive':  # TODO: is this still being used?
             #     e = ReactiveElement(lh, de, **kw)
             #     e.add_requirements(*de.required_roles)
@@ -2932,7 +2944,7 @@ def create_layout_element(lh, name, **kw):
             # lh.add_data_elem(e.field)
             # return e
 
-    if isinstance(de, Action):
+    if isinstance(de, actions.Action):
         return ButtonElement(lh, name, de)
 
     if isinstance(de, fields.VirtualField):

lino/core/fields.py

@@ -33,13 +33,15 @@ from lino.core.utils import (
 from lino.core.exceptions import ChangedAPI
 from lino.core.diff import ChangeWatcher
 from lino.core import constants
+from lino.core import atomizer
 
 from lino.utils import isiterable
-from lino.utils import get_class_attr
+from lino.utils import choosers
+# from lino.utils import get_class_attr
 from lino.utils import IncompleteDate
 from lino.utils import quantities
 from lino.utils.quantities import Duration
-from lino.modlib.gfks.fields import GenericForeignKeyIdField
+# from lino.modlib.gfks.fields import GenericForeignKeyIdField
 
 from .signals import pre_ui_save
 
@@ -369,8 +371,9 @@ class RemoteField(FakeField):
     """
     A field on a related object.
 
-    Remote fields are created by
-    :meth:`lino.core.model.Model.get_data_elem` when needed.
+    Remote fields are created by :func:`lino.core.atomizer.create_atomizer`
+    (which itself is called by :meth:`lino.core.model.Model.get_data_elem`) when
+    needed.
 
     .. attribute:: field
 
@@ -382,6 +385,7 @@ class RemoteField(FakeField):
     # ~ editable = False
 
     def __init__(self, getter, name, fld, setter=None, **kwargs):
+        # from lino.core import choicelists
         self.func = getter
         self.name = name
         self.attname = name
@@ -405,7 +409,7 @@ class RemoteField(FakeField):
         if setter is not None:
             self.editable = True
             self.choices = getattr(fld, "choices", None)
-        super(RemoteField, self).__init__(**kwargs)
+        super().__init__(**kwargs)
         # ~ print 20120424, self.name
         # ~ settings.SITE.register_virtual_field(self)
 
@@ -417,6 +421,9 @@ class RemoteField(FakeField):
         ):
             fld.lino_resolve_type()  # 20200425
             fk = fld.return_type
+        # elif isinstance(fld, choicelists.ChoiceListField):
+        #     self.choicelist = fld.choicelist
+        #     fk = None
         elif isinstance(fld, models.ForeignKey):
             fk = fld
         else:
@@ -425,9 +432,7 @@ class RemoteField(FakeField):
             # if not fk.remote_field:
             #     raise Exception("20200425 {} has no remote_field".format(fk))
             self.remote_field = fk.remote_field
-            from lino.core import store
-
-            store.get_atomizer(self.remote_field, self, name)
+            atomizer.get_atomizer(self.remote_field, self, name)
 
     def __str__(self):
         # return "<RemoteField({})>".format(self.name)
@@ -539,12 +544,12 @@ class VirtualModel:
         self._meta = model._meta
 
 
-VFIELD_ATTRIBS = frozenset(
-    """to_python choices save_form_data
-  value_to_string max_length remote_field
-  max_digits verbose_name decimal_places wildcard_data_elem
-  blank choices""".split()
-)
+VFIELD_ATTRIBS = frozenset([
+    "to_python", "choices", "save_form_data",
+    "value_to_string", "max_length", "remote_field",
+    "max_digits", "verbose_name", "decimal_places",
+    "wildcard_data_elem", "blank"
+])
 
 
 def return_none(obj, ar):
@@ -657,9 +662,10 @@ class VirtualField(FakeField):
         #     logger.info('20170905 resolve_type done %s %s',
         #                 self.name, self.verbose_name)
 
-        from lino.core import store
+        # if self.name is None or self.model is None:
+        #     return
 
-        store.get_atomizer(self.model, self, self.name)
+        atomizer.get_atomizer(self.model, self, self.name)
 
         # print("20181023 Done: lino_resolve_type() for {}".format(self))
 
@@ -1247,7 +1253,7 @@ class ImportedFields(object):
     @classmethod
     def declare_imported_fields(cls, names):
         cls._imported_fields = cls._imported_fields | set(
-            fields_list(cls, names))
+            atomizer.fields_list(cls, names))
         # ~ logger.info('20120801 %s.declare_imported_fields() --> %s' % (
         # ~ cls,cls._imported_fields))
 
@@ -1277,7 +1283,7 @@ class TableRow(object):
     def get_chooser_for_field(cls, fieldname):
         d = getattr(cls, "_choosers_dict", {})
         # if fieldname.endswith("__municipality"):
-        #     print("20200425 Model.get_chooser_for_field", cls, fieldname, d)
+        # print("20200425 Model.get_chooser_for_field", cls, fieldname, d)
         return d.get(fieldname, None)
 
     @classmethod
@@ -1457,6 +1463,9 @@ class TableRow(object):
             return escape(str(self))
         return tostring(self.as_summary_item(ar, **kwargs))
 
+    def as_tile(self, ar, **kwargs):
+        return self.as_paragraph(ar, **kwargs)
+
     def as_story_item(self, ar, **kwargs):
         kwargs.update(display_mode=constants.DISPLAY_MODE_STORY)
         return mark_safe("".join(self.as_page(ar, **kwargs)))
@@ -1533,57 +1542,6 @@ def use_as_wildcard(de):
     return True
 
 
-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.
-
-    If one of the names refers to a dummy field, this name will be ignored
-    silently.
-
-    For example if you have a model `MyModel` with two fields `foo` and
-    `bar`, then ``dd.fields_list(MyModel,"foo bar")`` will return
-    ``['foo','bar']`` and ``dd.fields_list(MyModel,"foo baz")`` will raise
-    an exception.
-
-    TODO: either rename this to `fields_set` or change it to return an
-    iterable on the fields.
-    """
-    lst = set()
-    names_list = field_names.split()
-
-    for name in names_list:
-        if name == "*":
-            explicit_names = set()
-            for name in names_list:
-                if name != "*":
-                    explicit_names.add(name)
-            for de in wildcard_data_elems(model):
-                if not isinstance(de, DummyField):
-                    if de.name not in explicit_names:
-                        if use_as_wildcard(de):
-                            lst.add(de.name)
-        else:
-            e = model.get_data_elem(name)
-            if e is None:
-                raise FieldDoesNotExist(
-                    "No data element %r in %s" % (name, model))
-            if not hasattr(e, "name"):
-                raise FieldDoesNotExist(
-                    "%s %r in %s has no name" % (e.__class__, name, model)
-                )
-            if isinstance(e, DummyField):
-                pass
-            else:
-                lst.add(e.name)
-    return lst
-
-
 def pointer_factory(cls, othermodel, *args, **kw):
     """
     Instantiate a `ForeignKey` or `OneToOneField` with some subtle
@@ -1610,147 +1568,6 @@ def pointer_factory(cls, othermodel, *args, **kw):
     return cls(othermodel, *args, **kw)
 
 
-def make_remote_field(model, name):
-    from lino.utils import choosers
-    parts = name.split("__")
-    if len(parts) == 1:
-        return
-    # It's going to be a RemoteField
-    # logger.warning("20151203 RemoteField %s in %s", name, cls)
-
-    from lino.core import store
-
-    cls = model
-    field_chain = []
-    editable = False
-    gettable = True
-    leaf_chooser = None
-    for n in parts:
-        if model is None:
-            return
-            # raise Exception(
-            #     "Invalid remote field {0} for {1}".format(name, cls))
-
-        if isinstance(model, str):
-            # Django 1.9 no longer resolves the
-            # rel.model of ForeignKeys on abstract
-            # models, so we do it here.
-            model = resolve_model(model)
-            # logger.warning("20151203 %s", model)
-
-        fld = model.get_data_elem(n)
-        if fld is None:
-            return
-            # raise Exception(
-            #     "Invalid RemoteField %s.%s (no field %s in %s)" %
-            #     (full_model_name(model), name, n, full_model_name(model)))
-
-        if isinstance(fld, DummyField):
-            # a remote field containing at least one dummy field is itself a
-            # dummy field
-            return fld
-
-        # Why was this? it caused docs/specs/avanti/courses.rst to fail
-        # if isinstance(fld, models.ManyToOneRel):
-        #     gettable = False
-
-        # make sure that the atomizer gets created.
-        store.get_atomizer(model, fld, fld.name)
-
-        if isinstance(fld, VirtualField):
-            fld.lino_resolve_type()
-        leaf_chooser = choosers.check_for_chooser(model, fld)
-
-        field_chain.append(fld)
-        if isinstance(
-            fld, (models.OneToOneRel, models.OneToOneField, models.ForeignKey)
-        ):
-            editable = True
-        if getattr(fld, "remote_field", None):
-            model = fld.remote_field.model
-        else:
-            model = None
-
-    # if not gettable:
-    #     # raise Exception("20231112")
-    #     return RemoteField(none_getter, name, fld)
-
-    if leaf_chooser is not None:
-        d = choosers.get_choosers_dict(cls)
-        d[name] = leaf_chooser
-
-    def getter(obj, ar=None):
-        try:
-            for fld in field_chain:
-                if obj is None:
-                    return None
-                obj = fld._lino_atomizer.full_value_from_object(obj, ar)
-            return obj
-        except Exception as e:
-            # raise
-            msg = "Error while computing {}: {} ({} in {})"
-            raise Exception(msg.format(name, e, fld, field_chain))
-            # ~ if False: # only for debugging
-            if True:  # see 20130802
-                logger.exception(e)
-                return str(e)
-            return None
-
-    if not editable:
-        rf = RemoteField(getter, name, fld)
-        # choosers.check_for_chooser(model, rf)
-        return rf
-
-    def setter(obj, value):
-        # logger.info("20180712 %s setter() %s", name, value)
-        # all intermediate fields are OneToOneRel
-        target = obj
-        try:
-            for i, fld in enumerate(field_chain):
-                # print("20180712a %s" % fld)
-                if isinstance(fld, (models.OneToOneRel, models.ForeignKey)):
-                    reltarget = getattr(target, fld.name, None)
-                    if reltarget is None:
-                        rkw = {fld.field.name: target}
-                        # print(
-                        #     "20180712 create {}({})".format(
-                        #         fld.related_model, rkw))
-                        reltarget = fld.related_model(**rkw)
-                        reltarget.save_new_instance(
-                            fld.related_model.get_default_table().create_request()
-                        )
-
-                    setattr(target, fld.name, reltarget)
-
-                    if target == obj and target.id is None:
-                        # Model.save_new_instance will be called do not insert this record.
-                        target = reltarget
-                        continue
-                    target.full_clean()
-                    target.save()
-                    # print("20180712b {}.{} = {}".format(
-                    #     target, fld.name, reltarget))
-                    target = reltarget
-                else:
-                    setattr(target, fld.name, value)
-                    target.full_clean()
-                    target.save()
-                    # print(
-                    #     "20180712c setattr({},{},{}".format(
-                    #         target, fld.name, value))
-                    return True
-        except Exception as e:
-            if False:  # only for debugging
-                logger.exception(e)
-                return str(e)
-            raise e.__class__("Error while setting %s: %s" % (name, e))
-            return False
-
-    rf = RemoteField(getter, name, fld, setter)
-    # choosers.check_for_chooser(model, rf)
-    return rf
-
-
 # # would be nice for lino_xl.lib.vat.VatItemBase.item_total
 # class FieldAlias(VirtualField):
 #     def __init__(self, orig_name):
@@ -1852,3 +1669,16 @@ def choices_for_field(ar, holder, field):
     else:
         raise http.Http404("No choices for %s" % field)
     return (qs, row2dict)
+
+
+def setup_params_choosers(self):
+    if self.parameters:
+        for k, fld in self.parameters.items():
+            if isinstance(fld, models.ForeignKey):
+                msg = "Invalid target %s in parameter {} of {}".format(k, self)
+                fld.remote_field.model = resolve_model(
+                    fld.remote_field.model, strict=msg
+                )
+                set_default_verbose_name(fld)
+
+            choosers.check_for_chooser(self, fld)

lino/core/kernel.py

@@ -50,22 +50,22 @@ from lino.utils.html import E
 # from lino.utils import isiterable
 from lino.core import layouts
 from lino.core import actors
-from lino.core import actions
 from lino.core import frames
-from lino.core import fields
 from lino.core import dbtables
+from lino.core import atomizer
 from lino.core import choicelists
 from lino.core import workflows
 from lino.core import tables
 from lino.core import constants
 from lino.core.model import Model
-from lino.core.roles import UserRole
+# from lino.core.roles import UserRole
+from lino.utils.choosers import discover_choosers
 from lino.core.store import Store
 from lino.core.renderer import HtmlRenderer, TextRenderer
 from lino.core.gfks import ContentType, GenericForeignKey
 from lino.core.signals import (
     pre_ui_build,
-    post_ui_build,
+    # post_ui_build,
     pre_startup,
     post_startup,
     pre_analyze,
@@ -83,9 +83,9 @@ from .utils import get_models
 from .utils import resolve_fields_list
 
 # from .utils import djangoname
-from .utils import class_dict_items
+# from .utils import class_dict_items
 
-from .fields import set_default_verbose_name
+from lino.core.fields import set_default_verbose_name
 # from lino.core.requests import ActorRequest
 
 startup_rlock = threading.RLock()  # Lock() or RLock()?
@@ -155,6 +155,8 @@ class Kernel(object):
     #             # self._code_mtime = codetime(settings.SETTINGS_MODULE)
     #     return self._code_mtime
 
+    editing_front_end = None
+
     def kernel_startup(self, site):
         """This is a part of a Lino site startup.  The Django Model
         definitions are done, now Lino analyzes them and does certain
@@ -226,22 +228,22 @@ class Kernel(object):
 
             if isinstance(model.hidden_columns, str):
                 model.hidden_columns = frozenset(
-                    fields.fields_list(model, model.hidden_columns)
+                    atomizer.fields_list(model, model.hidden_columns)
                 )
 
             if isinstance(model.active_fields, str):
                 model.active_fields = frozenset(
-                    fields.fields_list(model, model.active_fields)
+                    atomizer.fields_list(model, model.active_fields)
                 )
 
             if isinstance(model.allow_cascaded_delete, str):
                 model.allow_cascaded_delete = frozenset(
-                    fields.fields_list(model, model.allow_cascaded_delete)
+                    atomizer.fields_list(model, model.allow_cascaded_delete)
                 )
 
             if isinstance(model.allow_cascaded_copy, str):
                 model.allow_cascaded_copy = frozenset(
-                    fields.fields_list(model, model.allow_cascaded_copy)
+                    atomizer.fields_list(model, model.allow_cascaded_copy)
                 )
 
             # Note how to inherit this from from parent model.
@@ -469,7 +471,7 @@ class Kernel(object):
                 model._lino_default_table = rpt
 
         # ~ choosers.discover()
-        actions.discover_choosers()
+        discover_choosers()
 
         for a in actors.actors_list:
             for name, field in a.virtual_fields.items():
@@ -675,13 +677,16 @@ class Kernel(object):
         #         must_remove.add(r)
         # site.user_roles -= must_remove
 
-        post_ui_build.send(self)
+        # post_ui_build.send(self)
 
-        # trigger creation of params_layout.params_store
+        # trigger creation of params_layout.params_store and
+        # virtual fields in LightWeightContainer
         for res in actors.actors_list:
             for ba in res.get_actions():
                 if ba.action.params_layout is not None:
                     ba.action.params_layout.get_layout_handle()
+                if ba.action.is_window_action():
+                    ba.get_layout_handel()
 
         # logger.info("20161219 kernel_startup done")