lino 25.2.3__py3-none-any.whl → 25.3.1__py3-none-any.whl

lino/modlib/linod/__init__.py

@@ -20,6 +20,7 @@ class Plugin(ad.Plugin):
     verbose_name = _("Lino daemon")
     use_channels = False
     background_sleep_time = 5  # in seconds
+    daemon_user = "robin"  # TODO: find a better solution
 
     def on_plugins_loaded(self, site):
         assert self.site is site

lino/modlib/linod/choicelists.py

@@ -80,3 +80,24 @@ add("INFO")
 add("WARNING")
 add("ERROR")
 add("CRITICAL")
+
+
+def background_task(**kwargs):
+    if "class_name" not in kwargs:
+        kwargs["class_name"] = "linod.SystemTask"
+
+    def decorator(func):
+        Procedures.add_item(func, **kwargs)
+        return func
+
+    return decorator
+
+
+def schedule_often(every=10, **kwargs):
+    kwargs.update(every_unit="secondly", every=every)
+    return background_task(**kwargs)
+
+
+def schedule_daily(**kwargs):
+    kwargs.update(every_unit="daily", every=1)
+    return background_task(**kwargs)

lino/modlib/linod/consumers.py

@@ -36,7 +36,10 @@ from .utils import BROADCAST_CHANNEL
 #     logger.addHandler(logging.StreamHandler())
 #     logger.setLevel(logging.INFO)
 
-is_slave = lambda actor: actor.master is not None
+
+def is_slave(actor): return actor.master is not None
+
+
 match_master = (
     lambda ContentType, MasterModel, Master: Master == MasterModel
     or ContentType == Master
@@ -57,8 +60,12 @@ class LinodConsumer(AsyncConsumer):
     async def run_background_tasks(self, event: dict):
         # 'run.background.tasks' in `pm linod`
         from lino.modlib.linod.mixins import start_task_runner
+        # from lino.core.utils import login
+        # ar = login(settings.SITE.plugins.linod.daemon_user)
         from lino.core.requests import BaseRequest
-        ar = BaseRequest()
+        u = await settings.SITE.user_model.objects.aget(
+            username=settings.SITE.plugins.linod.daemon_user)
+        ar = BaseRequest(user=u)
         asyncio.ensure_future(start_task_runner(ar))
 
     async def send_push(self, event):
@@ -82,7 +89,8 @@ class LinodConsumer(AsyncConsumer):
         if user is None:
             subs = settings.SITE.models.notify.Subscription.objects.all()
         else:
-            subs = settings.SITE.models.notify.Subscription.objects.filter(user=user)
+            subs = settings.SITE.models.notify.Subscription.objects.filter(
+                user=user)
         async for sub in subs.aiterator():
             sub_info = {
                 "endpoint": sub.endpoint,
@@ -122,7 +130,8 @@ class LinodConsumer(AsyncConsumer):
             data.update(
                 **dict(
                     [
-                        (a.actor_id, {"mk": msg["mk"], "mt": mt, "pk": msg["pk"]})
+                        (a.actor_id, {"mk": msg["mk"],
+                         "mt": mt, "pk": msg["pk"]})
                         for a in ups
                         if is_slave(a)
                         and match_master(ContentType, MasterModel, a.master)

lino/modlib/linod/management/commands/linod.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2022-2024 Rumma & Ko Ltd
+# Copyright 2022-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 # import time
@@ -10,6 +10,7 @@ from django.conf import settings
 from django.core.management import BaseCommand, call_command
 from lino.api import dd, rt
 from lino.modlib.linod.mixins import start_log_server, start_task_runner
+from lino.core.requests import BaseRequest
 
 if dd.plugins.linod.use_channels:
     import threading
@@ -50,7 +51,10 @@ class Command(BaseCommand):
             # print("20240424 Run Lino daemon without channels")
 
             async def main():
-                ar = rt.login()
+                u = await settings.SITE.user_model.objects.aget(
+                    username=settings.SITE.plugins.linod.daemon_user)
+                ar = BaseRequest(user=u)
+                # ar = rt.login(dd.plugins.linod.daemon_user)
                 await asyncio.gather(start_log_server(), start_task_runner(ar))
                 # t1 = asyncio.create_task(settings.SITE.start_log_server())
                 # t2 = asyncio.create_task(start_task_runner(ar))

lino/modlib/linod/mixins.py

@@ -4,20 +4,18 @@
 # See https://dev.lino-framework.org/plugins/linod.html
 
 import logging
-import sys
 import traceback
 import asyncio
 import pickle
 from datetime import timedelta
-from io import StringIO
 from django.conf import settings
 from django.db import models
 from django.utils import timezone
-from django.core.exceptions import ValidationError
+# from django.core.exceptions import ValidationError
 from asgiref.sync import sync_to_async, async_to_sync
 
 from lino import logger
-from lino.api import dd, rt, _
+from lino.api import dd, _
 from lino.mixins import Sequenced
 from lino.modlib.system.mixins import RecurrenceSet
 from lino.modlib.system.choicelists import Recurrences
@@ -34,8 +32,9 @@ def astr(self):
 
 class RunNow(dd.Action):
     label = _("Run now")
+    help_text = _("Mark the task as to be executed asap by linod.")
     select_rows = True
-
+    button_text = "▶"
     # icon_name = 'bell'
     # icon_name = 'lightning'
 
@@ -44,7 +43,6 @@ class RunNow(dd.Action):
         for obj in ar.selected_rows:
             assert issubclass(obj.__class__, Runnable)
             if True:  # dd.plugins.linod.use_channels:
-                # Mark the task as to be executed asap by linod.
                 obj.last_start_time = None
                 obj.last_end_time = None
                 obj.message = "{} requested to run this task at {}.".format(
@@ -65,9 +63,11 @@ class Runnable(Sequenced, RecurrenceSet):
 
     log_level = LogLevels.field(default="INFO")
     disabled = dd.BooleanField(_("Disabled"), default=False)
-    last_start_time = dd.DateTimeField(_("Started at"), null=True, editable=False)
+    last_start_time = dd.DateTimeField(
+        _("Started at"), null=True, editable=False)
     last_end_time = dd.DateTimeField(_("Ended at"), null=True, editable=False)
-    message = dd.RichTextField(_("Logged messages"), format="plain", editable=False)
+    message = dd.RichTextField(
+        _("Logged messages"), format="plain", editable=False)
 
     # procedure = Procedures.field(strict=False, unique=True, editable=False)
     procedure = Procedures.field(strict=False)
@@ -76,7 +76,8 @@ class Runnable(Sequenced, RecurrenceSet):
     run_now = RunNow()
 
     def __str__(self):
-        r = "{} #{} ({})".format(self._meta.verbose_name, self.seqno, self.name)
+        r = "{} #{} ({})".format(
+            self._meta.verbose_name, self.seqno, self.name)
         return r
 
     def full_clean(self, *args, **kwargs):
@@ -131,6 +132,9 @@ class Runnable(Sequenced, RecurrenceSet):
                 await ar.adebug("Successfully terminated %s", self)
                 # ar.info("Successfully terminated %s", astr(self))
                 self.message = out.getvalue()
+            except Warning as e:
+                await ar.adebug("Terminated %s with warning %s", self, str(e))
+                self.message = out.getvalue()
             except Exception as e:
                 self.message = out.getvalue()
                 self.message += "\n" + "".join(traceback.format_exception(e))
@@ -159,7 +163,7 @@ class Runnable(Sequenced, RecurrenceSet):
         return _("Scheduled to run at {}").format(dd.ftl(next_time))
 
 
-async def start_task_runner(ar, max_count=None):
+async def start_task_runner(ar=None, max_count=None):
     # called from consumers.LinoConsumer.run_background_tasks()
     await ar.ainfo("Start task runner using %s...", ar.logger)
     # ar.info("Start task runner using %s...", ar.logger)
@@ -170,7 +174,8 @@ async def start_task_runner(ar, max_count=None):
         await ar.adebug("Start next task runner loop.")
 
         now = timezone.now()
-        next_time = now + timedelta(seconds=dd.plugins.linod.background_sleep_time)
+        next_time = now + \
+            timedelta(seconds=dd.plugins.linod.background_sleep_time)
 
         for cls in Procedures.task_classes():
             # asyncio.ensure_future(m.start_task_runner(ar.spawn_request()))

lino/modlib/linod/models.py

@@ -30,11 +30,12 @@ class SystemTask(Runnable):
 class SystemTasks(dd.Table):
     # label = _("System tasks")
     model = "linod.SystemTask"
+    order_by = ['seqno']
     required_roles = dd.login_required(SiteStaff)
     column_names = "seqno name log_level disabled status procedure *"
     detail_layout = """
     seqno procedure
-    name 
+    name
     every every_unit
     log_level disabled status
     last_start_time last_end_time
@@ -58,7 +59,8 @@ class SystemTaskChecker(Checker):
         for proc in Procedures.get_list_items():
             if proc.class_name == "linod.SystemTask":
                 if SystemTask.objects.filter(procedure=proc).count() == 0:
-                    msg = _("No {} for {}").format(SystemTask._meta.verbose_name, proc)
+                    msg = _("No {} for {}").format(
+                        SystemTask._meta.verbose_name, proc)
                     yield (True, msg)
                     if fix:
                         logger.debug("Create background task for %r", proc)

lino/modlib/notify/models.py

@@ -22,6 +22,7 @@ from lino.utils.format_date import fds
 from lino.mixins import Created, ObservedDateRange
 from lino.modlib.gfks.mixins import Controllable
 from lino.modlib.users.mixins import UserAuthored, My
+from lino.modlib.linod.choicelists import schedule_daily, schedule_often
 from lino.modlib.office.roles import OfficeUser
 
 from .choicelists import MessageTypes, MailModes
@@ -29,7 +30,9 @@ from .api import send_notification, NOTIFICATION, send_panel_update
 
 html_parser = etree.HTMLParser()
 
-subaddress_separator = dd.get_plugin_setting('inbox', 'subaddress_separator', None)
+subaddress_separator = dd.get_plugin_setting(
+    'inbox', 'subaddress_separator', None)
+
 
 def groupname(s):
     # Remove any invalid characters from the given string so that it can
@@ -126,7 +129,8 @@ class Message(UserAuthored, Controllable, Created):
     message_type = MessageTypes.field(default="change")
     seen = models.DateTimeField(_("seen"), null=True, editable=False)
     sent = models.DateTimeField(_("sent"), null=True, editable=False)
-    body = dd.RichTextField(_("Body"), editable=False, format="html", default="")
+    body = dd.RichTextField(_("Body"), editable=False,
+                            format="html", default="")
     mail_mode = MailModes.field(default="often")
     subject = models.CharField(_("Subject"), max_length=250, editable=False)
     reply_to = dd.ForeignKey(
@@ -171,7 +175,8 @@ class Message(UserAuthored, Controllable, Created):
                 ba = owner.get_detail_action(ar)
                 if ba is not None:
                     push_options.update(
-                        action_url=ar.renderer.get_detail_url(ar, ba.actor, owner.pk)
+                        action_url=ar.renderer.get_detail_url(
+                            ar, ba.actor, owner.pk)
                     )
                 # push_options.update(action_url=ar.renderer.obj2url(ar, owner))
             me = ar.get_user()
@@ -267,7 +272,8 @@ class Message(UserAuthored, Controllable, Created):
                     collect(u, obj)
             else:
                 collect(obj.user, obj)
-        ar.logger.debug("Send out '%s' summaries for %d users.", mm, len(users))
+        ar.logger.debug(
+            "Send out '%s' summaries for %d users.", mm, len(users))
         for user, messages in users.items():
             with translation.override(user.language):
                 sender = sender_parts[0]
@@ -276,9 +282,11 @@ class Message(UserAuthored, Controllable, Created):
                     subject = msg.subject
                     if subaddress_separator is not None:
                         if msg.reply_to_id:
-                            sender += subaddress_separator + str(msg.reply_to_id)
+                            sender += subaddress_separator + \
+                                str(msg.reply_to_id)
                         elif msg.owner_id:
-                            sender += subaddress_separator + str(msg.owner_type)
+                            sender += subaddress_separator + \
+                                str(msg.owner_type)
                             sender += subaddress_separator + str(msg.owner_id)
                 else:
                     subject = _("{} notifications").format(len(messages))
@@ -460,18 +468,18 @@ class MyMessages(My, Messages):
 #         h)
 
 
-@dd.schedule_often(every=10)
+@schedule_often(every=10)
 def send_pending_emails_often(ar):
     # print("20231021 send_pending_emails_often()", ar.logger)
     rt.models.notify.Message.send_summary_emails(ar, MailModes.often)
 
 
-@dd.schedule_daily()
+@schedule_daily()
 def send_pending_emails_daily(ar):
     rt.models.notify.Message.send_summary_emails(ar, MailModes.daily)
 
 
-# @dd.schedule_often(every=10)
+# @schedule_often(every=10)
 # def send_pending_emails_often(ar):
 #     Message = rt.models.notify.Message
 #     qs = Message.objects.filter(sent__isnull=True)
@@ -488,7 +496,7 @@ remove_after = dd.plugins.notify.remove_after
 
 if remove_after:
 
-    @dd.schedule_daily()
+    @schedule_daily()
     def clear_seen_messages(ar):
         Message = rt.models.notify.Message
         qs = Message.objects.filter(

lino/modlib/printing/actions.py

@@ -33,7 +33,7 @@ class BasePrintAction(Action):
     hotkey = Hotkey("p", code="KeyP", ctrl=True)
 
     def __init__(self, build_method=None, label=None, **kwargs):
-        super(BasePrintAction, self).__init__(label, **kwargs)
+        super().__init__(label, **kwargs)
         if build_method is not None:
             self.build_method = build_method
 
@@ -46,7 +46,7 @@ class BasePrintAction(Action):
             return False
         # if actor.__name__ == 'ExcerptsByProject':
         #     logger.info("20140401 attach_to_actor() %r", self)
-        return super(BasePrintAction, self).attach_to_actor(actor, name)
+        return super().attach_to_actor(actor, name)
 
     def get_print_templates(self, bm, elem):
         # print("20190506 BasePrintAction.get_print_templates", elem)
@@ -65,17 +65,19 @@ class BasePrintAction(Action):
         """Return the target filename if a document needs to be built,
         otherwise return ``None``.
         """
-        elem.before_printable_build(bm)
-        # raise Exception("20170519 before_build didn't warn")
-        filename = bm.get_target_name(self, elem)
-        if not filename:
+        # elem.before_printable_build(bm)
+        if not elem.must_build_printable(bm):
             return
-        if os.path.exists(filename):
-            logger.debug("%s %s -> overwrite existing %s.", bm, elem, filename)
-            os.remove(filename)
-        else:
-            # logger.info("20121221 makedirs_if_missing %s",os.path.dirname(filename))
-            rt.makedirs_if_missing(os.path.dirname(filename))
+        # raise Exception("20170519 before_build didn't warn")
+        filename = bm.get_target_file(self, elem).path
+        filename.unlink(missing_ok=True)
+        filename.parent.mkdir(exist_ok=True, parents=True)
+        # if filename.exists():
+        #     logger.debug("%s %s -> overwrite existing %s.", bm, elem, filename)
+        #     os.remove(filename)
+        # else:
+        #     # logger.info("20121221 makedirs_if_missing %s",os.path.dirname(filename))
+        #     rt.makedirs_if_missing(os.path.dirname(filename))
         logger.debug("%s : %s -> %s", bm, elem, filename)
         return filename
 
@@ -90,7 +92,8 @@ class BasePrintAction(Action):
             "If it doesn't, please "
             "ask your system administrator."
         )
-        msg = msg.format(etree.tostring(E.a(leaf, href=url), encoding="unicode"))
+        msg = msg.format(etree.tostring(
+            E.a(leaf, href=url), encoding="unicode"))
         # msg %= dict(doc=leaf, help=etree.tostring(
         #     help_url, encoding="unicode"))
         kw.update(message=msg, alert=True)
@@ -104,9 +107,10 @@ class BasePrintAction(Action):
         if isinstance(bm, str):
             bm = BuildMethods.get_by_value(bm)
         bm.build(ar, self, elem)
-        mf = bm.get_target(self, elem)
-        leaf = mf.parts[-1]
-        self.notify_done(ar, bm, leaf, mf.get_url(ar.request), **kw)
+        mf = bm.get_target_file(self, elem)
+        # leaf = mf.parts[-1]
+        leaf = mf.path.name
+        self.notify_done(ar, bm, leaf, mf.url, **kw)
 
 
 class DirectPrintAction(BasePrintAction):
@@ -168,23 +172,25 @@ class CachedPrintAction(BasePrintAction):
         if len(ar.selected_rows) == 1:
             obj = ar.selected_rows[0]
             bm = obj.get_build_method()
-            mf = bm.get_target(self, obj)
-            leaf = mf.parts[-1]
+            mf = bm.get_target_file(self, obj)
+            # leaf = mf.parts[-1]
+            leaf = mf.path.name
             if obj.build_time is None:
                 obj.build_target(ar)
                 ar.debug("%s has been built.", leaf)
             else:
                 ar.debug("Reused %s from cache.", leaf)
 
-            url = mf.get_url(ar.request)
-            self.notify_done(ar, bm, leaf, url, **kw)
+            # url = mf.get_url(ar.request)
+            self.notify_done(ar, bm, leaf, mf.url, **kw)
             ar.set_response(refresh=True)
             return
 
         def ok(ar2):
             # qs = [ar.actor.get_row_by_pk(pk) for pk in ar.selected_pks]
             mf = self.print_multiple(ar, ar.selected_rows)
-            ar2.success(open_url=mf.get_url(ar.request))
+            ar2.success(open_url=mf.url)
+            # ar2.success(open_url=mf.get_url(ar.request))
             # kw.update(refresh_all=True)
             # return kw
 
@@ -197,13 +203,16 @@ class CachedPrintAction(BasePrintAction):
             # assert isinstance(obj,CachedPrintable)
             if obj.printed_by_id is None:
                 obj.build_target(ar)
-            pdf = obj.get_target_name()
-            assert pdf is not None
-            pdfs.append(pdf)
+            # pdf = obj.get_target_file().name
+            # assert pdf is not None
+            # pdfs.append(pdf)
+            mf = obj.get_target_file()
+            pdfs.append(mf.path)
 
         mf = TmpMediaFile(ar, "pdf")
-        rt.makedirs_if_missing(os.path.dirname(mf.name))
-        merge_pdfs(pdfs, mf.name)
+        # rt.makedirs_if_missing(os.path.dirname(mf.name))
+        rt.makedirs_if_missing(mf.path.parent)
+        merge_pdfs(pdfs, mf.path)
         return mf
 
 
@@ -217,7 +226,7 @@ class EditTemplate(BasePrintAction):
         # if not settings.SITE.is_installed('davlink'):
         if not settings.SITE.webdav_protocol:
             return False
-        return super(EditTemplate, self).attach_to_actor(actor, name)
+        return super().attach_to_actor(actor, name)
 
     def run_from_ui(self, ar, **kw):
         lcd = settings.SITE.confdirs.LOCAL_CONFIG_DIR
@@ -269,7 +278,8 @@ class EditTemplate(BasePrintAction):
             ar.debug("Gonna copy %s to %s", filename, local_file)
 
             def ok(ar2):
-                logger.info("%s made local template copy %s", ar.user, local_file)
+                logger.info("%s made local template copy %s",
+                            ar.user, local_file)
                 rt.makedirs_if_missing(os.path.dirname(local_file))
                 shutil.copyfile(filename, local_file)
                 # shutil.copy() can cause PermissionError if dst exists and is
@@ -299,14 +309,15 @@ class ClearCacheAction(Action):
         # should be visible in the UI
         if obj is not None and not obj.build_time:
             return False
-        return super(ClearCacheAction, self).get_action_permission(ar, obj, state)
+        return super().get_action_permission(ar, obj, state)
 
     def run_from_ui(self, ar):
         elem = ar.selected_rows[0]
 
         def doit(ar):
             elem.clear_cache()
-            ar.success(_("%s printable cache has been cleared.") % elem, refresh=True)
+            ar.success(_("%s printable cache has been cleared.") %
+                       elem, refresh=True)
 
         t = elem.get_cache_mtime()
         if t is not None:

lino/modlib/printing/choicelists.py

@@ -44,21 +44,21 @@ class BuildMethod(Choice):
             names = self.name
         super().__init__(names, self.__class__.__name__, names, **kwargs)
 
-    def get_target(self, action, obj):
+    def get_target_file(self, action, obj):
         # Used by get_target_name()
         # assert self.name is not None
         return MediaFile(
             self.use_webdav,
             self.cache_name,
             self.value,
-            obj.filename_root() + self.target_ext,
+            obj.get_printable_target_stem() + self.target_ext,
         )
 
-    def get_target_name(self, action, elem):
-        return self.get_target(action, elem).name
+    # def get_target_name(self, action, elem):
+    #     return self.get_target_file(action, elem).name
 
     def get_target_url(self, action, elem):
-        return self.get_target(action, elem).url
+        return self.get_target_file(action, elem).url
 
     def build(self, ar, action, elem):
         raise NotImplementedError
@@ -108,7 +108,8 @@ class DjangoBuildMethod(TemplatedBuildMethod):
         except TemplateDoesNotExist as e:
             raise Warning("No template found for %s (%s)" % (e, tpls2))
         except Exception as e:
-            raise Exception("Error while loading template for %s : %s" % (tpls2, e))
+            raise Exception(
+                "Error while loading template for %s : %s" % (tpls2, e))
 
     # ,MEDIA_URL=settings.MEDIA_URL):
     def render_template(self, elem, tpl, **context):
@@ -170,7 +171,8 @@ class SimpleBuildMethod(TemplatedBuildMethod):
 
         lang = elem.get_print_language() or translation.get_language()
         if lang != settings.SITE.DEFAULT_LANGUAGE.django_code:
-            name = tpl_leaf[: -len(self.template_ext)] + "_" + lang + self.template_ext
+            name = tpl_leaf[: -len(self.template_ext)] + \
+                                   "_" + lang + self.template_ext
             if rt.find_config_file(name, *elem.get_template_groups()):
                 return name
         return tpl_leaf
@@ -238,7 +240,6 @@ class XmlBuildMethod(DjangoBuildMethod):
         lang = str(elem.get_print_language() or translation.get_language())
         # or settings.SITE.DEFAULT_LANGUAGE.django_code)
 
-
         with translation.override(lang):
             cmd_options = elem.get_build_options(self)
             logger.info(
@@ -288,7 +289,8 @@ class BuildMethods(ChoiceList):
             if bm is None:
                 raise Exception(
                     "Invalid default_build_method '{}', choices are {}".format(
-                        settings.SITE.default_build_method, tuple(cls.get_list_items())
+                        settings.SITE.default_build_method, tuple(
+                            cls.get_list_items())
                     )
                 )
             return bm

lino/modlib/printing/mixins.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-# Copyright 2009-2024 Rumma & Ko Ltd
+# Copyright 2009-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
 import os
@@ -137,14 +137,15 @@ class Printable(Model):
             kw = ar.get_printable_context(**kw)
         kw.update(this=self)  # for backward compatibility
         kw.update(obj=self)  # preferred in new templates
-        kw.update(language=self.get_print_language() or translation.get_language())
+        kw.update(language=self.get_print_language()
+                  or translation.get_language())
         # settings.SITE.DEFAULT_LANGUAGE.django_code)
         kw.update(site=settings.SITE)
         kw.update(weekdays=weekdays)
         return kw
 
-    def before_printable_build(self, bm):
-        pass
+    def must_build_printable(self, bm):
+        return True
 
 
 class CachedPrintable(Duplicable, Printable):
@@ -155,23 +156,26 @@ class CachedPrintable(Duplicable, Printable):
     do_clear_cache = ClearCacheAction()
     edit_template = EditTemplate()
 
-    build_time = models.DateTimeField(_("build time"), null=True, editable=False)
-
+    build_time = models.DateTimeField(
+        _("build time"), null=True, editable=False)
     build_method = BuildMethods.field(blank=True, null=True)
 
     def full_clean(self, *args, **kwargs):
         if not self.build_method:
             self.build_method = self.get_default_build_method()
-        super(CachedPrintable, self).full_clean(*args, **kwargs)
+        super().full_clean(*args, **kwargs)
 
     def on_duplicate(self, ar, master):
-        super(CachedPrintable, self).on_duplicate(ar, master)
+        super().on_duplicate(ar, master)
         self.build_time = None
         self.build_method = None
 
-    def get_target_name(self):
-        if self.build_time:
-            return self.get_build_method().get_target_name(self.do_print, self)
+    def must_build_printable(self, bm):
+        return self.build_time is None
+
+    # def get_target_name(self):
+    #     if self.build_time:
+    #         return self.get_build_method().get_target_name(self.do_print, self)
 
     def get_build_method(self):
         return self.build_method or self.get_default_build_method()
@@ -179,19 +183,20 @@ class CachedPrintable(Duplicable, Printable):
     def get_target_url(self):
         return self.build_method.get_target_url(self.do_print, self)
 
+    def get_target_file(self):
+        return self.build_method.get_target_file(self.do_print, self)
+
     def get_cache_mtime(self):
         """Return the modification time (a `datetime`) of the generated cache
         file, or `None` if no such file exists.
 
         """
-        filename = self.get_target_name()
+        filename = self.get_target_file().path
         if not filename:
             return None
-        try:
-            t = os.path.getmtime(filename)
-        except OSError:
+        if not filename.exists():
             return None
-        return datetime.datetime.fromtimestamp(t)
+        return datetime.datetime.fromtimestamp(filename.lstat().st_mtime)
 
     def clear_cache(self):
         self.build_time = None
@@ -223,14 +228,14 @@ class TypedPrintable(CachedPrintable):
     def get_template_groups(self):
         ptype = self.get_printable_type()
         if ptype is None:
-            return super(TypedPrintable, self).get_template_groups()
+            return super().get_template_groups()
         return ptype.get_template_groups()
 
     def get_default_build_method(self):
         ptype = self.get_printable_type()
         if ptype and ptype.build_method:
             return ptype.build_method
-        return super(TypedPrintable, self).get_default_build_method()
+        return super().get_default_build_method()
 
     # def get_build_method(self):
     #     if not self.build_method:
@@ -239,12 +244,12 @@ class TypedPrintable(CachedPrintable):
     # ptype = self.get_printable_type()
     # if ptype and ptype.build_method:
     #     return ptype.build_method
-    # return super(TypedPrintable, self).get_build_method()
+    # return super().get_build_method()
 
     def get_print_templates(self, bm, action):
         ptype = self.get_printable_type()
         if ptype is None:
-            return super(TypedPrintable, self).get_print_templates(bm, action)
+            return super().get_print_templates(bm, action)
 
         if ptype.template:
             return [ptype.template]