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

lino/core/utils.py

@@ -640,7 +640,7 @@ def navinfo(qs, elem, limit=None):
     )
 
 
-class Parametrizable(object):
+class Parametrizable:
     """
     Base class for both Actors and Actions.  See :doc:`/dev/parameters`.
 
@@ -1129,3 +1129,126 @@ def show(*args, **kwargs):
 def shows(*args, **kwargs):
     """Return the output of :func:`show`."""
     return capture_output(show, *args, **kwargs)
+
+
+class Panel:
+    """
+    To be used when a panel cannot be expressed using a simple
+    template string because it requires one or more options. These
+    `options` parameters can be:
+
+    - label
+    - required_roles
+    - window_size
+    - label_align
+
+    Unlike a :class:`BaseLayout` it cannot have any child panels
+    and cannot become a tabbed panel.
+    """
+
+    def __init__(self, desc, label=None, **options):
+        # assert not 'required' in options
+        self.desc = desc
+        if label is not None:
+            options.update(label=label)
+        self.options = options
+
+    def replace(self, *args, **kw):
+        """
+        Calls the standard :meth:`string.replace`
+        method on this Panel's template.
+        """
+        self.desc = self.desc.replace(*args, **kw)
+
+
+def resolve_layout(cls, k, spec, layout_class, **options):
+    # k: just for naming the culprit in error messages
+    if isinstance(spec, str):
+        if "\n" in spec or "." not in spec:
+            return layout_class(spec, cls, **options)
+        else:
+            layout_class = settings.SITE.models.resolve(spec)
+            if layout_class is None:
+                raise Exception(
+                    "Unresolved {} {!r} for {}".format(k, spec, cls))
+            return layout_class(None, cls, **options)
+    elif isinstance(spec, Panel):
+        options.update(spec.options)
+        return layout_class(spec.desc, cls, **options)
+    else:
+        if not isinstance(spec, layout_class):
+            if not isinstance(cls, type):
+                # cls is an action instance
+                cls = cls.__class__
+            msg = (
+                "{}.{}.{} must be a string, " "a Panel or an instance of {} (not {!r})"
+            )
+            raise Exception(
+                msg.format(cls.__module__, cls.__name__,
+                           k, layout_class.__name__, spec)
+            )
+        if spec._datasource is None:
+            spec.set_datasource(cls)
+            return spec
+        elif not issubclass(cls, spec._datasource):
+            raise Exception(
+                "Cannot reuse %s instance (%s of %r) for %r"
+                % (spec.__class__, k, spec._datasource, cls)
+            )
+    return spec
+
+
+def install_layout(cls, k, layout_class, **options):
+    """
+    - `cls` is the actor (a class object)
+
+    - `k` is one of 'grid_layout', 'detail_layout', 'insert_layout',
+      'params_layout', 'card_layout'
+
+    - `layout_class`
+
+    """
+    # if str(cls) == 'courses.Pupils':
+    #     print("20160329 install_layout", k, layout_class)
+    dl = cls.__dict__.get(k, None)
+    if dl is None:  # and not cls._class_init_done:
+        dl = getattr(cls, k, None)
+    if dl is None:
+        return
+    setattr(cls, k, resolve_layout(cls, k, dl, layout_class, **options))
+
+
+def register_params(cls):
+    """`cls` is either an actor (a class object) or an action (an
+    instance).
+
+    """
+    if cls.parameters is not None:
+        for k, v in cls.parameters.items():
+            v.set_attributes_from_name(k)
+            v.table = cls
+            # v.model = cls  # 20181023 experimentally
+
+        if cls.params_layout is None:
+            if cls._params_layout_class is None:
+                raise Exception(f"{cls} has no _params_layout_class")
+            cls.params_layout = cls._params_layout_class.join_str.join(
+                cls.parameters.keys()
+            )
+        install_layout(cls, "params_layout", cls._params_layout_class)
+
+    # e.g. accounting.ByJournal is just a mixin but provides a default value for its children
+    elif cls.params_layout is not None:
+        raise Exception("{} has a params_layout but no parameters".format(cls))
+
+    # if isinstance(cls, type) and cls.__name__.endswith("Users"):
+    # # if isinstance(cls, type) and cls.model is not None and cls.model.__name__ == "User":
+    #     # if str(cls.model) != "users.User":
+    #     #     raise Exception("{} {}".format(cls, cls.model))
+    #     print("20200825 {}.register_params {} {}".format(
+    #         cls, cls.parameters, cls.params_layout))
+
+
+def make_params_layout_handle(self):
+    # `self` is either an Action instance or an Actor class object
+    return self.params_layout.get_layout_handle()