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

lino/core/requests.py

@@ -81,6 +81,26 @@ Subject: {subject}
 def noop(ar):
     return ar.success(gettext("Aborted"))
 
+def mi2bp(master_instance, bp):
+    if master_instance is not None:
+        if isinstance(master_instance, (models.Model, TableRow)):
+            bp[constants.URL_PARAM_MASTER_PK] = master_instance.pk
+            if ContentType is not None and isinstance(
+                master_instance, models.Model
+            ):
+                assert not master_instance._meta.abstract
+                mt = ContentType.objects.get_for_model(
+                    master_instance.__class__).pk
+                bp[constants.URL_PARAM_MASTER_TYPE] = mt
+            # else:
+            #     logger.warning("20141205 %s %s",
+            #                    self.master_instance,
+            #                    ContentType)
+        else:  # if self.master is None:
+            # e.g. in accounting.MovementsByMatch the master is a `str`
+            bp[constants.URL_PARAM_MASTER_PK] = master_instance
+            # raise Exception("No master key for {} {!r}".format(
+            #     self.master_instance.__class__, self.master_instance))
 
 class StringLogger(logging.Logger):
     # Instantiated by BaseRequest.capture_logger()
@@ -152,7 +172,7 @@ class ValidActionResponses(object):
 
     no_data_text = None
     title = None
-    """The dynamic title to give to the window or component which shows this response.
+    """The dynamic title to give to the window or component that shows this response.
     TODO: is this still being used?
     """
 
@@ -308,7 +328,7 @@ class BaseRequest:
     action_param_values = None
     param_values = None
     bound_action = None
-    known_values = {}
+    known_values = None
     no_data_text = _("No data to display")
     is_on_main_actor = True
     permalink_uris = False
@@ -317,6 +337,12 @@ class BaseRequest:
     master_instance = None
     request = None
     selected_rows = []
+    obvious_fields = None
+    order_by = None
+    filter = None
+    gridfilters = None,
+    quick_search = None
+    extra = None
     content_type = "application/json"
     requesting_panel = None
     xcallback_answers = {}
@@ -331,11 +357,19 @@ class BaseRequest:
         parent=None,
         is_on_main_actor=True,
         permalink_uris=None,
+        known_values=None,
+        obvious_fields=None,
         **kw
     ):
         self.response = dict()
+        self.obvious_fields = set()
+        if obvious_fields is not None:
+            self.obvious_fields |= obvious_fields
         # if str(kw.get('actor', None)) == "cal.EntriesByController":
         # if kw.get('actor', None):
+
+        self.known_values = dict()
+
         if request is not None:
             assert parent is None
             self.request = request
@@ -356,9 +390,11 @@ class BaseRequest:
                         raise Exception("%s : %s is None" % (kw, k))
                 else:
                     kw[k] = getattr(parent, k)
-            kv = kw.setdefault("known_values", {})
-            if parent.actor is self.actor:
-                kv.update(parent.known_values)
+            # kv = kw.setdefault("known_values", {})
+            if parent.actor is not None and parent.actor is self.actor:
+                kw['param_values'] = parent.param_values
+                if parent.known_values is not None:
+                    self.known_values.update(parent.known_values)
             # kw.setdefault('user', parent.user)
             # kw.setdefault('subst_user', parent.subst_user)
             # kw.setdefault('renderer', parent.renderer)
@@ -377,10 +413,27 @@ class BaseRequest:
         self.is_on_main_actor = is_on_main_actor
         self.permalink_uris = permalink_uris
 
+        if known_values is not None:
+            self.known_values.update(known_values)
+
         self.setup(**kw)
 
         # print("20241101", self.__class__.__name__, self.show_urls)
 
+        self.obvious_fields |= set(self.known_values.keys())
+
+        if self.actor is not None:
+
+            for k, v in self.actor.known_values.items():
+                self.known_values.setdefault(k, v)
+
+            self.obvious_fields |= self.actor.obvious_fields
+                # self.obvious_fields.update(obvious_fields.split())
+            # if parent.obvious_fields is not None:
+            if parent is not None and parent.actor is self.actor and parent.obvious_fields:
+                self.obvious_fields |= parent.obvious_fields
+            self.obvious_fields.add(self.actor.master_key)
+
         if self.master is not None and settings.SITE.strict_master_check:
             if self.master_instance is None:
                 raise exceptions.BadRequest(
@@ -409,12 +462,21 @@ class BaseRequest:
         requesting_panel=None,
         renderer=None,
         xcallback_answers=None,
-        known_values={},
         show_urls=None,
+        quick_search=None,
+        order_by=None,
+        filter=None,
+        gridfilters=None,
+        extra=None,
     ):
         if logger is not None:
             self.logger = logger
         self.requesting_panel = requesting_panel
+        self.quick_search = quick_search
+        self.order_by = order_by
+        self.filter = filter
+        self.gridfilters = gridfilters
+        self.extra = extra
         if user is None:
             self.user = settings.SITE.get_anonymous_user()
         else:
@@ -532,36 +594,11 @@ class BaseRequest:
                 master_key=rqdata.get(constants.URL_PARAM_MASTER_PK, None),
             )
 
-        # if settings.SITE.use_filterRow:
-        #     exclude = dict()
-        #     for f in self.ah.store.fields:
-        #         if f.field:
-        #             filterOption = rqdata.get(
-        #                 'filter[%s_filterOption]' % f.field.name)
-        #             if filterOption == 'empty':
-        #                 kw[f.field.name + "__isnull"] = True
-        #             elif filterOption == 'notempty':
-        #                 kw[f.field.name + "__isnull"] = False
-        #             else:
-        #                 filterValue = rqdata.get('filter[%s]' % f.field.name)
-        #                 if filterValue:
-        #                     if not filterOption:
-        #                         filterOption = 'contains'
-        #                     if filterOption == 'contains':
-        #                         kw[f.field.name + "__icontains"] = filterValue
-        #                     elif filterOption == 'doesnotcontain':
-        #                         exclude[f.field.name +
-        #                                 "__icontains"] = filterValue
-        #                     else:
-        #                         print("unknown filterOption %r" % filterOption)
-        #     if len(exclude):
-        #         kw.update(exclude=exclude)
-
         if settings.SITE.use_gridfilters:
-            filter = rqdata.get(constants.URL_PARAM_GRIDFILTER, None)
-            if filter is not None:
-                filter = json.loads(filter)
-                kw["gridfilters"] = [constants.dict2kw(flt) for flt in filter]
+            v = rqdata.get(constants.URL_PARAM_GRIDFILTER, None)
+            if v is not None:
+                v = json.loads(v)
+                kw["gridfilters"] = [constants.dict2kw(flt) for flt in v]
 
         # kw = ActionRequest.parse_req(self, request, rqdata, **kw)
         if settings.SITE.user_model:
@@ -962,6 +999,8 @@ class BaseRequest:
             )
             return
 
+        self.logger.info("Send email '%s' from %s to %s", subject, sender, recipients)
+
         recipients = [a for a in recipients if "@example.com" not in a]
         if not len(recipients):
             self.logger.info(
@@ -970,8 +1009,6 @@ class BaseRequest:
             # self.logger.info("Email body would have been %s", body)
             return
 
-        self.logger.info("Send email '%s' from %s to %s", subject, sender, recipients)
-
         kw = {}
         if body.startswith("<"):
             kw["html_message"] = body
@@ -1128,14 +1165,17 @@ class BaseRequest:
         an obvious value.
 
         """
-        if name in self.known_values:
-            return True
-        # if self.param_values is not None and name in self.param_values:
+        return name in self.obvious_fields
+        # if name in self.known_values:
         #     return True
-        if self.actor is not None:
-            if self.actor.master_key == name:
-                return True
-        return False
+        # # if self.param_values is not None and name in self.param_values:
+        # #     return True
+        # if self.actor is not None:
+        #     if self.actor.master_key == name:
+        #         return True
+        #     if name in self.actor.obvious_fields:
+        #         return True
+        # return False
 
     def get_user(self):
         """
@@ -1338,10 +1378,8 @@ class BaseRequest:
         return self.renderer.obj2url(self, *args, **kwargs)
 
     def obj2html(self, obj, text=None, **kwargs):
-        """
-        Return a clickable HTML element that points to a detail view of the
-        given database object.
-        """
+        # Return a clickable HTML element that points to a detail view of the
+        # given database object.
         if obj is None:
             return ""
         return self.renderer.obj2html(self, obj, text, **kwargs)
@@ -1666,11 +1704,8 @@ class ActionRequest(BaseRequest):
     renderer = None
     offset = None
     limit = None
-    order_by = None
     master = None
-    extra = None
     title = None
-    filter = None
     limit = None
     offset = None
 
@@ -1703,28 +1738,16 @@ class ActionRequest(BaseRequest):
 
     def setup(
         self,
-        known_values=None,
         param_values=None,
         action_param_values={},
-        quick_search=None,
-        order_by=None,
         offset=None,
         limit=None,
         title=None,
-        filter=None,
-        gridfilters=None,
         exclude=None,
         selected_pks=None,
         selected_rows=None,
-        extra=None,
         **kw
     ):
-        self.quick_search = quick_search
-        self.order_by = order_by
-        self.filter = filter
-        self.gridfilters = gridfilters
-        self.extra = extra
-
         if title is not None:
             self.title = title
         if offset is not None:
@@ -1743,12 +1766,7 @@ class ActionRequest(BaseRequest):
         assert self.actor is not None
         request = self.request
 
-        kv = dict()
-        for k, v in self.actor.known_values.items():
-            kv.setdefault(k, v)
-        if known_values:
-            kv.update(known_values)
-        self.known_values = kv
+        self.actor.setup_request(self)
 
         if self.actor.parameters is not None:
             pv = self.actor.param_defaults(self)
@@ -1826,8 +1844,6 @@ class ActionRequest(BaseRequest):
             self.set_action_param_values(**action_param_values)
         self.bound_action.setup_action_request(self)
 
-        self.actor.setup_request(self)
-
         # if str(self.actor) == 'outbox.MyOutbox':
         #     if self.master_instance is None:
         #         raise Exception("20230426 b {}".format(self.master))
@@ -1899,6 +1915,8 @@ class ActionRequest(BaseRequest):
         if target is None:
             target = self.actor
         if self._insert_sar is None:
+            if target.insert_action is None:
+                raise Exception(f"20241212 {target} has no insert_action")
             self._insert_sar = target.insert_action.request_from(self)
         else:
             assert self._insert_sar.actor is target
@@ -2132,26 +2150,7 @@ class ActionRequest(BaseRequest):
             for k, v in self.known_values.items():
                 if self.actor.known_values.get(k, None) != v:
                     bp[k] = v
-        if self.master_instance is not None:
-            if isinstance(self.master_instance, (models.Model, TableRow)):
-                bp[constants.URL_PARAM_MASTER_PK] = self.master_instance.pk
-                if ContentType is not None and isinstance(
-                    self.master_instance, models.Model
-                ):
-                    assert not self.master_instance._meta.abstract
-                    mt = ContentType.objects.get_for_model(
-                        self.master_instance.__class__
-                    ).pk
-                    bp[constants.URL_PARAM_MASTER_TYPE] = mt
-                # else:
-                #     logger.warning("20141205 %s %s",
-                #                    self.master_instance,
-                #                    ContentType)
-            else:  # if self.master is None:
-                # e.g. in accounting.MovementsByMatch the master is a `str`
-                bp[constants.URL_PARAM_MASTER_PK] = self.master_instance
-                # raise Exception("No master key for {} {!r}".format(
-                #     self.master_instance.__class__, self.master_instance))
+        mi2bp(self.master_instance, bp)
         self._status = kw
         return kw
 
@@ -2445,7 +2444,7 @@ class ActionRequest(BaseRequest):
             oh = ar.actor.override_column_headers(ar)
             if oh:
                 for i, e in enumerate(columns):
-                    header = oh.get(e.name, None)
+                    header = oh.get(e, None)
                     if header is not None:
                         headers[i] = header
                 # ~ print 20120507, oh, headers

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
@@ -627,6 +584,8 @@ class Site(object):
             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",
@@ -896,7 +855,7 @@ 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
                     )
                 )
@@ -1009,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):
@@ -2206,7 +2165,7 @@ class Site(object):
     site_prefix = "/"
     """The string to prefix to every URL of the Lino web interface.
 
-    This must *start and end with a *slash*.  Default value is
+    This must *start and end* with a *slash*.  Default value is
     ``'/'``.
 
     This must be set if your project is not being served at the "root"

lino/core/store.py

@@ -1227,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

@@ -521,22 +521,6 @@ method in order to sort the rows of the queryset.
             return cls.detail_action
         return actions.ShowTable()
 
-    @classmethod
-    def row_as_paragraph(cls, ar, row):
-        """Return an HTML string that represents the given row as a single
-        paragraph.
-
-        See :ref:`dev.as_paragraph`.
-        """
-        return row.as_paragraph(ar)
-
-    @classmethod
-    def row_as_page(cls, ar, row, **kwargs):
-        """
-        Return an HTML string that represent the given row as a plain page.
-        """
-        return row.as_page(ar, **kwargs)
-
     @classmethod
     def get_actor_editable(self):
         if self._editable is None:

lino/core/utils.py

@@ -379,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))
@@ -421,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:
@@ -1113,7 +1116,7 @@ class PhantomRow(VirtualRow):
 
 
 def login(username=None, **kwargs):
-    """Return a basic :term:`action request` with the specified user signed in. 
+    """Return a basic :term:`action request` with the specified user signed in.
     """
     from lino.core.requests import BaseRequest  # avoid circular import
     # settings.SITE.startup()

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."""),
@@ -322,8 +323,10 @@ help_texts = {
     'lino.core.model.Model.allow_cascaded_delete' : _("""A set of names of ForeignKey or GenericForeignKey fields of this model that allow for cascaded delete."""),
     'lino.core.model.Model.disabled_fields' : _("""Return a set of field names that should be disabled (i.e. not editable) for this database object."""),
     'lino.core.model.Model.__str__' : _("""Return a translatable text that describes this database row."""),
-    'lino.core.model.Model.as_paragraph' : _("""Return a safe HTML string that represents this database row as a paragraph."""),
+    'lino.core.model.Model.as_str' : _("""Return a translatable text that describes this database row. Unlike __str__() this method gets an action request when it is called, so it knows the context."""),
+    'lino.core.model.Model.get_str_words' : _("""Yield a series of words that describe this database row in plain text."""),
     'lino.core.model.Model.as_summary_item' : _("""Return a HTML element that represents this database row in a data window in display mode “summary”."""),
+    'lino.core.model.Model.as_paragraph' : _("""Return a safe HTML string that represents this database row as a paragraph."""),
     'lino.core.model.Model.set_widget_options' : _("""Set default values for the widget options of a given element."""),
     'lino.core.model.Model.get_overview_elems' : _("""Return a list of HTML elements to be shown in overview field."""),
     'lino.core.model.Model.merge_row' : _("""Merge this object into another object of same class."""),
@@ -376,7 +379,7 @@ 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.StoredYear' : _("""The Django model used to store a 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."""),
@@ -515,7 +518,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."""),