vortex-nwp 2.0.0b1__py3-none-any.whl → 2.0.0b2__py3-none-any.whl

vortex/tools/services.py

@@ -5,7 +5,7 @@ With the abstract class Service (inheritating from FootprintBase)
 a default Mail Service is provided.
 """
 
-from configparser import NoOptionError, NoSectionError
+import configparser
 import contextlib
 import hashlib
 import pprint
@@ -19,7 +19,11 @@ from bronx.stdtypes import date
 from bronx.stdtypes.dictionaries import UpperCaseDict
 from bronx.syntax.pretty import EncodedPrettyPrinter
 from vortex import sessions
-from vortex.util.config import GenericConfigParser, load_template, LegacyTemplatingAdapter
+from vortex.util.config import (
+    GenericConfigParser,
+    load_template,
+    LegacyTemplatingAdapter,
+)
 
 #: No automatic export
 __all__ = []
@@ -27,7 +31,7 @@ __all__ = []
 logger = loggers.getLogger(__name__)
 
 # See logging.handlers.SysLogHandler.priority_map
-criticals = ['debug', 'info', 'error', 'warning', 'critical']
+criticals = ["debug", "info", "error", "warning", "critical"]
 
 
 class Service(footprints.FootprintBase):
@@ -36,31 +40,31 @@ class Service(footprints.FootprintBase):
     """
 
     _abstract = True
-    _collector = ('service',)
+    _collector = ("service",)
     _footprint = dict(
-        info = 'Abstract services class',
-        attr = dict(
-            kind = dict(),
-            level = dict(
-                optional = True,
-                default  = 'info',
-                values   = criticals,
-            ),
-        )
+        info="Abstract services class",
+        attr=dict(
+            kind=dict(),
+            level=dict(
+                optional=True,
+                default="info",
+                values=criticals,
+            ),
+        ),
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Abstract service init %s', self.__class__)
+        logger.debug("Abstract service init %s", self.__class__)
         t = sessions.current()
-        glove = kw.pop('glove', t.glove)
-        sh = kw.pop('sh', t.system())
+        glove = kw.pop("glove", t.glove)
+        sh = kw.pop("sh", t.system())
         super().__init__(*args, **kw)
         self._glove = glove
         self._sh = sh
 
     @property
     def realkind(self):
-        return 'service'
+        return "service"
 
     @property
     def sh(self):
@@ -89,7 +93,7 @@ class Service(footprints.FootprintBase):
             value = self.env.get(as_var, None)
         if not value:
             if as_conf is None:
-                as_conf = 'services:' + key.lower()
+                as_conf = "services:" + key.lower()
             value = self.sh.default_target.get(as_conf, default)
         return value
 
@@ -104,69 +108,66 @@ class MailService(Service):
     """
 
     _footprint = dict(
-        info = 'Mail services class',
-        attr = dict(
-            kind = dict(
-                values   = ['sendmail'],
-            ),
-            sender = dict(
-                optional = True,
-                default  = '[glove::xmail]',
-            ),
-            to = dict(
-                alias    = ('receiver', 'recipients'),
-            ),
-            replyto = dict(
-                optional = True,
-                alias    = ('reply', 'reply_to'),
-                default  = None,
-            ),
-            message = dict(
-                optional = True,
-                default  = '',
-                alias    = ('contents', 'body'),
-                type     = str,
-            ),
-            filename = dict(
-                optional = True,
-                default  = None,
-            ),
-            attachments = dict(
-                type     = footprints.FPList,
-                optional = True,
-                default  = footprints.FPList(),
-                alias    = ('files', 'attach'),
-            ),
-            subject = dict(
-                type     = str,
-            ),
-            smtpserver = dict(
-                optional = True,
-            ),
-            smtpport = dict(
-                type     = int,
-                optional = True,
-            ),
-            smtpuser = dict(
-                optional = True,
-            ),
-            smtppass = dict(
-                optional = True,
-            ),
-            charset = dict(
-                info     = 'The encoding that should be used when sending the email',
-                optional = True,
-                default  = 'utf-8',
-            ),
-            inputs_charset = dict(
-                info     = 'The encoding that should be used when reading input files',
-                optional = True,
-            ),
-            commaspace = dict(
-                optional = True,
-                default  = ', '
-            )
-        )
+        info="Mail services class",
+        attr=dict(
+            kind=dict(
+                values=["sendmail"],
+            ),
+            sender=dict(
+                optional=True,
+                default="[glove::xmail]",
+            ),
+            to=dict(
+                alias=("receiver", "recipients"),
+            ),
+            replyto=dict(
+                optional=True,
+                alias=("reply", "reply_to"),
+                default=None,
+            ),
+            message=dict(
+                optional=True,
+                default="",
+                alias=("contents", "body"),
+                type=str,
+            ),
+            filename=dict(
+                optional=True,
+                default=None,
+            ),
+            attachments=dict(
+                type=footprints.FPList,
+                optional=True,
+                default=footprints.FPList(),
+                alias=("files", "attach"),
+            ),
+            subject=dict(
+                type=str,
+            ),
+            smtpserver=dict(
+                optional=True,
+            ),
+            smtpport=dict(
+                type=int,
+                optional=True,
+            ),
+            smtpuser=dict(
+                optional=True,
+            ),
+            smtppass=dict(
+                optional=True,
+            ),
+            charset=dict(
+                info="The encoding that should be used when sending the email",
+                optional=True,
+                default="utf-8",
+            ),
+            inputs_charset=dict(
+                info="The encoding that should be used when reading input files",
+                optional=True,
+            ),
+            commaspace=dict(optional=True, default=", "),
+        ),
     )
 
     def attach(self, *args):
@@ -186,28 +187,41 @@ class MailService(Service):
             with open(self.filename, encoding=self.inputs_charset) as tmp:
                 body += tmp.read()
         from email.message import EmailMessage
+
         msg = EmailMessage()
-        msg.set_content(body, subtype="plain",
-                        charset=(self.charset if self.is_not_plain_ascii(body) else 'us-ascii'))
+        msg.set_content(
+            body,
+            subtype="plain",
+            charset=(
+                self.charset if self.is_not_plain_ascii(body) else "us-ascii"
+            ),
+        )
         return msg
 
     def as_multipart(self, msg):
         """Build a new multipart mail with default text contents and attachments."""
         from email.message import MIMEPart
+
         for xtra in self.attachments:
             if isinstance(xtra, MIMEPart):
                 msg.add_attachment(xtra)
             elif self.sh.path.isfile(xtra):
                 import mimetypes
+
                 ctype, encoding = mimetypes.guess_type(xtra)
                 if ctype is None or encoding is not None:
                     # No guess could be made, or the file is encoded
                     # (compressed), so use a generic bag-of-bits type.
-                    ctype = 'application/octet-stream'
-                maintype, subtype = ctype.split('/', 1)
-                with open(xtra, 'rb') as fp:
-                    msg.add_attachment(fp.read(), maintype, subtype,
-                                       cte="base64", filename=xtra)
+                    ctype = "application/octet-stream"
+                maintype, subtype = ctype.split("/", 1)
+                with open(xtra, "rb") as fp:
+                    msg.add_attachment(
+                        fp.read(),
+                        maintype,
+                        subtype,
+                        cte="base64",
+                        filename=xtra,
+                    )
         return msg
 
     def _set_header(self, msg, header, value):
@@ -215,25 +229,30 @@ class MailService(Service):
 
     def set_headers(self, msg):
         """Put on the current message the header items associated to footprint attributes."""
-        self._set_header(msg, 'From', self.sender)
-        self._set_header(msg, 'To', self.commaspace.join(self.to.split()))
-        self._set_header(msg, 'Subject', self.subject)
+        self._set_header(msg, "From", self.sender)
+        self._set_header(msg, "To", self.commaspace.join(self.to.split()))
+        self._set_header(msg, "Subject", self.subject)
         if self.replyto is not None:
-            self._set_header(msg, 'Reply-To', self.commaspace.join(self.replyto.split()))
+            self._set_header(
+                msg, "Reply-To", self.commaspace.join(self.replyto.split())
+            )
 
     @contextlib.contextmanager
     def smtp_entrypoints(self):
         import smtplib
-        my_smtpserver = self.actual_value('smtpserver',
-                                          as_var='VORTEX_SMTPSERVER',
-                                          default='localhost')
-        my_smtpport = self.actual_value('smtpport',
-                                        as_var='VORTEX_SMTPPORT',
-                                        default=smtplib.SMTP_PORT)
+
+        my_smtpserver = self.actual_value(
+            "smtpserver", as_var="VORTEX_SMTPSERVER", default="localhost"
+        )
+        my_smtpport = self.actual_value(
+            "smtpport", as_var="VORTEX_SMTPPORT", default=smtplib.SMTP_PORT
+        )
         if not self.sh.default_target.isnetworknode:
-            sshobj = self.sh.ssh('network', virtualnode=True, mandatory_hostcheck=False)
+            sshobj = self.sh.ssh(
+                "network", virtualnode=True, mandatory_hostcheck=False
+            )
             with sshobj.tunnel(my_smtpserver, my_smtpport) as tun:
-                yield 'localhost', tun.entranceport
+                yield "localhost", tun.entranceport
         else:
             yield my_smtpserver, my_smtpport
 
@@ -246,9 +265,10 @@ class MailService(Service):
         msgcorpus = msg.as_string()
         with self.smtp_entrypoints() as (smtpserver, smtpport):
             import smtplib
+
             extras = dict()
             if smtpport:
-                extras['port'] = smtpport
+                extras["port"] = smtpport
             smtp = smtplib.SMTP(smtpserver, **extras)
             if self.smtpuser and self.smtppass:
                 smtp.login(self.smtpuser, self.smtppass)
@@ -265,20 +285,15 @@ class ReportService(Service):
 
     _abstract = True
     _footprint = dict(
-        info = 'Report services class',
-        attr = dict(
-            kind = dict(
-                values   = ['sendreport']
-            ),
-            sender = dict(
-                optional = True,
-                default  = '[glove::user]',
-            ),
-            subject = dict(
-                optional = True,
-                default  = 'Test'
-            ),
-        )
+        info="Report services class",
+        attr=dict(
+            kind=dict(values=["sendreport"]),
+            sender=dict(
+                optional=True,
+                default="[glove::user]",
+            ),
+            subject=dict(optional=True, default="Test"),
+        ),
     )
 
     def __call__(self, *args):
@@ -291,14 +306,14 @@ class FileReportService(ReportService):
 
     _abstract = True
     _footprint = dict(
-        info = 'File Report services class',
-        attr = dict(
-            kind = dict(
-                values = ['sendreport', 'sendfilereport'],
-                remap  = dict(sendfilereport = 'sendreport'),
-            ),
-            filename = dict(),
-        )
+        info="File Report services class",
+        attr=dict(
+            kind=dict(
+                values=["sendreport", "sendfilereport"],
+                remap=dict(sendfilereport="sendreport"),
+            ),
+            filename=dict(),
+        ),
     )
 
 
@@ -318,57 +333,74 @@ class SSHProxy(Service):
     """
 
     _footprint = dict(
-        info = 'Remote command proxy',
-        attr = dict(
-            kind = dict(
-                values   = ['ssh', 'ssh_proxy'],
-                remap    = dict(autoremap = 'first'),
-            ),
-            hostname = dict(),
-            genericnode = dict(
-                optional = True,
-                default  = None,
-                access   = 'rwx',
-            ),
-            nodetype = dict(
-                optional = True,
-                values   = ['login', 'transfer', 'transfert', 'network', 'agt', 'syslog'],
-                default  = 'network',
-                remap    = dict(transfer = 'transfert'),
-            ),
-            permut = dict(
-                type     = bool,
-                optional = True,
-                default  = True,
-            ),
-            maxtries = dict(
-                type     = int,
-                optional = True,
-                default  = 2,
-            ),
-            sshopts = dict(
-                optional = True,
-                type     = footprints.FPList,
-                default  = None,
-            ),
-        )
+        info="Remote command proxy",
+        attr=dict(
+            kind=dict(
+                values=["ssh", "ssh_proxy"],
+                remap=dict(autoremap="first"),
+            ),
+            hostname=dict(),
+            genericnode=dict(
+                optional=True,
+                default=None,
+                access="rwx",
+            ),
+            nodetype=dict(
+                optional=True,
+                values=[
+                    "login",
+                    "transfer",
+                    "transfert",
+                    "network",
+                    "agt",
+                    "syslog",
+                ],
+                default="network",
+                remap=dict(transfer="transfert"),
+            ),
+            permut=dict(
+                type=bool,
+                optional=True,
+                default=True,
+            ),
+            maxtries=dict(
+                type=int,
+                optional=True,
+                default=2,
+            ),
+            sshopts=dict(
+                optional=True,
+                type=footprints.FPList,
+                default=None,
+            ),
+        ),
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Remote command proxy init %s', self.__class__)
+        logger.debug("Remote command proxy init %s", self.__class__)
         super().__init__(*args, **kw)
         hostname, virtualnode = self._actual_hostname()
-        extra_sshopts = None if self.sshopts is None else ' '.join(self.sshopts)
-        self._sshobj = self.sh.ssh(hostname, sshopts=extra_sshopts,
-                                   maxtries=self.maxtries, virtualnode=virtualnode,
-                                   permut=self.permut, mandatory_hostcheck=False)
+        extra_sshopts = (
+            None if self.sshopts is None else " ".join(self.sshopts)
+        )
+        self._sshobj = self.sh.ssh(
+            hostname,
+            sshopts=extra_sshopts,
+            maxtries=self.maxtries,
+            virtualnode=virtualnode,
+            permut=self.permut,
+            mandatory_hostcheck=False,
+        )
 
     def _actual_hostname(self):
         """Build a list of candidate target hostnames."""
         myhostname = self.hostname.strip().lower()
         virtualnode = False
-        if myhostname == 'node':
-            if self.genericnode is not None and self.genericnode != 'no_generic':
+        if myhostname == "node":
+            if (
+                self.genericnode is not None
+                and self.genericnode != "no_generic"
+            ):
                 myhostname = self.genericnode
             else:
                 myhostname = self.nodetype
@@ -381,7 +413,7 @@ class SSHProxy(Service):
 
     def __call__(self, *args):
         """Remote execution."""
-        return self._sshobj.execute(' '.join(args))
+        return self._sshobj.execute(" ".join(args))
 
 
 class JeevesService(Service):
@@ -390,38 +422,39 @@ class JeevesService(Service):
     """
 
     _footprint = dict(
-        info = 'Jeeves services class',
-        attr = dict(
-            kind = dict(
-                values   = ['askjeeves']
-            ),
-            todo = dict(),
-            jname = dict(
-                optional = True,
-                default  = 'test',
-            ),
-            juser = dict(
-                optional = True,
-                default  = '[glove::user]',
-            ),
-            jpath = dict(
-                optional = True,
-                default  = None,
-                access   = 'rwx',
-            ),
-            jfile = dict(
-                optional = True,
-                default  = 'vortex',
-            ),
-        )
+        info="Jeeves services class",
+        attr=dict(
+            kind=dict(values=["askjeeves"]),
+            todo=dict(),
+            jname=dict(
+                optional=True,
+                default="test",
+            ),
+            juser=dict(
+                optional=True,
+                default="[glove::user]",
+            ),
+            jpath=dict(
+                optional=True,
+                default=None,
+                access="rwx",
+            ),
+            jfile=dict(
+                optional=True,
+                default="vortex",
+            ),
+        ),
     )
 
     def __call__(self, *args):
         """Main action: ..."""
         if self.jpath is None:
-            self.jpath = self.sh.path.join(self.env.HOME, 'jeeves', self.jname, 'depot')
+            self.jpath = self.sh.path.join(
+                self.env.HOME, "jeeves", self.jname, "depot"
+            )
         if self.sh.path.isdir(self.jpath):
             from jeeves import bertie
+
             data = dict()
             for arg in args:
                 data.update(arg)
@@ -429,10 +462,11 @@ class JeevesService(Service):
                 user=self.juser,
                 jtag=self.sh.path.join(self.jpath, self.jfile),
                 todo=self.todo,
-                mail=data.pop('mail', self.glove.xmail),
-                apps=data.pop('apps', (self.glove.vapp,)),
-                conf=data.pop('conf', (self.glove.vconf,)),
-                task=self.env.get('JOBNAME') or self.env.get('SMSNAME', 'interactif'),
+                mail=data.pop("mail", self.glove.xmail),
+                apps=data.pop("apps", (self.glove.vapp,)),
+                conf=data.pop("conf", (self.glove.vconf,)),
+                task=self.env.get("JOBNAME")
+                or self.env.get("SMSNAME", "interactif"),
             )
             fulltalk.update(
                 data=data,
@@ -440,7 +474,7 @@ class JeevesService(Service):
             jr = bertie.ask(**fulltalk)
             return jr.todo, jr.last
         else:
-            logger.error('No valid path to jeeves <%s>', self.jpath)
+            logger.error("No valid path to jeeves <%s>", self.jpath)
             return None
 
 
@@ -453,37 +487,41 @@ class HideService(Service):
     """
 
     _footprint = dict(
-        info = 'Hide a given object on current filesystem',
-        attr = dict(
-            kind = dict(
-                values   = ['hidden', 'hide', 'hiddencache'],
-                remap    = dict(autoremap = 'first'),
+        info="Hide a given object on current filesystem",
+        attr=dict(
+            kind=dict(
+                values=["hidden", "hide", "hiddencache"],
+                remap=dict(autoremap="first"),
             ),
-            rootdir = dict(
-                optional = True,
-                default  = None,
+            rootdir=dict(
+                optional=True,
+                default=None,
             ),
-            headdir = dict(
-                optional = True,
-                default  = 'hidden',
+            headdir=dict(
+                optional=True,
+                default="hidden",
             ),
-            asfmt = dict(
-                optional = True,
-                default  = None,
+            asfmt=dict(
+                optional=True,
+                default=None,
             ),
-        )
+        ),
     )
 
     def find_rootdir(self, filename):
         """Find a path for hiding files on the same filesystem."""
         username = self.sh.getlogname()
-        work_dir = self.sh.path.join(self.sh.find_mount_point(filename), 'work')
+        work_dir = self.sh.path.join(
+            self.sh.find_mount_point(filename), "work"
+        )
         if not self.sh.path.exists(work_dir):
             logger.warning("path <%s> doesn't exist", work_dir)
             fullpath = self.sh.path.realpath(filename)
             if username not in fullpath:
-                logger.error('No login <%s> in path <%s>', username, fullpath)
-                raise ValueError('Login name not in actual path for hiding data')
+                logger.error("No login <%s> in path <%s>", username, fullpath)
+                raise ValueError(
+                    "Login name not in actual path for hiding data"
+                )
             work_dir = fullpath.partition(username)[0]
             logger.warning("using work_dir = <%s>", work_dir)
         hidden_path = self.sh.path.join(work_dir, username, self.headdir)
@@ -494,21 +532,25 @@ class HideService(Service):
 
         rootdir = self.rootdir
         if rootdir is None:
-            rootdir = self.sh.default_target.get('hidden_rootdir', None)
+            rootdir = self.sh.default_target.get("hidden_rootdir", None)
         if rootdir is not None:
             rootdir = self.sh.path.expanduser(rootdir)
 
         actual_rootdir = rootdir or self.find_rootdir(filename)
         destination = self.sh.path.join(
             actual_rootdir,
-            '.'.join((
-                'HIDDEN',
-                date.now().strftime('%Y%m%d%H%M%S.%f'),
-                'P{:06d}'.format(self.sh.getpid()),
-                hashlib.md5(self.sh.path.abspath(filename).encode(encoding='utf-8')).hexdigest()
-            ))
+            ".".join(
+                (
+                    "HIDDEN",
+                    date.now().strftime("%Y%m%d%H%M%S.%f"),
+                    "P{:06d}".format(self.sh.getpid()),
+                    hashlib.md5(
+                        self.sh.path.abspath(filename).encode(encoding="utf-8")
+                    ).hexdigest(),
+                )
+            ),
         )
-        self.sh.cp(filename, destination, intent='in', fmt=self.asfmt)
+        self.sh.cp(filename, destination, intent="in", fmt=self.asfmt)
         return destination
 
 
@@ -519,20 +561,21 @@ class Directory:
     Directory (en) means Annuaire (fr).
     """
 
-    def __init__(self, inifile, domain='meteo.fr', encoding=None):
+    def __init__(self, inifile, domain="meteo.fr", encoding=None):
         """Keep aliases in memory, as a dict of sets."""
         config = GenericConfigParser(inifile, encoding=encoding)
         try:
-            self.domain = config.get('general', 'default_domain')
-        except NoOptionError:
+            self.domain = config.get("general", "default_domain")
+        except configparser.NoOptionError:
             self.domain = domain
         self.aliases = {
-            k.lower(): set(v.lower().replace(',', ' ').split())
-            for (k, v) in config.items('aliases')
+            k.lower(): set(v.lower().replace(",", " ").split())
+            for (k, v) in config.items("aliases")
         }
         count = self._flatten()
-        logger.debug('opmail aliases flattened in %d iterations:\n%s',
-                     count, str(self))
+        logger.debug(
+            "opmail aliases flattened in %d iterations:\n%s", count, str(self)
+        )
 
     def get_addresses(self, definition, add_domain=True):
         """
@@ -540,20 +583,24 @@ class Directory:
         may reference aliases.
         """
         addresses = set()
-        for item in definition.lower().replace(',', ' ').split():
+        for item in definition.lower().replace(",", " ").split():
             if item in self.aliases:
                 addresses |= self.aliases[item]
             else:
                 addresses |= {item}
         if add_domain:
-            return ' '.join(self._add_domain(addresses))
-        return ' '.join(addresses)
+            return " ".join(self._add_domain(addresses))
+        return " ".join(addresses)
 
     def __str__(self):
-        return '\n'.join(sorted(
-            ['{}: {}'.format(k, ' '.join(sorted(v)))
-             for (k, v) in self.aliases.items()]
-        ))
+        return "\n".join(
+            sorted(
+                [
+                    "{}: {}".format(k, " ".join(sorted(v)))
+                    for (k, v) in self.aliases.items()
+                ]
+            )
+        )
 
     def _flatten(self):
         """Resolve recursive definitions from the dict of sets."""
@@ -564,11 +611,18 @@ class Directory:
             count += 1
             for kref, vref in self.aliases.items():
                 if kref in vref:
-                    logger.error('Cycle detected in the aliases directory.\n'
-                                 'offending key: %s.\n'
-                                 'directory being flattened:\n%s',
-                                 str(kref), str(self))
-                    raise ValueError('Cycle for key <{}> in directory definition'.format(kref))
+                    logger.error(
+                        "Cycle detected in the aliases directory.\n"
+                        "offending key: %s.\n"
+                        "directory being flattened:\n%s",
+                        str(kref),
+                        str(self),
+                    )
+                    raise ValueError(
+                        "Cycle for key <{}> in directory definition".format(
+                            kref
+                        )
+                    )
                 for k, v in self.aliases.items():
                     if kref in v:
                         v -= {kref}
@@ -579,11 +633,7 @@ class Directory:
 
     def _add_domain(self, aset):
         """Add domain where missing in a set of addresses."""
-        return {
-            v if '@' in v
-            else v + '@' + self.domain
-            for v in aset
-        }
+        return {v if "@" in v else v + "@" + self.domain for v in aset}
 
 
 class PromptService(Service):
@@ -593,16 +643,16 @@ class PromptService(Service):
     """
 
     _footprint = dict(
-        info = 'Simulate a call to a Service.',
-        attr = dict(
-            kind = dict(
-                values   = ('prompt',),
+        info="Simulate a call to a Service.",
+        attr=dict(
+            kind=dict(
+                values=("prompt",),
             ),
-            comment = dict(
-                optional = True,
-                default  = None,
+            comment=dict(
+                optional=True,
+                default=None,
             ),
-        )
+        ),
     )
 
     def __call__(self, options):
@@ -610,8 +660,8 @@ class PromptService(Service):
 
         pf = EncodedPrettyPrinter().pformat
         logger_action = getattr(logger, self.level, logger.warning)
-        msg = (self.comment or 'PromptService was called.') + '\noptions = {}'
-        logger_action(msg.format(pf(options)).replace('\n', '\n<prompt>'))
+        msg = (self.comment or "PromptService was called.") + "\noptions = {}"
+        logger_action(msg.format(pf(options)).replace("\n", "\n<prompt>"))
         return True
 
 
@@ -622,51 +672,51 @@ class TemplatedMailService(MailService):
     """
 
     _footprint = dict(
-        info = 'Templated mail services class',
-        attr = dict(
-            kind = dict(
-                values   = ['templatedmail'],
-            ),
-            id = dict(
-                alias    = ('template',),
-            ),
-            subject = dict(
-                optional = True,
-                default  = None,
-                access   = 'rwx',
-            ),
-            to = dict(
-                optional = True,
-                default  = None,
-                access   = 'rwx',
-            ),
-            message = dict(
-                access   = 'rwx',
-            ),
-            directory = dict(
-                type     = Directory,
-                optional = True,
-                default  = None,
-            ),
-            catalog = dict(
-                type     = GenericConfigParser,
-            ),
-            dryrun = dict(
-                info     = "Do not actually send the email. Just render the template.",
-                type     = bool,
-                optional = True,
-                default  = False,
-            ),
-        )
+        info="Templated mail services class",
+        attr=dict(
+            kind=dict(
+                values=["templatedmail"],
+            ),
+            id=dict(
+                alias=("template",),
+            ),
+            subject=dict(
+                optional=True,
+                default=None,
+                access="rwx",
+            ),
+            to=dict(
+                optional=True,
+                default=None,
+                access="rwx",
+            ),
+            message=dict(
+                access="rwx",
+            ),
+            directory=dict(
+                type=Directory,
+                optional=True,
+                default=None,
+            ),
+            catalog=dict(
+                type=configparser.ConfigParser,
+            ),
+            dryrun=dict(
+                info="Do not actually send the email. Just render the template.",
+                type=bool,
+                optional=True,
+                default=False,
+            ),
+        ),
     )
 
     _TEMPLATES_SUBDIR = None
 
     def __init__(self, *args, **kw):
-        ticket = kw.pop('ticket', sessions.get())
+        ticket = kw.pop("ticket", sessions.get())
         super().__init__(*args, **kw)
         self._ticket = ticket
-        logger.debug('TemplatedMail init for id <%s>', self.id)
+        logger.debug("TemplatedMail init for id <%s>", self.id)
 
     @property
     def ticket(self):
@@ -674,19 +724,21 @@ class TemplatedMailService(MailService):
 
     def header(self):
         """String prepended to the message body."""
-        return ''
+        return ""
 
     def trailer(self):
         """String appended to the message body."""
-        return ''
+        return ""
 
     def get_catalog_section(self):
         """Read section <id> (a dict-like) from the catalog."""
         try:
             section = dict(self.catalog.items(self.id))
-        except NoSectionError:
-            logger.error('Section <%s> is missing in catalog <%s>',
-                         self.id, self.catalog.file)
+        except configparser.NoSectionError:
+            logger.error(
+                "Section <%s> is missing in catalog",
+                self.id,
+            )
             section = None
         return section
 
@@ -707,28 +759,31 @@ class TemplatedMailService(MailService):
         """
         if not isinstance(tpl, (Template, LegacyTemplatingAdapter)):
             tpl = Template(tpl)
-        result = ''
+        result = ""
         for level in range(depth):
             try:
                 result = tpl.substitute(tpldict)
             except KeyError as exc:
-                logger.error('Undefined key <%s> in template substitution level %d',
-                             str(exc), level + 1)
+                logger.error(
+                    "Undefined key <%s> in template substitution level %d",
+                    str(exc),
+                    level + 1,
+                )
                 result = tpl.safe_substitute(tpldict)
             except ValueError as exc:
-                logger.error('Illegal syntax in template: %s', exc)
+                logger.error("Illegal syntax in template: %s", exc)
                 result = tpl.safe_substitute(tpldict)
             tpl = Template(result)
         return result
 
     def _template_name_rewrite(self, tplguess):
-        base = '@'
+        base = "@"
         if self._TEMPLATES_SUBDIR is not None:
-            base = '@{!s}/'.format(self._TEMPLATES_SUBDIR)
+            base = "@{!s}/".format(self._TEMPLATES_SUBDIR)
         if not tplguess.startswith(base):
             tplguess = base + tplguess
-        if not tplguess.endswith('.tpl'):
-            tplguess += '.tpl'
+        if not tplguess.endswith(".tpl"):
+            tplguess += ".tpl"
         return tplguess
 
     def get_message(self, tpldict):
@@ -739,13 +794,15 @@ class TemplatedMailService(MailService):
         * header and trailer are added.
         """
         tpl = self.message
-        if tpl == '':
-            tplfile = self.section.get('template', self.id)
+        if tpl == "":
+            tplfile = self.section.get("template", self.id)
             tplfile = self._template_name_rewrite(tplfile)
             try:
-                tpl = load_template(self.ticket, tplfile, encoding=self.inputs_charset)
+                tpl = load_template(
+                    self.ticket, tplfile, encoding=self.inputs_charset
+                )
             except ValueError as exc:
-                logger.error('%s', exc.message)
+                logger.error("%s", exc.message)
                 return None
         message = self.substitute(tpl, tpldict)
         return self.header() + message + self.trailer()
@@ -758,9 +815,11 @@ class TemplatedMailService(MailService):
         """
         tpl = self.subject
         if tpl is None:
-            tpl = self.section.get('subject', None)
+            tpl = self.section.get("subject", None)
             if tpl is None:
-                logger.error('Missing <subject> definition for id <%s>.', self.id)
+                logger.error(
+                    "Missing <subject> definition for id <%s>.", self.id
+                )
                 return None
         subject = self.substitute(tpl, tpldict)
         return subject
@@ -776,9 +835,9 @@ class TemplatedMailService(MailService):
         """
         tpl = self.to
         if tpl is None:
-            tpl = self.section.get('to', None)
+            tpl = self.section.get("to", None)
             if tpl is None:
-                logger.error('Missing <to> definition for id <%s>.', self.id)
+                logger.error("Missing <to> definition for id <%s>.", self.id)
                 return None
         to = self.substitute(tpl, tpldict)
         if self.directory:
@@ -834,38 +893,48 @@ class TemplatedMailService(MailService):
 
 
 class AbstractRdTemplatedMailService(TemplatedMailService):
-
     _abstract = True
 
     def header(self):
         """String prepended to the message body."""
         now = date.now()
-        stamp1 = now.strftime('%A %d %B %Y')
-        stamp2 = now.strftime('%X')
-        return 'Email sent on {} at {} (from: {}).\n--\n\n'.format(stamp1, stamp2,
-                                                                   self.sh.default_target.hostname)
+        stamp1 = now.strftime("%A %d %B %Y")
+        stamp2 = now.strftime("%X")
+        return "Email sent on {} at {} (from: {}).\n--\n\n".format(
+            stamp1, stamp2, self.sh.default_target.hostname
+        )
 
     def substitution_dictionary(self, add_ons=None):
         sdict = super().substitution_dictionary(add_ons=add_ons)
-        sdict['jobid'] = self.sh.guess_job_identifier()
+        sdict["jobid"] = self.sh.guess_job_identifier()
         # Try to detect MTOOL data (this may be empty if MTOOL is not used):
         if self.env.MTOOL_STEP:
-            mt_stack = ['\nMTOOL details:', ]
-            mt_items = ['mtool_step_{:s}'.format(i)
-                        for i in ('abort', 'depot', 'spool', 'idnum')
-                        if 'mtool_step_{:s}'.format(i) in self.env]
-            print_tablelike('{:s} = {!s}', mt_items, [self.env[i] for i in mt_items],
-                            output_callback=mt_stack.append)
-            sdict['mtool_info'] = '\n'.join(mt_stack) + '\n'
+            mt_stack = [
+                "\nMTOOL details:",
+            ]
+            mt_items = [
+                "mtool_step_{:s}".format(i)
+                for i in ("abort", "depot", "spool", "idnum")
+                if "mtool_step_{:s}".format(i) in self.env
+            ]
+            print_tablelike(
+                "{:s} = {!s}",
+                mt_items,
+                [self.env[i] for i in mt_items],
+                output_callback=mt_stack.append,
+            )
+            sdict["mtool_info"] = "\n".join(mt_stack) + "\n"
         else:
-            sdict['mtool_info'] = ''
+            sdict["mtool_info"] = ""
         # The list of footprints' defaults
         fpdefaults = footprints.setup.defaults
-        sdict['fpdefaults'] = pprint.pformat(fpdefaults, indent=2)
+        sdict["fpdefaults"] = pprint.pformat(fpdefaults, indent=2)
         # A condensed indication on date/cutoff
-        sdict['timeid'] = fpdefaults.get('date', None)
-        if sdict['timeid']:
-            sdict['timeid'] = sdict['timeid'].vortex(cutoff=fpdefaults.get('cutoff', 'X'))
+        sdict["timeid"] = fpdefaults.get("date", None)
+        if sdict["timeid"]:
+            sdict["timeid"] = sdict["timeid"].vortex(
+                cutoff=fpdefaults.get("cutoff", "X")
+            )
         # The generic host/cluster name
-        sdict['host'] = self.sh.default_target.inetname
+        sdict["host"] = self.sh.default_target.inetname
         return sdict