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

lino/modlib/uploads/ui.py

@@ -66,10 +66,11 @@ class UploadDetail(dd.DetailLayout):
     """
 
     left = """
-    file user
+    file
     volume:10 library_file:40
-    upload_area type description
-    owner
+    user owner
+    upload_area type
+    description
     source
     """
 
@@ -82,6 +83,11 @@ class Uploads(dd.Table):
     required_roles = dd.login_required(UploadsReader)
     column_names = "file type user owner description id *"
     order_by = ["-id"]
+    default_display_modes = {
+        70: constants.DISPLAY_MODE_LIST,
+        None: constants.DISPLAY_MODE_GALLERY
+    }
+    # extra_display_modes = {constants.DISPLAY_MODE_LIST, constants.DISPLAY_MODE_GALLERY}
 
     detail_layout = "uploads.UploadDetail"
 
@@ -197,10 +203,10 @@ class AreaUploads(Uploads):
                     # icon_name='application_form',
                     title=_("Edit metadata of the uploaded file."),
                 )
-                url = m.get_file_url()
-                if url:
+                mf = m.get_media_file()
+                if mf:
                     show = ar.renderer.href_button(
-                        url,
+                        mf.get_download_url(),
                         # u"\u21A7",  # DOWNWARDS ARROW FROM BAR (↧)
                         # u"\u21E8",
                         "\u21f2",  # SOUTH EAST ARROW TO CORNER (⇲)

lino/modlib/uploads/utils.py

@@ -0,0 +1,107 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2010-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+from os.path import splitext
+from django.conf import settings
+from django.utils.text import format_lazy
+from lino.api import dd, rt, _
+from lino.utils import needs_update
+
+if (with_thumbnails := dd.get_plugin_setting('uploads', 'with_thumbnails', False)):
+    from PIL import Image  # pip install Pillow
+    import pymupdf    # pip install PyMuPDF
+
+class UploadMediaFile:
+
+    def __init__(self, url):
+        self.url = url
+        assert url is not None
+        root, suffix = splitext(url)
+        self.suffix = suffix.lower()
+
+    def get_image_name(self):
+        if self.suffix not in previewer.PREVIEW_SUFFIXES:
+            return None
+        if previewer.base_dir is None:
+            if self.suffix == ".pdf":
+                return None
+            return self.url
+        url = self.url
+        if self.suffix == ".pdf":
+            url += ".png"
+        return previewer.base_dir + "/" + url
+
+    def get_mimetype_description(self):
+        if self.suffix == ".pdf":
+            return _("PDF file")
+        if self.get_image_name():
+            return _("picture")
+        return _("media file")
+
+    def get_image_url(self):
+        url = self.get_image_name()
+        if url is not None:
+            return settings.SITE.build_media_url(url)
+
+    def get_download_url(self):
+        return settings.SITE.build_media_url(self.url)
+
+
+class Previewer:
+    # The bare media previewer. It doesn't do any real work.
+    base_dir = None
+    max_width = None
+    PREVIEW_SUFFIXES = {'.png', '.jpg'}
+
+    def check_preview(self, obj, fix=False):
+        return []
+
+
+class FilePreviewer(Previewer):
+    # A media previewer that builds thumbnails in a separate directory tree
+    PREVIEW_SUFFIXES = {'.png', '.jpg', '.pdf'}
+
+    def __init__(self, base_dir=None, max_width=None):
+        self.base_dir = base_dir
+        self.max_width = max_width
+        super().__init__()
+
+    def check_preview(self, obj, fix=False):
+        mf = obj.get_media_file()
+        if mf is None:
+            return
+        if (dst := mf.get_image_name()) is None:
+            return
+        if dst == mf.url:
+            raise Exception("20241113 should never happen")
+            return
+        src = settings.SITE.media_root / mf.url
+        dst = settings.SITE.media_root / dst
+
+        if needs_update(src, dst):
+            yield (True, format_lazy(_("Must build thumbnail for {}"), mf.url))
+            if fix:
+                if src.suffix.lower() == ".pdf":
+                    doc = pymupdf.open(src)
+                    page = doc.load_page(0)
+                    pixmap = page.get_pixmap(dpi=120)
+                    pixmap.save(dst)
+                    return
+                with Image.open(src) as im:
+                    im.thumbnail((self.max_width, self.max_width))
+                    dst.parent.mkdir(parents=True, exist_ok=True)
+                    im.save(dst)
+
+if with_thumbnails:
+    previewer = FilePreviewer("thumbs", 720)
+else:
+    previewer = Previewer()
+
+# full = Previewer()
+# if with_thumbnails:
+#     small = FilePreviewer("thumbs", 720)
+# else:
+#     small = full
+
+# Lino currently offers only two previewers, "full" and "small"

lino/modlib/users/models.py

@@ -99,7 +99,7 @@ class User(AbstractBaseUser, Contactable, CreatedModified, Publishable, DateRang
     user_type = UserTypes.field(blank=True)
     initials = models.CharField(_("Initials"), max_length=10, blank=True)
     if dd.plugins.users.with_nickname:
-        nickname = models.CharField(_("Nickname"), max_length=20, blank=True)
+        nickname = models.CharField(_("Nickname"), max_length=50, blank=True)
     else:
         nickname = dd.DummyField()
     first_name = models.CharField(_("First name"), max_length=30, blank=True)
@@ -144,7 +144,7 @@ class User(AbstractBaseUser, Contactable, CreatedModified, Publishable, DateRang
         my_settings = MySettings()
 
     def __str__(self):
-        return self.nickname if self.nickname else self.get_full_name()
+        return self.nickname or self.get_full_name()
 
     @property
     def is_active(self):

lino/modlib/weasyprint/__init__.py

@@ -29,6 +29,8 @@ class Plugin(ad.Plugin):
 
     verbose_name = _("WeasyPrint")
 
+    needs_plugins = ["lino.modlib.jinja"]
+
     header_height = 20
     """Height of header in mm. Set to `None` if you want no header."""
 

lino/utils/__init__.py

@@ -67,7 +67,7 @@ from urllib.parse import urlencode
 # import locale
 import dateparser
 from io import StringIO
-import contextlib
+from contextlib import redirect_stdout, contextmanager
 from pathlib import Path
 
 from etgen.utils import join_elems
@@ -77,13 +77,6 @@ from lino.utils.code import codefiles, codetime
 
 from rstgen.utils import confirm, i2d, i2t
 
-try:
-    import lino_book
-    DEMO_DATA = Path(lino_book.__file__).parent.parent.absolute() / 'demo_data'
-    """The root directory with demo data included in the Developer Guide."""
-except ImportError:
-    DEMO_DATA = None
-
 DATE_TO_DIR_TPL = "%Y/%m"
 
 def read_exception(excinfo):
@@ -105,6 +98,12 @@ def buildurl(root, *args, **kw):
     return url
 
 
+def needs_update(src, dest):
+    if dest.exists() and dest.stat().st_mtime >= src.stat().st_mtime:
+        return False
+    return True
+
+
 class AttrDict(dict):
     """
     Dictionary-like helper object.
@@ -366,6 +365,12 @@ curry = lambda func, *args, **kw: lambda *p, **n: func(
     *args + p, **dict(list(kw.items()) + list(n.items()))
 )
 
+def capture_output(func, *args, **kwargs):
+    s = StringIO()
+    with redirect_stdout(s):
+        func(*args, **kwargs)
+    return s.getvalue()
+
 
 class IncompleteDate(object):
     """Naive representation of a potentially incomplete gregorian date.
@@ -694,7 +699,7 @@ class MissingRow:
         return "MissingRow({!r})".format(self.message)
 
 
-@contextlib.contextmanager
+@contextmanager
 def logging_disabled(level):
     try:
         logging.disable(level)

lino/utils/djangotest.py

@@ -20,6 +20,7 @@ from django.db import connection, reset_queries, connections, DEFAULT_DB_ALIAS
 from django.utils import translation
 
 from lino.utils import AttrDict
+from lino.api import rt
 from lino.core.signals import testcase_setup  # , database_ready
 from lino.core.callbacks import applyCallbackChoice
 from .test import CommonTestCase
@@ -112,7 +113,7 @@ class DjangoManageTestCase(DjangoTestCase, CommonTestCase):
         the response's content (which is expected to contain a dict), convert
         this dict to an AttrDict before returning it.
         """
-        ar = settings.SITE.login(username)
+        ar = rt.login(username)
         self.client.force_login(ar.user)
         extra[settings.SITE.remote_user_header] = username
         # extra.update(REMOTE_USER=username)

lino/utils/html.py

@@ -11,9 +11,10 @@ from etgen.html import E, to_rst, fromstring, iselement, join_elems, forcetext,
 
 # from etgen.html import tostring as et_tostring
 from html2text import HTML2Text
-from django.utils.html import SafeString, mark_safe, escape
+from django.utils.html import SafeString, mark_safe, escape, format_html
 # from lino.utils import tostring
 
+SAFE_EMPTY = mark_safe("")
 
 def html2text(html, **kwargs):
     """
@@ -69,3 +70,33 @@ def assert_safe(s):
     if not isinstance(s, SafeString):
         raise Exception("%r is not a safe string" % s)
     # assert isinstance(s, SafeString)
+
+
+class Grouper:
+
+    def __init__(self, ar):
+        self.ar = ar
+        if ar.actor.group_by is None: return
+        self.last_values = [None for f in ar.actor.group_by]
+
+    def begin(self):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        return SAFE_EMPTY
+
+    def stop(self):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        return SAFE_EMPTY
+
+    def before_row(self, obj):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        self.current_values = [f(obj) for f in self.ar.actor.group_by]
+        if self.current_values == self.last_values:
+            return SAFE_EMPTY
+        return self.ar.actor.before_group_change(self, obj)
+
+    def after_row(self, obj):
+        if self.ar.actor.group_by is None: return SAFE_EMPTY
+        if self.current_values == self.last_values:
+            return SAFE_EMPTY
+        self.last_values = self.current_values
+        return self.ar.actor.after_group_change(self, obj)

lino/utils/media.py

@@ -55,6 +55,5 @@ class MediaFile(object):
 class TmpMediaFile(MediaFile):
     def __init__(self, ar, fmt):
         ip = ar.request.META.get("REMOTE_ADDR", "unknown_ip")
-        super(TmpMediaFile, self).__init__(
-            False, "cache", "appy" + fmt, ip, str(ar.actor) + "." + fmt
-        )
+        super().__init__(
+            False, "cache", "appy" + fmt, ip, str(ar.actor) + "." + fmt)

lino/utils/soup.py

@@ -0,0 +1,311 @@
+# -*- coding: UTF-8 -*-
+# Copyright 2016-2024 Rumma & Ko Ltd
+# License: GNU Affero General Public License v3 (see file COPYING for details)
+
+# See https://dev.lino-framework.org/dev/bleach.html
+
+import re
+from bs4 import BeautifulSoup, NavigableString, Comment, Doctype
+from bs4.element import Tag
+import logging; logger = logging.getLogger(__file__)
+from lino.api import dd
+
+
+PARAGRAPH_TAGS = {
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "h7",
+    "h8",
+    "h9",
+    "pre",
+    "li",
+    "div",
+}
+
+WHITESPACE_TAGS = PARAGRAPH_TAGS | {
+    "[document]",
+    "span",
+    "ul",
+    "html",
+    "head",
+    "body",
+    "base",
+}
+
+
+class Style:
+    # TODO: Extend rstgen.sphinxconf.sigal_image.Format to incoroporate this.
+    def __init__(self, s):
+        self._map = {}
+        if s:
+            for i in s.split(";"):
+                k, v = i.split(":", maxsplit=1)
+                self._map[k.strip()] = v.strip()
+        self.is_dirty = False
+
+    def __contains__(self, *args):
+        return self._map.__contains__(*args)
+
+    def __setitem__(self, k, v):
+        if k in self._map and self._map[k] == v:
+            return
+        self._map[k] = v
+        self.is_dirty = True
+
+    def __delitem__(self, k):
+        if k in self._map:
+            self.is_dirty = True
+        return self._map.__delitem__(k)
+
+    def adjust_size(self):
+        # if self['float'] == "none":
+        #     return
+        if "width" in self._map:
+            del self["width"]
+        self["height"] = dd.plugins.memo.short_preview_image_height
+
+    def as_string(self):
+        return ";".join(["{}:{}".format(*kv) for kv in self._map.items()])
+
+
+class TextCollector:
+    def __init__(self, max_length=None):
+        self.text = ""
+        self.sep = ""  # becomes "\n\n" after a PARAGRAPH_TAGS
+        self.remaining = max_length or settings.SITE.plugins.memo.short_preview_length
+        self.image = None
+
+    def add_chunk(self, ch):
+        # print("20230712 add_chunk", ch.name, ch)
+
+        if ch.name in WHITESPACE_TAGS:
+            for c in ch.children:
+                if not self.add_chunk(c):
+                    return False
+            if ch.name in PARAGRAPH_TAGS:
+                self.sep = "\n\n"
+            else:
+                self.sep = " "
+            return True
+
+        assert ch.name != "IMG"
+
+        if ch.name == "img":
+            if self.image is not None:
+                # Ignore all images except the first one.
+                self.text += self.sep
+                return True
+            style = Style(ch.get("style", None))
+            if not "float" in style:
+                style["float"] = "right"
+            style.adjust_size()
+            if style.is_dirty:
+                ch["style"] = style.as_string()
+            self.image = ch
+            # print("20231023 a", ch)
+
+        we_want_more = True
+        if ch.string is not None:
+            if len(ch.string) > self.remaining:
+                # print("20231023", len(ch.string), '>', self.remaining)
+                ch.string = ch.string[: self.remaining] + "..."
+                we_want_more = False
+                # print("20230927", ch.string, ch)
+                # self.text += str(ch.string) + "..."
+                # return False
+            self.remaining -= len(ch.string)
+
+        if isinstance(ch, NavigableString):
+            self.text += self.sep + ch.string
+        else:
+            self.text += self.sep + str(ch)
+
+        self.remaining -= len(self.sep)
+        self.sep = ""
+        return we_want_more
+
+
+def truncate_comment(html_str, max_length=300):
+    # Returns a single paragraph with a maximum number of visible chars.
+    # new implementation since 20230713
+    html_str = html_str.strip()  # remove leading or trailing newlines
+
+    if not html_str.startswith("<"):
+        # print("20231023 c", html_str)
+        if len(html_str) > max_length:
+            return html_str[:max_length] + "..."
+        return html_str
+
+    # if "choose one or the other" in html_str:
+    #     print(html_str)
+    #     raise Exception("20230928 {} {}".format(len(html_str), max_length))
+
+    soup = BeautifulSoup(html_str, features="html.parser")
+    tc = TextCollector(max_length)
+    tc.add_chunk(soup)
+    return tc.text
+
+
+
+def old_truncate_comment(html_str, max_p_len=None):
+    # returns a single paragraph with a maximum number of visible chars.
+    # No longer used. Replaced by new truncate_comment() below
+    if max_p_len is None:
+        max_p_len = settings.SITE.plugins.memo.short_preview_length
+    html_str = html_str.strip()  # remove leading or trailing newlines
+
+    if not html_str.startswith("<"):
+        if len(html_str) > max_p_len:
+            txt = html_str[:max_p_len] + "..."
+        else:
+            txt = html_str
+        return txt
+    soup = BeautifulSoup(html_str, "html.parser")
+    ps = soup.find_all(
+        ["p", "h1", "h2", "h3", "h4", "h5", "h6", "h7", "h8", "h9", "pre"]
+    )
+    if len(ps) > 0:
+        anchor_end = "</a>"
+        txt = ""
+        for p in ps:
+            text = ""
+            for c in p.contents:
+                if isinstance(c, Tag):
+                    if c.name == "a":
+                        text += str(c)
+                        max_p_len = max_p_len + len(text) - len(c.text)
+                    else:
+                        # text += str(c)
+                        text += c.text
+                else:
+                    text += str(c)
+
+            if len(txt) + len(text) > max_p_len:
+                txt += text
+                if anchor_end in txt:
+                    ae_index = txt.index(anchor_end) + len(anchor_end)
+                    if ae_index >= max_p_len:
+                        txt = txt[:ae_index]
+                        txt += "..."
+                        break
+                txt = txt[:max_p_len]
+                txt += "..."
+                break
+            else:
+                txt += text + "\n\n"
+        return txt
+    return html_str
+
+# remove these tags including their content.
+blacklist = frozenset(["script", "style", "head"])
+
+# unwrap these tags (remove the wrapper and leave the content)
+unwrap = frozenset(["html", "body"])
+
+useless_main_tags = frozenset(["p", "div", "span"])
+
+ALLOWED_TAGS = frozenset([
+    "a",
+    "b",
+    "i",
+    "em",
+    "ul",
+    "ol",
+    "li",
+    "strong",
+    "p",
+    "br",
+    "span",
+    "pre",
+    "def",
+    "div",
+    "img",
+    "table",
+    "th",
+    "tr",
+    "td",
+    "thead",
+    "tfoot",
+    "tbody",
+])
+
+
+# Map of allowed attributes by tag. Copied from bleach.sanitizer:
+ALLOWED_ATTRIBUTES = {
+    "a": {"href", "title"},
+    "abbr": {"title"},
+    "acronym": {"title"},
+}
+
+ALLOWED_ATTRIBUTES["span"] = {
+    "class",
+    "data-index",
+    "data-denotation-char",
+    "data-link",
+    "data-title",
+    "data-value",
+    "contenteditable",
+}
+ALLOWED_ATTRIBUTES["p"] = {"align"}
+
+def safe_css(attr, css):
+    if attr == "style":
+        return re.sub("(width|height):[^;]+;", "", css)
+    return css
+
+def sanitize(old):
+
+    # Inspired by https://chase-seibert.github.io/blog/2011/01/28/sanitize-html-with-beautiful-soup.html
+
+    old = old.strip()
+    if not old:
+        return old
+
+    try:
+        soup = BeautifulSoup(old, features="lxml")
+    except HTMLParseError as e:
+        logger.info("Could not sanitize %r : %s", old, e)
+        return f"Could not sanitize content ({e})"
+
+    for tag in soup.findAll():
+        # print(tag)
+        tag_name = tag.name.lower()
+        if tag_name in blacklist:
+            # blacklisted tags are removed in their entirety
+            tag.extract()
+        elif tag_name in unwrap:
+            tag.unwrap()
+        elif tag_name in ALLOWED_TAGS:
+            # tag is allowed. Make sure all the attributes are allowed.
+            allowed = ALLOWED_ATTRIBUTES.get(tag_name, None)
+            if allowed is None:
+                tag.attrs = dict()
+            else:
+                tag.attrs = {k: v for k, v in tag.attrs.items() if k in allowed}
+        else:
+            # print(tag.name)
+            # tag.decompose()
+            # tag.extract()
+            # not a whitelisted tag. I'd like to remove it from the tree
+            # and replace it with its children. But that's hard. It's much
+            # easier to just replace it with an empty span tag.
+            tag.name = "span"
+            tag.attrs = dict()
+
+    # remove all comments because they might contain scripts
+    comments = soup.findAll(text=lambda text:isinstance(text, (Comment, Doctype)))
+    for comment in comments:
+        comment.extract()
+
+    # remove the wrapper tag if it is useless
+    if len(soup.contents) == 1:
+        main_tag = soup.contents[0]
+        if main_tag.name in useless_main_tags and not main_tag.attrs:
+            main_tag.unwrap()
+
+    return str(soup).strip()

{lino-24.10.3.dist-info → lino-24.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lino
-Version: 24.10.3
+Version: 24.11.1
 Summary: A framework for writing desktop-like web applications using Django and ExtJS or React
 Project-URL: Homepage, https://www.lino-framework.org
 Project-URL: Repository, https://gitlab.com/lino-framework/lino
@@ -666,8 +666,6 @@ License:                     GNU AFFERO GENERAL PUBLIC LICENSE
         if any, to sign a "copyright disclaimer" for the program, if necessary.
         For more information on this, and how to apply and follow the GNU AGPL, see
         <https://www.gnu.org/licenses/>.
-License-File: AUTHORS.rst
-License-File: COPYING
 Keywords: Django,React,customized,framework
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment