lino 24.10.3__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):
@@ -1062,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,7 @@ 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
@@ -1063,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
 
@@ -1108,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,8 +376,11 @@ 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.StoredPeriod' : _("""An accounting period is the smallest time slice to be declared in accounting reports. Usually it corresponds to one month. But there are except for some small companies which declare per quarter."""),
-    'lino.modlib.periods.StoredYears' : _("""The fiscal years available in this database."""),
+    '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."""),
@@ -654,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"])

lino/mixins/periods.py

@@ -214,11 +214,11 @@ class DateRangeObservable(Model):
     def setup_parameters(cls, fields):
         fields.update(
             start_date=models.DateField(
-                _("Period from"),
+                _("Date range from"),
                 blank=True,
                 null=True,
                 default=cls.get_default_start_date,
-                help_text=_("Start date of observed period"),
+                help_text=_("Start date of observed date range."),
             )
         )
         fields.update(
@@ -227,7 +227,7 @@ class DateRangeObservable(Model):
                 blank=True,
                 null=True,
                 default=cls.get_default_end_date,
-                help_text=_("End date of observed period"),
+                help_text=_("End date of observed date range."),
             )
         )
         super().setup_parameters(fields)
@@ -267,6 +267,12 @@ class DateRange(DateRangeObservable):
     def get_period_text(self):
         return rangetext(self, fdl, self.empty_period_text)
 
+    def covers_date(self, d):
+        if self.start_date and self.start_date > d:
+            return False
+        if self.end_date and self.end_date < d:
+            return False
+        return True
 
 DateRange.set_widget_options("start_date", width=10)
 DateRange.set_widget_options("end_date", width=10)

lino/mixins/polymorphic.py

@@ -247,16 +247,16 @@ class Polymorphic(model.Model):
         buttons = self.get_mti_buttons(ar)
         return E.span(*buttons)
 
-    def as_summary_item(self, ar, *args, **kwargs):
+    def as_summary_item(self, ar, text=None, **kwargs):
         # a = super(Polymorphic, self).get_detail_action(ar)
         a = self.get_detail_action(ar)
         if a is not None:
-            return super().as_summary_item(ar, *args, **kwargs)
+            return super().as_summary_item(ar, text, **kwargs)
         for m in self._mtinav_models:
             if m is not self.__class__:
                 obj = mti.get_child(self, m)
                 if obj is not None:
                     if obj.get_detail_action(ar) is not None:
-                        return obj.as_summary_item(ar, *args, **kwargs)
+                        return obj.as_summary_item(ar, text, **kwargs)
         return str(self)
         # return "?!? {} has no detail_action for {}".format(self, ar)

lino/mixins/ref.py

@@ -47,7 +47,7 @@ class Referrable(model.Model):
     @classmethod
     def on_analyze(cls, site):
         cls.set_widget_options("ref", width=cls.ref_max_length)
-        super(Referrable, cls).on_analyze(site)
+        super().on_analyze(site)
 
     def on_duplicate(self, ar, master):
         """
@@ -56,7 +56,10 @@ class Referrable(model.Model):
         """
         if self.ref:
             self.ref += " (DUP)"
-        super(Referrable, self).on_duplicate(ar, master)
+        super().on_duplicate(ar, master)
+
+    def __str__(self):
+        return self.ref or super().__str__()
 
     @staticmethod
     def ref_prefix(obj, ar=None):
@@ -96,7 +99,7 @@ class Referrable(model.Model):
         # if search_text.isdigit():
         if search_text.startswith("*"):
             return models.Q(**{prefix + "ref__icontains": search_text[1:]})
-        return super(Referrable, cls).quick_search_filter(search_text, prefix)
+        return super().quick_search_filter(search_text, prefix)
 
 
 class StructuredReferrable(Referrable):