lino 24.10.3__py3-none-any.whl → 24.11.1__py3-none-any.whl

lino/core/site.py

@@ -18,11 +18,6 @@ from pprint import pprint
 from logging.handlers import SocketHandler
 import time
 
-try:
-    from bleach.sanitizer import ALLOWED_ATTRIBUTES
-except ImportError:
-    ALLOWED_ATTRIBUTES = dict()
-
 NO_REMOTE_AUTH = True
 # 20240518 We have only one production site still using remote http
 # authentication, and they will migrate to sessions-based auth with their next
@@ -359,44 +354,6 @@ class Site(object):
 
     detail_main_name = "main"
 
-    bleach_allowed_tags = [
-        "a",
-        "b",
-        "i",
-        "em",
-        "ul",
-        "ol",
-        "li",
-        "strong",
-        "p",
-        "br",
-        "span",
-        "pre",
-        "def",
-        "div",
-        "img",
-        "table",
-        "th",
-        "tr",
-        "td",
-        "thead",
-        "tfoot",
-        "tbody",
-    ]
-
-    ALLOWED_ATTRIBUTES["span"] = [
-        "class",
-        "data-index",
-        "data-denotation-char",
-        "data-link",
-        "data-title",
-        "data-value",
-        "contenteditable",
-    ]
-    ALLOWED_ATTRIBUTES["p"] = ["href", "title", "align"]
-
-    bleach_allowed_attributes = ALLOWED_ATTRIBUTES
-
     textfield_bleached = True
     textfield_format = "plain"
     verbose_client_info_message = False
@@ -621,13 +578,14 @@ 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
             for k in ("DATABASES", "SECRET_KEY"):
                 self.django_settings[k] = self.master_site.django_settings[k]
 
+        self.update_settings(
+            EMAIL_SUBJECT_PREFIX=f'[{self.project_name}] ')
         self.update_settings(
             SERIALIZATION_MODULES={
                 "py": "lino.utils.dpy",
@@ -868,16 +826,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)
 
@@ -900,21 +855,18 @@ class Site(object):
                     # the default_ui.
                     return
                 raise Exception(
-                    "Tried to install {} where {} " "is already installed.".format(
+                    "Tried to install {}, but {} is already installed.".format(
                         app_name, other
                     )
                 )
 
             # 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 +880,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 +901,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 +952,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:
@@ -1032,7 +968,7 @@ class Site(object):
             for r in p.get_requirements(self):
                 reqs.add(r)
         if self.textfield_bleached:
-            reqs.add("bleach")
+            reqs.add("beautifulsoup4")
         return sorted(reqs)
 
     def setup_plugins(self):
@@ -2304,23 +2240,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)
@@ -1230,10 +1227,10 @@ class Store(BaseStore):
             dh = form.get_layout_handle()
             self.collect_fields(self.card_fields, dh)
 
-        form = rh.actor.list_layout
-        if form:
-            dh = form.get_layout_handle()
-            self.collect_fields(self.item_fields, dh)
+        # form = rh.actor.list_layout
+        # if form:
+        #     dh = form.get_layout_handle()
+        #     self.collect_fields(self.item_fields, dh)
 
         if self.pk is not None:
             self.pk_index = 0

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
@@ -378,7 +379,7 @@ class UnresolvedModel(object):
         # ~ print(self)
 
     def __repr__(self):
-        return self.__class__.__name__ + "(%s,%s)" % (self.model_spec, self.app_label)
+        return self.__class__.__name__ + "(%r, %s)" % (self.model_spec, self.app_label)
 
     # ~ def __getattr__(self,name):
     # ~ raise AttributeError("%s has no attribute %r" % (self,name))
@@ -420,6 +421,9 @@ def resolve_model(model_spec, app_label=None, strict=False):
             # settings.SITE.logger.info("20181230 resolve %s --> %r, %r",
             #                           model_spec, app, model)
         else:
+            # 20241112 Helped to explore #5797 (Could not resolve target
+            # 'uploads.UploadType' of ForeignKey 'type' in <class
+            # 'lino.modlib.uploads.models.Upload'>)
             from django.apps import apps
 
             try:
@@ -1063,7 +1067,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 +1112,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

@@ -56,8 +56,8 @@ help_texts = {
     'lino.mixins.periods.Started.save' : _("""Fills default value “today” to start_date"""),
     'lino.mixins.periods.Ended' : _("""Mixin for models with two fields end_date and end_time."""),
     'lino.mixins.periods.Ended.get_duration' : _("""Return the duration in hours."""),
-    'lino.mixins.periods.DateRange' : _("""Mixin for models that represent a period defined by a start date and an end date."""),
-    'lino.mixins.periods.ObservedDateRange' : _("""lino.core.param_panel.ParameterPanel with two fields start_date and end_date which default to empty."""),
+    'lino.mixins.periods.DateRange' : _("""A model mixin that adds two fields start_date and end_date. DateRangeObservable"""),
+    'lino.mixins.periods.ObservedDateRange' : _("""lino.core.param_panel.ParameterPanel with two fields start_date and end_date."""),
     'lino.mixins.periods.Yearly' : _("""An ObservedDateRange for which start_date defaults to Jan 1st and end_date to Dec 31 of the current year."""),
     'lino.mixins.periods.Monthly' : _("""An ObservedDateRange which defaults to the current month."""),
     'lino.mixins.periods.Weekly' : _("""An ObservedDateRange which defaults to the current week."""),
@@ -174,6 +174,7 @@ help_texts = {
     'lino.modlib.tinymce.Plugin.media_name' : _("""Lino currently includes three versions of TinyMCE, but for production sites we still use the eldest version 3.4.8."""),
     'lino.modlib.uploads.Plugin' : _("""See /dev/plugins."""),
     'lino.modlib.uploads.Plugin.remove_orphaned_files' : _("""Whether checkdata –fix should automatically delete orphaned files in the uploads folder."""),
+    'lino.modlib.uploads.Plugin.with_thumbnails' : _("""Whether to use PIL, the Python Imaging Library."""),
     'lino.modlib.weasyprint.Plugin' : _("""See /dev/plugins."""),
     'lino.modlib.weasyprint.Plugin.header_height' : _("""Height of header in mm. Set to None if you want no header."""),
     'lino.modlib.weasyprint.Plugin.footer_height' : _("""Height of footer in mm. Set to None if you want no header."""),
@@ -376,8 +377,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."""),
@@ -512,7 +516,6 @@ help_texts = {
     'lino.modlib.comments.Commentable.add_comments_filter' : _("""Add filters to the given queryset of comments, requested by the given user."""),
     'lino.modlib.comments.Commentable.get_rfc_description' : _("""Return a HTML formatted string with the description of this Commentable as it should be displayed by the slave summary of CommentsByOwner."""),
     'lino.modlib.comments.Commentable.on_commented' : _("""This is automatically called when a comment has been created or modified."""),
-    'lino.modlib.comments.Commentable.get_comment_group' : _("""(Currently not used)"""),
     'lino.modlib.files.Volume' : _("""The Django model representing a file volume."""),
     'lino.modlib.files.Volume.id' : _("""The primary key used to point to this volume from a database object."""),
     'lino.modlib.files.Volume.ref' : _("""The full path of the root folder."""),
@@ -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”."""),
@@ -685,6 +689,7 @@ help_texts = {
     'lino.modlib.uploads.UploadController.show_uploads' : _("""Opens a data window with the uploaded files associated to this database object."""),
     'lino.modlib.uploads.UploadsByController' : _("""Shows the uploaded files associated to this database object."""),
     'lino.modlib.uploads.Shortcuts' : _("""The list of available upload shortcut fields in this application."""),
+    'lino.modlib.uploads.Previewers' : _("""An abstract choicelist of the previewers that are available on this site."""),
     'lino.modlib.uploads.UploadsFolderChecker' : _("""Find orphaned files in uploads folder."""),
     'lino.modlib.weasyprint.WeasyBuildMethod' : _("""The base class for both build methods."""),
     'lino.modlib.weasyprint.WeasyHtmlBuildMethod' : _("""Renders the input template and returns the unmodified output as plain HTML."""),