lino 24.10.2__py3-none-any.whl → 24.11.0__py3-none-any.whl

lino/core/requests.py

@@ -35,6 +35,7 @@ from asgiref.sync import sync_to_async
 
 from lino.utils.html import E, tostring, iselement
 from lino.utils import AttrDict
+from lino.utils import capture_output
 from lino.utils import MissingRow
 from lino.utils.html import html2text
 from lino.core import constants
@@ -237,8 +238,8 @@ class ValidActionResponses(object):
 
 
 inheritable_attrs = frozenset(
-    "user subst_user renderer requesting_panel master_instance logger".split()
-)
+    ["user", "subst_user", "renderer", "requesting_panel", "master_instance",
+    "logger", "show_urls"] )
 
 
 def bool2text(x):
@@ -311,6 +312,8 @@ class BaseRequest:
     no_data_text = _("No data to display")
     is_on_main_actor = True
     permalink_uris = False
+    show_urls = True
+    master = None
     master_instance = None
     request = None
     selected_rows = []
@@ -326,12 +329,13 @@ class BaseRequest:
         self,
         request=None,
         parent=None,
-        hash_router=None,
         is_on_main_actor=True,
         permalink_uris=None,
         **kw
     ):
         self.response = dict()
+        # if str(kw.get('actor', None)) == "cal.EntriesByController":
+        # if kw.get('actor', None):
         if request is not None:
             assert parent is None
             self.request = request
@@ -339,8 +343,6 @@ class BaseRequest:
             kw = self.parse_req(request, self.rqdata, **kw)
             if permalink_uris is None:
                 permalink_uris = False  # todo: which default value?
-            # if hash_router is None:
-            #     hash_router = False
         elif parent is not None:
             # if parent.actor is None:
             # 20190926 we want to have javascript extjs links in dasboard
@@ -369,15 +371,16 @@ class BaseRequest:
             # is_on_main_actor = False
             if permalink_uris is None:
                 permalink_uris = parent.permalink_uris
-            # if hash_router is None:
-            #     hash_router = parent.hash_router
+        # else:
+        #     kw.setdefault("show_urls", False)
 
         self.is_on_main_actor = is_on_main_actor
         self.permalink_uris = permalink_uris
-        # self.hash_router = hash_router
 
         self.setup(**kw)
 
+        # print("20241101", self.__class__.__name__, self.show_urls)
+
         if self.master is not None and settings.SITE.strict_master_check:
             if self.master_instance is None:
                 raise exceptions.BadRequest(
@@ -407,6 +410,7 @@ class BaseRequest:
         renderer=None,
         xcallback_answers=None,
         known_values={},
+        show_urls=None,
     ):
         if logger is not None:
             self.logger = logger
@@ -418,27 +422,31 @@ class BaseRequest:
         self.current_project = current_project
         if renderer is None:
             renderer = settings.SITE.kernel.text_renderer
+            # renderer = settings.SITE.kernel.default_renderer
         self.renderer = renderer
+        if show_urls is not None:
+            self.show_urls = show_urls
         self.subst_user = subst_user
         if xcallback_answers is not None:
             self.xcallback_answers = xcallback_answers
 
-        if master is None and self.actor is not None:
-            master = self.actor.master
-        if master_type is not None:
-            try:
-                master = ContentType.objects.get(pk=master_type).model_class()
-            except ContentType.DoesNotExist:
-                raise exceptions.BadRequest("Invalid master_type {}".format(master_type)) from None
-        self.master = master
-
-        if self.master is not None and self.master_instance is None:
-            # master_instance might have been inherited from parent
-            if master_instance is None:
-                master_instance = self.get_master_instance(
-                    self.master, master_key, master_type
-                )
-            self.master_instance = self.actor.cast_master_instance(master_instance)
+        if self.actor is not None:
+            if master is None:
+                master = self.actor.master
+            if master_type is not None and ContentType is not None:
+                try:
+                    master = ContentType.objects.get(pk=master_type).model_class()
+                except ContentType.DoesNotExist:
+                    raise exceptions.BadRequest("Invalid master_type {}".format(master_type)) from None
+            self.master = master
+
+            if self.master is not None and self.master_instance is None:
+                # master_instance might have been inherited from parent
+                if master_instance is None:
+                    master_instance = self.get_master_instance(
+                        self.master, master_key, master_type
+                    )
+                self.master_instance = self.actor.cast_master_instance(master_instance)
 
         self.row_meta = dict(meta=True)
 
@@ -1166,6 +1174,9 @@ class BaseRequest:
     def story2rst(self, story, *args, **kwargs):
         return self.renderer.show_story(self, story, *args, **kwargs)
 
+    def shows(self, *args, **kwargs):
+        return capture_output(self.show, *args, **kwargs)
+
     def show(
         self,
         spec=None,
@@ -1175,6 +1186,7 @@ class BaseRequest:
         language=None,
         nosummary=False,
         stripped=True,
+        show_links=False,
         show_urls=False,
         max_width=None,
         header_links=False,
@@ -1194,10 +1206,14 @@ class BaseRequest:
 
         :column_names: overrides default list of columns
 
-        :show_urls: show links and other html formatting.  Used
+        :show_links: show links and other html formatting.  Used
                      .e.g. in :ref:`avanti.specs.roles` where we want
                      to show whether cells are clickable or not.
 
+        :show_urls: show the real URLs. URLs in doctests are usually replaced by
+                    "…" to increase readability. If this is explicitly set to True, Lino
+                    prints the full URLs.
+
         :nosummary: if it is a table with :attr:`display_mode
                     <lino.core.tables.AbstractTable.display_mode>`
                     set to ``((None, DISPLAY_MODE_SUMMARY), )``,
@@ -1253,6 +1269,8 @@ class BaseRequest:
             ar = self.spawn(spec, **kwargs)
             # return self.renderer.show_story(spec, **kwargs)
 
+        ar.show_urls = show_urls
+
         def doit():
             # print 20160530, ar.renderer
             if issubclass(ar.actor, Report):
@@ -1275,7 +1293,7 @@ class BaseRequest:
                     nosummary=nosummary,
                     stripped=stripped,
                     max_width=max_width,
-                    show_urls=show_urls,
+                    show_links=show_links,
                     display_mode=display_mode,
                 )
             elif isinstance(ar.bound_action.action, actions.ShowDetail):
@@ -1630,9 +1648,9 @@ class ActionRequest(BaseRequest):
     Holds information about an individual web request and provides
     methods like
 
-    - :meth:`get_user <lino.core.actions.BaseRequest.get_user>`
-    - :meth:`confirm <lino.core.actions.BaseRequest.confirm>`
-    - :meth:`spawn <lino.core.actions.BaseRequest.spawn>`
+    - :meth:`get_user <lino.core.requests.BaseRequest.get_user>`
+    - :meth:`confirm <lino.core.requests.BaseRequest.confirm>`
+    - :meth:`spawn <lino.core.requests.BaseRequest.spawn>`
 
     An `ActionRequest` is also a :class:`BaseRequest` and inherits its
     methods.
@@ -1845,7 +1863,7 @@ class ActionRequest(BaseRequest):
         return "{0} {1}".format(self.__class__.__name__, self.bound_action)
 
     def gen_insert_button(
-        self, target, button_attrs=dict(style="float: right;"), **values
+        self, target=None, button_attrs=dict(style="float: right;"), **values
     ):
         """
         Generate an insert button using a cached insertable object.
@@ -1860,13 +1878,26 @@ class ActionRequest(BaseRequest):
         The difference is that gen_insert_button is more efficient when you do
         this more than once during a single request.
 
-        `target` is the actor into which we want to insert an object.
-        `button_label` is the optional button label.
+        `target` is the actor into which we want to insert an object. When this is `None`, Lino uses :attr:`self.actor`.
+        `button_attrs` if given, are forwarded to :meth:`ar2button`.
         `values` is a dict of extra default values to apply to the insertable object.
 
+        The `values` must be atomized by the caller, which is especially
+        important when you want to set a :term:`foreign key` field. So instead
+        of saying::
+
+            gen_insert_button(None, user=u)
+
+        you must say::
+
+            gen_insert_button(None, user=u.pk, userHidden=str(u))
+
         First usage example is in :mod:`lino_xl.lib.calview`.
+        Second usage example is :class:`lino_prima.lib.prima.PupilsAndProjects`.
 
         """
+        if target is None:
+            target = self.actor
         if self._insert_sar is None:
             self._insert_sar = target.insert_action.request_from(self)
         else:
@@ -1877,7 +1908,7 @@ class ActionRequest(BaseRequest):
             # obj = st['data_record']
             # for k, v in values.items():
             #     setattr(obj, k, v)
-            # print(20200302, st['data_record'])
+            # print(20241018, st['data_record'])
             return self._insert_sar.ar2button(**button_attrs)
 
     def run(self, *args, **kw):
@@ -2030,7 +2061,10 @@ class ActionRequest(BaseRequest):
         if self.create_kw:
             kw.update(self.create_kw)
         if self.known_values:
-            kw.update(self.known_values)
+            # kw.update(self.known_values)
+            for k, v in self.known_values.items():
+                if not "__" in k:
+                    kw[k] = v
         obj = self.actor.create_instance(self, **kw)
         return obj
 
@@ -2143,8 +2177,8 @@ class ActionRequest(BaseRequest):
     #         actor = self.actor
     #     return super(ActorRequest, self).spawn(actor, **kw)
 
-    def row_as_summary(self, obj, *args, **kwargs):
-        return self.actor.row_as_summary(self, obj, *args, **kwargs)
+    def row_as_summary(self, obj, text=None, **kwargs):
+        return self.actor.row_as_summary(self, obj, text, **kwargs)
 
     def row_as_page(self, row, **kwargs):
         return self.actor.row_as_page(self, row, **kwargs)
@@ -2242,6 +2276,7 @@ class ActionRequest(BaseRequest):
         column_names=None,
         header_links=False,
         max_width=None,  # ignored
+        show_links=None,  # ignored
         hide_sums=None,
     ):
         """
@@ -2431,12 +2466,12 @@ class ActionRequest(BaseRequest):
             if v is None:
                 td = E.td(**cellattrs)
             else:
+                td = col.value2html(self, v, **cellattrs)
+                # print("20240506 {} {}".format(col.__class__, tostring(td)))
                 nv = col.value2num(v)
                 if nv != 0:
                     sums[i] += nv
                     has_numeric_value = True
-                td = col.value2html(self, v, **cellattrs)
-                # print("20240506 {} {}".format(col.__class__, tostring(td)))
             col.apply_cell_format(td)
             self.actor.apply_cell_format(self, row, col, recno, td)
             cells.append(td)

lino/core/site.py

@@ -621,7 +621,6 @@ class Site(object):
             db = self.get_database_settings()
             if db is not None:
                 self.django_settings.update(DATABASES=db)
-
         else:
             self.site_dir = self.master_site.site_dir
             self._history_aware_logging = self.master_site._history_aware_logging
@@ -868,16 +867,13 @@ class Site(object):
         for x in self.local_apps:
             add(x)
 
-        # actual_apps = []
         plugins = []
 
-        # disabled_plugins = set()
-
         def install_plugin(app_name, needed_by=None):
             # print("20210305 install_plugin({})".format(app_name))
             # Django does not accept newstr, and we don't want to see
             # ``u'applabel'`` in doctests.
-            app_name = str(app_name)
+            # app_name = str(app_name)
             # print("20160524 install_plugin(%r)" % app_name)
             app_mod = import_module(app_name)
 
@@ -907,14 +903,11 @@ class Site(object):
 
             # Can an `__init__.py` file explicitly set ``Plugin =
             # None``? Is that feature being used?
-            app_class = getattr(app_mod, "Plugin", None)
-            if app_class is None:
-                app_class = Plugin
+            app_class = getattr(app_mod, "Plugin", Plugin)
+            # if app_class is None:
+            #     app_class = Plugin
             cfg = PLUGIN_CONFIGS.pop(k, None)
             ip = app_class(self, k, app_name, app_mod, needed_by, cfg or dict())
-            # cfg = PLUGIN_CONFIGS.pop(k, None)
-            # if cfg:
-            #     ip.configure(**cfg)
 
             self.plugins.define(k, ip)
 
@@ -928,8 +921,6 @@ class Site(object):
                     # plugins.append(dep)
 
             plugins.append(ip)
-            # for dp in ip.disables_plugins:
-            #     disabled_plugins.add(dp)
 
         # lino is always the first plugin:
         install_plugin("lino")
@@ -951,17 +942,10 @@ class Site(object):
         # afterwards.
         # if self.get_auth_method() == 'session':
         if self.user_model:
-            k = str("django.contrib.sessions")
+            k = "django.contrib.sessions"
             if k not in self.plugins:
                 install_plugin(k)
 
-        # for p in plugins:
-        #     if p.app_label in disabled_plugins \
-        #        or p.app_name in disabled_plugins:
-        #         plugins.remove(p)
-        #         del self.plugins[p.app_label]
-
-        # self.update_settings(INSTALLED_APPS=tuple(actual_apps))
         self.update_settings(INSTALLED_APPS=tuple([p.app_name for p in plugins]))
         self.installed_plugins = tuple(plugins)
 
@@ -1009,13 +993,6 @@ class Site(object):
 
         for p in self.installed_plugins:
             reg(p.__class__)
-            # for pp in plugin_parents(p.__class__):
-            #     if p.app_label == 'contacts':
-            #         print("20160524c %s" % pp)
-            #     reg(p.__class__)
-
-        # for m, p in self.override_modlib_models.items():
-        #     print("20160524 %s : %s" % (m, p))
 
         self.installed_plugin_modules = set()
         for p in self.installed_plugins:
@@ -2304,23 +2281,6 @@ class Site(object):
 
         yield E.span(*p)
 
-    def login(self, username=None, **kw):
-        from lino.core import requests
-
-        self.startup()
-        User = self.user_model
-        if User and username:
-            try:
-                kw.update(user=User.objects.get(username=username))
-            except User.DoesNotExist:
-                raise User.DoesNotExist("'{0}' : no such user".format(username))
-
-        # if not 'renderer' in kw:
-        #     kw.update(renderer=self.ui.text_renderer)
-
-        # import lino.core.urls  # hack: trigger ui instantiation
-        return requests.BaseRequest(**kw)
-
     def get_letter_date_text(self, today=None):
         sc = self.site_config.site_company
         if today is None:

lino/core/store.py

@@ -53,6 +53,8 @@ from lino.utils.format_date import fds
 from lino.utils import IncompleteDate
 from lino.core.utils import DelayedValue
 
+FIELD_TYPES = {}
+
 
 class StoreField(object):
     """
@@ -207,6 +209,14 @@ class StoreField(object):
             setattr(instance, self.name, v)
             return True
 
+    @classmethod
+    def register_for_field(cls, dftype, elemtype):
+        if dftype in FIELD_TYPES:
+            raise Exception(f"Duplicate field type {dftype}")
+        FIELD_TYPES[dftype] = cls
+        from lino.core.elems import _FIELD2ELEM
+        _FIELD2ELEM.append((dftype, elemtype))
+
     def format_value(self, ar, v):
         """
         Return a plain textual representation as a unicode string
@@ -424,19 +434,6 @@ class PreviewTextStoreField(StoreField):
             for name in self.column_names():
                 d[name] = getattr(row, name)
 
-
-class MeasurementStoreField(StoreField):
-    def extract_form_data(self, obj, post_data, ar=None):
-        unit = self.field.measurement.STANDARD_UNIT
-        if hasattr(obj, "unit"):
-            new_unit = post_data.get("unitHidden", None)
-            if new_unit is not None:
-                unit = new_unit
-            elif obj.unit is not None:
-                unit = obj.unit.name
-        return self.field.measurement(**{unit: float(post_data.get(self.name, "0.0"))})
-
-
 # class LinkedForeignKeyField(ForeignKeyStoreField):
 
 # def get_rel_to(self,obj):
@@ -821,7 +818,10 @@ class DateStoreField(StoreField):
             try:
                 return datetime.date(*settings.SITE.parse_date(v))
             except Exception as e:
-                raise Warning("Invalid date '{}'' : {}".format(v, e))
+                # The front end is responsible for validating before submitting.
+                # Here it's too late to complain.
+                return None
+                # raise Warning("Invalid date '{}'' : {}".format(v, e))
 
     def format_value(self, ar, v):
         """Return a plain textual representation of this value as a unicode
@@ -1059,13 +1059,13 @@ def create_atomizer(holder, fld, name):
         return DisplayStoreField(fld, name)
     if isinstance(fld, models.IntegerField):
         return IntegerStoreField(fld, name)
-    if isinstance(fld, fields.MeasurementField):
-        return MeasurementStoreField(fld, name)
     if isinstance(fld, fields.PreviewTextField):
         return PreviewTextStoreField(fld, name)
     if isinstance(fld, models.ManyToOneRel):
         # raise Exception("20190625 {} {} {}".format(holder, fld, name))
         return
+    if (sft := FIELD_TYPES.get(fld.__class__, None)) is not None:
+        return sft(fld, name)
     kw = {}
     if choosers.uses_simple_values(holder, fld):
         return StoreField(fld, name, **kw)

lino/core/tables.py

@@ -639,23 +639,6 @@ method in order to sort the rows of the queryset.
     #     # print("20181230 detail_pointer() {}".format(cls))
     #     return obj.as_summary_item(ar)
 
-    @classmethod
-    def request(self, master_instance=None, **kw):
-        """Return a new :class:`ActionRequest
-        <lino.core.requests.ActionRequest>` on this table.
-
-        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 ActionRequest(**kw)
-
     @classmethod
     def run_action_from_console(self, pk=None, an=None):
         """

lino/core/utils.py

@@ -23,6 +23,8 @@ from django.core import exceptions
 from django.http import QueryDict
 
 from lino.utils.html import E, assert_safe, tostring
+from lino.utils import capture_output
+from lino.utils.ranges import isrange
 
 from django.core.validators import validate_email, ValidationError, URLValidator
 
@@ -309,21 +311,41 @@ def range_filter(value, f1, f2):
     q2 = Q(**{f2 + "__isnull": True}) | Q(**{f2 + "__gte": value})
     return Q(q1, q2)
 
-
 def inrange_filter(fld, rng, **kw):
     """Assuming a database model with a field named `fld`, return a Q
-    object to select those rows whose `fld` value is not null and
-    within the given range `rng`.  `rng` must be a tuple or list with
-    two items.
-
+    object to select the rows having value for `fld` within the given range `rng`.
+    `rng` must be a tuple or list with two items.
     """
-    assert rng[0] <= rng[1]
+
+    # assert rng[0] <= rng[1]
     kw[fld + "__isnull"] = False
-    kw[fld + "__gte"] = rng[0]
-    kw[fld + "__lte"] = rng[1]
+    if rng[0] is not None:
+        kw[fld + "__gte"] = rng[0]
+    if rng[1] is not None:
+        kw[fld + "__lte"] = rng[1]
     return Q(**kw)
 
 
+def overlap_range_filter(sv, ev, f1, f2, **kw):
+    """
+
+    Return a Q object to select all objects having fields `f1` and `f2` define a
+    range that overlaps with the range specified by `sv` (start value) and `ev`
+    (end value).
+
+    For example, when I specify filter parameters `Date from` 2024-02-21 and
+    `until` 2024-03-12 in a :class:`lino.modlib.periods.StoredPeriods` table, I
+    want both February and March. Tested examples see
+    :ref:`dg.plugins.periods.period_filter`.
+
+    """
+    # if not isrange(rng[0], rng[1]):
+    #     raise ValueError(f"{rng} is not a valid range")
+    if not ev:
+        ev = sv
+    return Q(**{f1+"__lte" : ev, f2+"__gte" : sv})
+
+
 def babelkw(*args, **kw):
     return settings.SITE.babelkw(*args, **kw)
 
@@ -679,7 +701,7 @@ class ParameterPanel(object):
 
     Subclassed e.g. by
     :class:`lino.mixins.periods.ObservedDateRange`.
-    :class:`lino_xl.lib.accounting.AccountingPeriodRange`.
+    :class:`lino_xl.lib.accounting.PeriodRangeParameters`.
     """
 
     def __init__(self, **kw):
@@ -1042,7 +1064,7 @@ class InstanceAction:
         """
         if len(args) and isinstance(args[0], BaseRequest):
             raise ChangedAPI("20181004")
-        ar = self.bound_action.request()
+        ar = self.bound_action.request(renderer=settings.SITE.kernel.text_renderer)
         self.run_from_code(ar, *args, **kwargs)
         return ar.response
 
@@ -1087,3 +1109,29 @@ class PhantomRow(VirtualRow):
 
     def __str__(self):
         return str(self._ar.get_action_title())
+
+
+
+def login(username=None, **kwargs):
+    """Return a basic :term:`action request` with the specified user signed in. 
+    """
+    from lino.core.requests import BaseRequest  # avoid circular import
+    # settings.SITE.startup()
+    User = settings.SITE.user_model
+    if User and username:
+        try:
+            kwargs.update(user=User.objects.get(username=username))
+        except User.DoesNotExist:
+            raise User.DoesNotExist(f"'{username}' : no such user")
+
+    kwargs.setdefault("show_urls", False)
+    # import lino.core.urls  # hack: trigger ui instantiation
+    return BaseRequest(**kwargs)
+
+def show(*args, **kwargs):
+    """Print the specified data table to stdout."""
+    return login().show(*args, **kwargs)
+
+def shows(*args, **kwargs):
+    """Return the output of :func:`show`."""
+    return capture_output(show, *args, **kwargs)

lino/core/views.py

@@ -1,4 +1,4 @@
-# Copyright 2010-2020 Rumma & Ko Ltd
+# Copyright 2010-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 """Utility functions used by :mod:`lino.modlib.extjs.views`.
 
@@ -99,6 +99,7 @@ def action_request(app_label, actor, request, rqdata, is_list, **kw):
             # The text of an Exception may not be
             # internationalized because some error handling code
             # may want to write it to a plain ascii stream.
+    kw.update(renderer=settings.SITE.kernel.default_renderer)
     ar = rpt.request(request=request, action=a, rqdata=rqdata, **kw)
     # print("20210403b", a.action.__class__, rqdata)
     return ar

lino/help_texts.py

@@ -376,6 +376,18 @@ help_texts = {
     'lino.modlib.linod.SystemTask.log_level' : _("""The logging level to apply when running this task."""),
     'lino.modlib.linod.SystemTask.run' : _("""Performs a routine job."""),
     'lino.modlib.linod.SystemTasks' : _("""The default actor for the SystemTask model."""),
+    'lino.modlib.periods.StoredYear' : _("""The Django model used to store an fiscal year."""),
+    'lino.modlib.periods.StoredPeriod' : _("""The Django model used to store an accounting period."""),
+    'lino.modlib.periods.StoredYears' : _("""The fiscal years defined in this database."""),
+    'lino.modlib.periods.StoredPeriods' : _("""The accounting periods defined in this database."""),
+    'lino.modlib.periods.PeriodTypes' : _("""A list of choices for the values allowed as periods.period_type."""),
+    'lino.modlib.periods.PeriodRange' : _("""Model mixin for objects that cover a range of accounting periods."""),
+    'lino.modlib.periods.PeriodRange.start_period' : _("""The first period of the range to cover."""),
+    'lino.modlib.periods.PeriodRange.end_period' : _("""The last period of the range to cover."""),
+    'lino.modlib.periods.PeriodRangeObservable' : _("""Model mixin for objects that can be filtered by a range of accounting periods. This adds two parameter fields start_period and end_period to every table on this model."""),
+    'lino.modlib.periods.StoredPeriodRange' : _("""A parameter panel with two fields:"""),
+    'lino.modlib.periods.StoredPeriodRange.start_period' : _("""Start of observed period range."""),
+    'lino.modlib.periods.StoredPeriodRange.end_period' : _("""Optional end of observed period range. Leave empty to consider only the Start period."""),
     'lino.modlib.publisher.Page' : _("""The Django model that represents a content page."""),
     'lino.modlib.publisher.PublisherBuildMethod' : _("""This deserves better documentation."""),
     'lino.modlib.publisher.Publishable' : _("""Model mixin to add to models that are potentially publishable."""),
@@ -645,6 +657,7 @@ help_texts = {
     'lino.modlib.system.DurationUnits' : _("""The list of possible duration units defined by this application."""),
     'lino.modlib.system.DurationUnit' : _("""Base class for the choices in the DurationUnits choicelist."""),
     'lino.modlib.system.DurationUnit.add_duration' : _("""Return a date or datetime obtained by adding value times this unit to the specified value orig. Returns None is orig is empty."""),
+    'lino.modlib.system.DisplayColors' : _("""A list of colors to be specified for displaying."""),
     'lino.modlib.system.BleachChecker' : _("""A data checker used to find unbleached html content."""),
     'lino.modlib.system.Genders' : _("""Defines the possible choices for the gender of a person (“male”, “female” and “nonbinary”)."""),
     'lino.modlib.system.YesNo' : _("""A choicelist with two values “Yes” and “No”."""),

lino/management/commands/show.py

@@ -3,11 +3,9 @@
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 import argparse
-
-from django.conf import settings
+from lino.api import rt
 from django.core.management.base import BaseCommand, CommandError
 
-
 class Command(BaseCommand):
     help = "Show the content of a specified table to standard output."
 
@@ -43,6 +41,6 @@ class Command(BaseCommand):
             spec = args[0]
 
         username = options["username"]
-        ses = settings.SITE.login(username)
+        ses = rt.login(username)
 
         ses.show(spec, language=options["language"])