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

lino/modlib/uploads/models.py

@@ -11,9 +11,13 @@ from django.db import models
 from django.conf import settings
 from django.core.exceptions import ValidationError
 from django.utils.text import format_lazy
-from django.utils.html import format_html
+from django.utils.html import format_html, mark_safe
 from django.utils.translation import pgettext_lazy as pgettext
 
+from rstgen.sphinxconf.sigal_image import parse_image_spec
+# from rstgen.sphinxconf.sigal_image import Standard, Thumb, Tiny, Wide, Solo, Duo, Trio
+# SMALL_FORMATS = (Thumb, Tiny, Duo, Trio)
+
 from lino.utils.html import E, join_elems
 from lino.api import dd, rt, _
 from lino.modlib.gfks.mixins import Controllable
@@ -29,6 +33,7 @@ from lino.modlib.publisher.mixins import Publishable
 from .actions import CameraStream
 from .choicelists import Shortcuts, UploadAreas
 from .mixins import UploadBase
+from .utils import previewer, UploadMediaFile
 
 from . import VOLUMES_ROOT
 
@@ -36,6 +41,7 @@ from . import VOLUMES_ROOT
 class Volume(Referrable):
 
     class Meta:
+        abstract = dd.is_abstract_model(__name__, "Volume")
         app_label = "uploads"
         verbose_name = _("Library volume")
         verbose_name_plural = _("Library volumes")
@@ -50,10 +56,8 @@ class Volume(Referrable):
         return self.ref or self.root_dir
 
     def full_clean(self, *args, **kw):
-        # if self.ref == "uploads":
-        #     raise ValidationError("Invalid reference for a volume.")
         super().full_clean(*args, **kw)
-        pth = Path(dd.plugins.uploads.get_volumes_root(), self.ref)
+        pth = dd.plugins.uploads.get_volumes_root() / self.ref
         if pth.exists():
             if pth.resolve().absolute() != Path(self.root_dir).resolve().absolute():
                 raise ValidationError(
@@ -74,8 +78,9 @@ class Volume(Referrable):
 
 
 class UploadType(BabelNamed):
-    class Meta(object):
+    class Meta:
         abstract = dd.is_abstract_model(__name__, "UploadType")
+        app_label = "uploads"
         verbose_name = _("Upload type")
         verbose_name_plural = _("Upload types")
 
@@ -105,7 +110,8 @@ class UploadType(BabelNamed):
 
 class Upload(UploadBase, UserAuthored, Controllable, Publishable):
 
-    class Meta(object):
+    class Meta:
+        app_label = "uploads"
         abstract = dd.is_abstract_model(__name__, "Upload")
         verbose_name = _("Upload file")
         verbose_name_plural = _("Upload files")
@@ -127,41 +133,52 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
         elif self.file:
             s = filename_leaf(self.file.name)
         elif self.library_file:
-            s = "{}:{}".format(self.volume.ref, self.library_file)
+            s = filename_leaf(self.library_file)
+            # s = "{}:{}".format(self.volume.ref, self.library_file)
         else:
             s = str(self.id)
         if self.type:
             s = str(self.type) + " " + s
         return s
 
-    def get_memo_command(self, ar=None):
-        if dd.is_installed("memo"):
-            cmd = f"[upload {self.pk}"
-            if self.description:
-                cmd += " " + self.description + "]"
-            else:
-                cmd += "]"
-            return cmd
+    def get_file_path(self):
+        if self.file and self.file.name:
+            return self.file.name
+        elif self.library_file and self.volume_id and self.volume.ref:
+            return VOLUMES_ROOT + "/" + self.volume.ref + "/" + self.library_file
         return None
 
-    def get_file_url(self):
-        if self.file.name:
-            return settings.SITE.build_media_url(self.file.name)
-        if self.library_file and self.volume_id and self.volume.ref:
-            return settings.SITE.build_media_url(
-                VOLUMES_ROOT, self.volume.ref, self.library_file)
-            # return self.volume.base_url + self.library_file
+    def get_media_file(self):
+        url = self.get_file_path()
+        if url is not None:
+            return UploadMediaFile(url)
+
+    def get_create_comment_text(self, ar):
+        mf = self.get_media_file()
+        if mf is None:
+            return super().get_create_comment_text(ar)
+        return _("Uploaded an {obj}.").format(obj=mf.get_mimetype_description())
+        # or mf.get_image_url() is None:
+        # return _("Uploaded {obj}. [{obj.memo_command} {obj.id}].").format(obj=self)
+
+    def get_memo_command(self, ar=None):
+        if dd.is_installed("memo"):
+            return f"[{self.memo_command} {self.pk} {self}]"
+            # cmd = f"[{self.memo_command} {self.pk}"
+            # if self.description:
+            #     cmd += " " + self.description + "]"
+            # else:
+            #     cmd += "]"
+            # return cmd
         return None
 
     def get_real_file_size(self):
         if self.file:
             return self.file.size
         if self.volume_id and self.library_file:
-            pth = os.path.join(
-                dd.plugins.uploads.get_volumes_root(),
-                self.volume.ref, self.library_file)
-            # pth = os.path.join(settings.MEDIA_ROOT, self.volume.ref, self.library_file)
-            return os.path.getsize(pth)
+            pth = dd.plugins.uploads.get_volumes_root() / self.volume.ref / self.library_file
+            return pth.stat().st_size
+            # return os.path.getsize(pth)
 
     def disabled_fields(self, ar):
         df = super().disabled_fields(ar)
@@ -184,16 +201,22 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
 
     @dd.chooser()
     def type_choices(self, upload_area):
-        M = dd.resolve_model("uploads.UploadType")
-        # logger.info("20140430 type_choices %s", upload_area)
+        UploadType = rt.models.uploads.UploadType
         if upload_area is None:
-            return M.objects.all()
-        return M.objects.filter(upload_area=upload_area)
+            return UploadType.objects.all()
+        return UploadType.objects.filter(upload_area=upload_area)
 
     def full_clean(self, *args, **kw):
         super().full_clean(*args, **kw)
         if self.type is not None:
             self.upload_area = self.type.upload_area
+        for i in self.check_previews(True):
+            pass
+
+    def check_previews(self, fix):
+        p = rt.models.uploads.previewer
+        for i in p.check_preview(self, fix):
+            yield i
 
     def get_gallery_item(self, ar):
         d = super().get_gallery_item(ar)
@@ -205,40 +228,45 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
 
     @dd.htmlbox()
     def preview(self, ar):
-        url = self.get_file_url()
-        if url is None or url.endswith(".pdf"):
+        mf = self.get_media_file()
+        if mf is None:
             txt = _("No preview available")
             return '<p style="text-align: center;padding: 2em;">({})</p>'.format(txt)
-        return '<img src="{}" style="max-width: 100%; max-height: 20em">'.format(url)
+        return '<img src="{}" style="max-width: 100%; max-height: 20em">'.format(mf.get_image_url())
 
     @dd.htmlbox(_("Thumbnail"))
     def thumbnail(self, ar):
         # url = settings.SITE.build_media_url(self.file.name)
-        url = self.get_file_url()
-        return '<img src="{}" style="height: 15ch; max-width: 22.5ch">'.format(url)
-
-    @dd.htmlbox(_("Thumbnail Medium"))
-    def thumbnail_medium(self, ar):
-        # url = settings.SITE.build_media_url(self.file.name)
-        url = self.get_file_url()
-        return '<img src="{}" style="width: 30ch;">'.format(url)
-
-    @dd.htmlbox(_("Thumbnail Large"))
-    def thumbnail_large(self, ar):
-        # url = settings.SITE.build_media_url(self.file.name)
-        url = self.get_file_url()
-        return '<img src="{}" style="width: 70ch;">'.format(url)
+        mf = self.get_media_file()
+        if mf is None:
+            return ""
+        return '<img src="{}" style="height: 15ch; max-width: 22.5ch">'.format(mf.get_image_url())
 
     def as_page(self, ar, **kwargs):
         yield format_html("<h1>{}</h1>", self)
-        url = self.get_file_url()
-        yield format_html('<img src="{}" style="width: 100%;">', url)
+        mf = self.get_media_file()
+        if mf is not None:
+            yield format_html('<img src="{}" style="width: 100%;">', mf.get_image_url())
         if self.description:
             yield escape(self.description)
         if self.source:
             yield _("Source") + ": "
             yield ar.obj2htmls(self.source)
 
+    def as_paragraph(self, ar, **kwargs):
+        rv = self.memo2html(ar, "")
+        # rv = ar.obj2htmls(self)
+        # mf = self.get_media_file()
+        # if mf is not None:
+        #     src = mf.get_image_url()
+        #     if src is not None:
+        #         url = mf.get_download_url()
+        #         rv += f'<a href="{url}"><img src="{src}" style="width: 30%;"></a>'
+        if self.source:
+            rv += format_html(
+                " ({}: {})", _("Source"), ar.obj2htmls(self.source))
+        return mark_safe(rv)
+
     # def get_choices_text(self, ar, actor, field):
     #     if self.file:
     #         return str(obj) + "&nbsp;<span style=\"float: right;\">" + obj.thumbnail + "</span>"
@@ -246,11 +274,12 @@ class Upload(UploadBase, UserAuthored, Controllable, Publishable):
 
 
 dd.update_field(Upload, "user", verbose_name=_("Uploaded by"))
+dd.update_field(Upload, "owner", verbose_name=_("Attached to"))
 
 
 class UploadChecker(Checker):
     verbose_name = _("Check metadata of upload files")
-    model = Upload
+    model = "uploads.Upload"
 
     def get_checkdata_problems(self, obj, fix=False):
         if obj.file:
@@ -267,6 +296,8 @@ class UploadChecker(Checker):
             tpl = "Stored file size {} differs from real file size {}"
             yield (False, format_lazy(tpl, obj.file_size, file_size))
 
+        for i in obj.check_previews(fix):
+            yield i
 
 UploadChecker.activate()
 
@@ -304,7 +335,6 @@ class UploadsFolderChecker(Checker):
 UploadsFolderChecker.activate()
 
 
-
 @dd.receiver(dd.pre_analyze)
 def before_analyze(sender, **kwargs):
     # This is the successor for `quick_upload_buttons`.
@@ -313,6 +343,8 @@ def before_analyze(sender, **kwargs):
     UploadType = sender.models.uploads.UploadType
     Shortcuts = sender.models.uploads.Shortcuts
 
+    # raise Exception(f"20241112 {UploadType}")
+
     for i in Shortcuts.items():
 
         def f(obj, ar):
@@ -341,16 +373,17 @@ def before_analyze(sender, **kwargs):
             elif n == 1:
                 after_show = ar.get_status()
                 obj = sar.data_iterator[0]
-                items.append(
-                    sar.renderer.href_button(
-                        obj.get_file_url(),
-                        _("show"),
-                        target="_blank",
-                        icon_name="page_go",
-                        style="vertical-align:-30%;",
-                        title=_("Open the uploaded file in a new browser window"),
+                if (mf := obj.get_media_file()) is not None:
+                    items.append(
+                        sar.renderer.href_button(
+                            mf.get_download_url(),
+                            _("show"),
+                            target="_blank",
+                            icon_name="page_go",
+                            style="vertical-align:-30%;",
+                            title=_("Open the uploaded file in a new browser window"),
+                        )
                     )
-                )
                 after_show.update(record_id=obj.pk)
                 items.append(
                     sar.window_action_button(
@@ -381,4 +414,54 @@ def before_analyze(sender, **kwargs):
         # logger.info("Installed upload shortcut field %s.%s",
         #             i.model_spec, i.name)
 
+
 from .ui import *
+
+# raise Exception("20241112")
+
+
+@dd.receiver(dd.post_startup)
+def setup_memo_commands(sender=None, **kwargs):
+    # Adds another memo command for Upload
+    # See :doc:`/specs/memo`
+
+    if not sender.is_installed('memo'):
+        return
+
+    def file2html(self, ar, text, **ctx):
+        """
+        Insert an image tag of the specified upload file.
+        """
+        mf = self.get_media_file()
+        if mf is None:
+            return format_html("<em>{}</em>", text or str(self))
+        ctx.update(src=mf.get_download_url())
+        ctx.update(href=ar.renderer.obj2url(ar, self))
+        if not mf.is_image():
+            if not text:
+                text = str(self)
+            ctx.update(text=text)
+            tpl = '(<a href="{src}" target="_blank">{text}</a>'
+            tpl += '| <a href="{href}">Detail</a>)'
+            return format_html(tpl, **ctx)
+
+        fmt = parse_image_spec(text, **ctx)
+        # TODO: When an image is inserted with format "wide", we should not use
+        # the thumbnail but the original file. But for a PDF file we must always
+        # use the img_src because the download_url is not an image.
+        fmt.context.update(src=mf.get_image_url())
+        # if isinstance(fmt, SMALL_FORMATS):
+        #     fmt.context.update(src=img_src)
+        # else:
+        #     print(f"20241116 {fmt} {fmt.context}")
+
+        if not fmt.context["caption"]:
+            fmt.context["caption"] = self.description or str(self)
+
+        rv = format_html(
+            '<a href="{href}" target="_blank"><img src="{src}"'
+            + ' style="{style}" title="{caption}"/></a>', **fmt.context)
+        return rv
+
+    mp = sender.plugins.memo.parser
+    mp.register_django_model('file', rt.models.uploads.Upload, rnd=file2html)

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,113 @@
+# -*- 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 is_image(self):
+        # whether this can be rendered in an <img> tag
+        if self.get_image_name() is None:
+            return False
+        return self.suffix in previewer.PREVIEW_SUFFIXES
+
+    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/mixins.py

@@ -159,13 +159,16 @@ class My(dbtables.Table):
 
     @classmethod
     def get_actor_label(self):
+        if self._label is not None:
+            return self._label
         if self.model is None:
-            return self._label or self.__name__
-        # return self._label or \
-        #     _("My %s") % self.model._meta.verbose_name_plural
-        return self._label or format_lazy(
-            _("My {}"), self.model._meta.verbose_name_plural
-        )
+            return self.__name__
+        return format_lazy(_("My {}"), self.model._meta.verbose_name_plural)
+
+    @classmethod
+    def setup_request(cls, ar):
+        super().setup_request(ar)
+        ar.obvious_fields.add("user")
 
     @classmethod
     def param_defaults(self, ar, **kw):

lino/modlib/weasyprint/choicelists.py

@@ -1,8 +1,9 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2016-2020 Rumma & Ko Ltd
+# Copyright 2016-2024 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 import os
+from pathlib import Path
 from copy import copy
 
 try:
@@ -10,11 +11,20 @@ try:
 except ImportError:
     HTML = None
 
+try:
+    import bulma
+    from weasyprint import CSS
+    BULMA_CSS = Path(bulma.__file__).parent / "static/bulma/css/style.min.css"
+    assert BULMA_CSS.exists()
+except ImportError:
+    BULMA_CSS = None
+
+
+
 from django.conf import settings
 from django.utils import translation
 
 from lino.api import dd
-
 from lino.modlib.jinja.choicelists import JinjaBuildMethod
 from lino.modlib.printing.choicelists import BuildMethods
 
@@ -29,17 +39,17 @@ class WeasyHtmlBuildMethod(WeasyBuildMethod):
     target_ext = ".html"
     name = "weasy2html"
 
-    def html2file(self, html, filename):
-        open(filename, "w").write(html)
-
 
 class WeasyPdfBuildMethod(WeasyBuildMethod):
     target_ext = ".pdf"
     name = "weasy2pdf"
 
-    def html2file(self, html, filename):
+    def html2file(self, html, filename, context):
         pdf = HTML(string=html)
-        pdf.write_pdf(filename)
+        if BULMA_CSS and context.get('use_bulma_css', False):
+            pdf.write_pdf(filename, stylesheets=[CSS(filename=BULMA_CSS)])
+        else:
+            pdf.write_pdf(filename)
 
 
 add = BuildMethods.add_item_instance

lino/utils/__init__.py

@@ -98,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.

lino/utils/choosers.py

@@ -108,6 +108,7 @@ class ChoiceConverter(Converter):
 
     def convert(self, **kw):
         value = kw.get(self.field.name)
+        # print(f"20241203 convert {self.field.name}")
 
         if value is not None:
             if not isinstance(value, self.field.choicelist.item_class):
@@ -190,7 +191,16 @@ class ManyToManyConverter(LookupConverter):
 
 def make_converter(f, lookup_fields={}):
     from lino.core.gfks import GenericForeignKey
+    from lino.core.fields import VirtualField
 
+    # if f.name == 'rating_type':
+    #     print(f"20241203 {f.__class__}")
+
+    # selector = f
+
+    if isinstance(f, VirtualField):
+        # print(f"20241203 {f.name} {f.return_type.name}")
+        f = f.return_type
     if isinstance(f, models.ForeignKey):
         return ForeignKeyConverter(f, lookup_fields.get(f.name, "pk"))
     if isinstance(f, GenericForeignKey):
@@ -206,8 +216,7 @@ def make_converter(f, lookup_fields={}):
     from lino.core import choicelists
 
     if isinstance(f, choicelists.ChoiceListField):
-        # if f.name == 'p_book':
-        # print "20131012 b", f
+        # print(f"20241203c {f.__class__}")
         return ChoiceConverter(f)
 
 
@@ -244,18 +253,22 @@ class Chooser(FieldChooser):
         from lino.core.gfks import is_foreignkey
         from lino.core.choicelists import ChoiceListField
 
-        if isinstance(field, ChoiceListField):
+        selector = field
+        if isinstance(field, fields.VirtualField):
+            selector = field.return_type
+
+        if isinstance(selector, ChoiceListField):
             self.simple_values = getattr(meth, "simple_values", False)
             self.instance_values = getattr(meth, "instance_values", True)
             self.force_selection = getattr(
                 meth, "force_selection", self.force_selection
             )
-        elif is_foreignkey(field):
-            pass
-        elif isinstance(field, fields.VirtualField) and isinstance(
-            field.return_type, models.ForeignKey
-        ):
+        elif is_foreignkey(selector):
             pass
+        # elif isinstance(field, fields.VirtualField) and isinstance(
+        #     field.return_type, models.ForeignKey
+        # ):
+        #     pass
         else:
             self.simple_values = getattr(meth, "simple_values", False)
             self.instance_values = getattr(meth, "instance_values", False)

lino/utils/html.py

@@ -11,7 +11,7 @@ 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("")

lino/utils/instantiator.py

@@ -210,6 +210,15 @@ def create_and_get(model, **kw):
     o = create(model, **kw)
     return model.objects.get(pk=o.pk)
 
+def make_if_needed(model, **values):
+    qs = model.objects.filter(**values)
+    if qs.count() == 1:
+        pass # ok, nothing to do
+    elif qs.count() == 0:
+        return model(**values)
+    else:
+        raise Exception(f"Multiple {model._meta.verbose_name_plural} for {values}")
+
 
 def _test():
     import doctest