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

vortex/tools/lfi.py

@@ -29,7 +29,7 @@ logger = loggers.getLogger(__name__)
 
 def use_in_shell(sh, **kw):
     """Extend current shell with the LFI interface defined by optional arguments."""
-    kw['shell'] = sh
+    kw["shell"] = sh
     return footprints.proxy.addon(**kw)
 
 
@@ -49,7 +49,9 @@ class LFI_Status:
         self._result = result or list()
 
     def __str__(self):
-        return '{:s} | rc={:d} result={:d}>'.format(repr(self).rstrip('>'), self.rc, len(self.result))
+        return "{:s} | rc={:d} result={:d}>".format(
+            repr(self).rstrip(">"), self.rc, len(self.result)
+        )
 
     @property
     def ok(self):
@@ -107,42 +109,44 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
     Interface to LFI commands through Perl wrappers.
     """
 
-    LFI_HNDL_SPEC = ':1'
+    LFI_HNDL_SPEC = ":1"
     DR_HOOK_SILENT = 1
     DR_HOOK_NOT_MPI = 1
     DR_HOOK_ASSERT_MPI_INITIALIZED = 0
-    OMP_STACKSIZE = '32M'
-    KMP_STACKSIZE = '32M'
-    KMP_MONITOR_STACKSIZE = '32M'
+    OMP_STACKSIZE = "32M"
+    KMP_STACKSIZE = "32M"
+    KMP_MONITOR_STACKSIZE = "32M"
 
     _footprint = dict(
-        info = 'Default LFI system interface (Perl)',
-        attr = dict(
-            kind = dict(
-                values   = ['lfi'],
+        info="Default LFI system interface (Perl)",
+        attr=dict(
+            kind=dict(
+                values=["lfi"],
             ),
-            cmd = dict(
-                alias    = ('lficmd',),
-                default  = 'lfitools',
+            cmd=dict(
+                alias=("lficmd",),
+                default="lfitools",
             ),
-            path = dict(
-                alias    = ('lfipath',),
+            path=dict(
+                alias=("lfipath",),
             ),
-            warnpack = dict(
-                type     = bool,
-                optional = True,
-                default  = False,
+            warnpack=dict(
+                type=bool,
+                optional=True,
+                default=False,
             ),
-            wraplanguage = dict(
-                values   = ['perl', ],
-                default  = 'perl',
-                optional = True,
-                doc_visibility = footprints.doc.visibility.ADVANCED,
+            wraplanguage=dict(
+                values=[
+                    "perl",
+                ],
+                default="perl",
+                optional=True,
+                doc_visibility=footprints.doc.visibility.ADVANCED,
             ),
-            toolkind = dict(
-                default  = 'lfitools',
+            toolkind=dict(
+                default="lfitools",
             ),
-        )
+        ),
     )
 
     def __init__(self, *args, **kw):
@@ -154,7 +158,9 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
     def lfitools_path(self):
         ctxtag = contexts.Context.tag_focus()
         if ctxtag not in self._lfitools_path:
-            self._lfitools_path[ctxtag] = self.sh.path.join(self.actual_path, self.actual_cmd)
+            self._lfitools_path[ctxtag] = self.sh.path.join(
+                self.actual_path, self.actual_cmd
+            )
             self.sh.xperm(self._lfitools_path[ctxtag], force=True)
         return self._lfitools_path[ctxtag]
 
@@ -166,14 +172,20 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
     def _spawn_wrap(self, func, cmd, **kw):
         """Tube to set LFITOOLS env variable."""
         self.env.LFITOOLS = self.lfitools_path
-        return super()._spawn_wrap(['lfi_' + func, ] + cmd, **kw)
+        return super()._spawn_wrap(
+            [
+                "lfi_" + func,
+            ]
+            + cmd,
+            **kw,
+        )
 
     def is_xlfi(self, source):
         """Check if the given ``source`` is a multipart-lfi file."""
         rc = False
         if source and isinstance(source, str) and self.sh.path.exists(source):
-            with open(source, 'rb') as fd:
-                rc = fd.read(8) == b'LFI_ALTM'
+            with open(source, "rb") as fd:
+                rc = fd.read(8) == b"LFI_ALTM"
         return rc
 
     def _std_table(self, lfifile, **kw):
@@ -184,13 +196,13 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
           * lfifile : lfi file name
 
         """
-        cmd = ['lfilist', lfifile]
-        kw['output'] = True
+        cmd = ["lfilist", lfifile]
+        kw["output"] = True
         rawout = self._spawn(cmd, **kw)
         return LFI_Status(
             rc=0,
             stdout=rawout,
-            result=[tuple(eval(x)[0]) for x in rawout if x.startswith('[')]
+            result=[tuple(eval(x)[0]) for x in rawout if x.startswith("[")],
         )
 
     fa_table = lfi_table = _std_table
@@ -208,39 +220,39 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
           * skipfields : LFI fields not to be compared
           * skiplength : Offset at which the comparison starts for each LFI fields
         """
-        cmd = ['lfidiff', '--lfi-file-1', lfi1, '--lfi-file-2', lfi2]
+        cmd = ["lfidiff", "--lfi-file-1", lfi1, "--lfi-file-2", lfi2]
 
-        maxprint = kw.pop('maxprint', 2)
+        maxprint = kw.pop("maxprint", 2)
         if maxprint:
-            cmd.extend(['--max-print-diff', str(maxprint)])
+            cmd.extend(["--max-print-diff", str(maxprint)])
 
-        skipfields = kw.pop('skipfields', 0)
+        skipfields = kw.pop("skipfields", 0)
         if skipfields:
-            cmd.extend(['--lfi-skip-fields', str(skipfields)])
+            cmd.extend(["--lfi-skip-fields", str(skipfields)])
 
-        skiplength = kw.pop('skiplength', 0)
+        skiplength = kw.pop("skiplength", 0)
         if skiplength:
-            cmd.extend(['--lfi-skip-length', str(skiplength)])
+            cmd.extend(["--lfi-skip-length", str(skiplength)])
 
-        kw['output'] = True
+        kw["output"] = True
 
         rawout = self._spawn(cmd, **kw)
-        fields = [tuple(x.split(' ', 2)[-2:]) for x in rawout if re.match(r' (?:\!=|\+\+|\-\-)', x)]
+        fields = [
+            tuple(x.split(" ", 2)[-2:])
+            for x in rawout
+            if re.match(r" (?:\!=|\+\+|\-\-)", x)
+        ]
 
         trfields = Tracker(
-            deleted=[x[1] for x in fields if x[0] == '--'],
-            created=[x[1] for x in fields if x[0] == '++'],
-            updated=[x[1] for x in fields if x[0] == '!='],
+            deleted=[x[1] for x in fields if x[0] == "--"],
+            created=[x[1] for x in fields if x[0] == "++"],
+            updated=[x[1] for x in fields if x[0] == "!="],
         )
 
         stlist = self.lfi_table(lfi1, output=True)
         trfields.unchanged = {x[0] for x in stlist.result} - set(trfields)
 
-        return LFI_Status(
-            rc=int(bool(fields)),
-            stdout=rawout,
-            result=trfields
-        )
+        return LFI_Status(rc=int(bool(fields)), stdout=rawout, result=trfields)
 
     fa_diff = lfi_diff = _std_diff
 
@@ -253,17 +265,29 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
           * fa2 : The new empty file
 
         """
-        cmd = ['faempty', fa1, fa2]
+        cmd = ["faempty", fa1, fa2]
         self._spawn(cmd, **kw)
 
     def _pack_stream(self, source):
-        return self._spawn_wrap('pack', [source, ],
-                                output=False,
-                                inpipe=True,
-                                bufsize=8192)
+        return self._spawn_wrap(
+            "pack",
+            [
+                source,
+            ],
+            output=False,
+            inpipe=True,
+            bufsize=8192,
+        )
 
     def _packed_size(self, source):
-        out = self._spawn_wrap('size', [source, ], output=True, inpipe=False)
+        out = self._spawn_wrap(
+            "size",
+            [
+                source,
+            ],
+            output=True,
+            inpipe=False,
+        )
         try:
             return int(out[0])
         except ValueError:
@@ -273,14 +297,19 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
     def _std_forcepack(self, source, destination=None):
         """Returned a path to a packed data."""
         if self.is_xlfi(source):
-            destination = (destination if destination else
-                           self.sh.safe_fileaddsuffix(source))
+            destination = (
+                destination
+                if destination
+                else self.sh.safe_fileaddsuffix(source)
+            )
             if not self.sh.path.exists(destination):
-                st = self._std_copy(source=source, destination=destination, pack=True)
+                st = self._std_copy(
+                    source=source, destination=destination, pack=True
+                )
                 if st:
                     return destination
                 else:
-                    raise OSError('XLFI packing failed')
+                    raise OSError("XLFI packing failed")
             else:
                 return destination
         else:
@@ -288,8 +317,16 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
 
     fa_forcepack = lfi_forcepack = _std_forcepack
 
-    def _std_ftput(self, source, destination, hostname=None, logname=None,
-                   port=DEFAULT_FTP_PORT, cpipeline=None, sync=False):
+    def _std_ftput(
+        self,
+        source,
+        destination,
+        hostname=None,
+        logname=None,
+        port=DEFAULT_FTP_PORT,
+        cpipeline=None,
+        sync=False,
+    ):
         """On the fly packing and ftp."""
         if self.is_xlfi(source):
             if cpipeline is not None:
@@ -301,64 +338,100 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
             if ftp:
                 packed_size = self._packed_size(source)
                 p = self._pack_stream(source)
-                st.rc = ftp.put(p.stdout, destination, size=packed_size, exact=True)
+                st.rc = ftp.put(
+                    p.stdout, destination, size=packed_size, exact=True
+                )
                 self.sh.pclose(p)
                 st.result = [destination]
                 st.stdout = [
-                    'Connection time   : {:f}'.format(ftp.length),
-                    'Packed source size: {:d}'.format(packed_size),
-                    'Actual target size: {:d}'.format(ftp.size(destination))
+                    "Connection time   : {:f}".format(ftp.length),
+                    "Packed source size: {:d}".format(packed_size),
+                    "Actual target size: {:d}".format(ftp.size(destination)),
                 ]
                 ftp.close()
             else:
                 st.rc = 1
-                st.result = ['Could not connect to ' + hostname + ' as user ' + logname]
+                st.result = [
+                    "Could not connect to " + hostname + " as user " + logname
+                ]
             return st
         else:
-            return self.sh.ftput(source, destination, hostname=hostname,
-                                 logname=logname, cpipeline=cpipeline,
-                                 port=port, sync=sync)
+            return self.sh.ftput(
+                source,
+                destination,
+                hostname=hostname,
+                logname=logname,
+                cpipeline=cpipeline,
+                port=port,
+                sync=sync,
+            )
 
-    def _std_rawftput(self, source, destination, hostname=None, logname=None,
-                      port=None, cpipeline=None, sync=False):
+    def _std_rawftput(
+        self,
+        source,
+        destination,
+        hostname=None,
+        logname=None,
+        port=None,
+        cpipeline=None,
+        sync=False,
+    ):
         """Use ftserv as much as possible."""
         if self.is_xlfi(source):
             if cpipeline is not None:
                 raise OSError("It's not allowed to compress xlfi files.")
             if self.sh.ftraw and self.rawftshell is not None:
-                newsource = self.sh.copy2ftspool(source, fmt='lfi')
-                rc = self.sh.ftserv_put(newsource, destination,
-                                        hostname=hostname, logname=logname, port=port,
-                                        specialshell=self.rawftshell, sync=sync)
+                newsource = self.sh.copy2ftspool(source, fmt="lfi")
+                rc = self.sh.ftserv_put(
+                    newsource,
+                    destination,
+                    hostname=hostname,
+                    logname=logname,
+                    port=port,
+                    specialshell=self.rawftshell,
+                    sync=sync,
+                )
                 self.sh.rm(newsource)  # Delete the request file
                 return rc
             else:
                 if port is None:
                     port = DEFAULT_FTP_PORT
-                return self._std_ftput(source, destination, hostname, logname,
-                                       port=port, sync=sync)
+                return self._std_ftput(
+                    source,
+                    destination,
+                    hostname,
+                    logname,
+                    port=port,
+                    sync=sync,
+                )
         else:
-            return self.sh.rawftput(source, destination, hostname=hostname,
-                                    logname=logname, port=port,
-                                    cpipeline=cpipeline, sync=sync)
+            return self.sh.rawftput(
+                source,
+                destination,
+                hostname=hostname,
+                logname=logname,
+                port=port,
+                cpipeline=cpipeline,
+                sync=sync,
+            )
 
     fa_ftput = lfi_ftput = _std_ftput
     fa_rawftput = lfi_rawftput = _std_rawftput
 
-    def _std_prepare(self, source, destination, intent='in'):
+    def _std_prepare(self, source, destination, intent="in"):
         """Check for the source and prepare the destination."""
-        if intent not in ('in', 'inout'):
-            raise ValueError('Incorrect value for intent ({})'.format(intent))
+        if intent not in ("in", "inout"):
+            raise ValueError("Incorrect value for intent ({})".format(intent))
         st = LFI_Status()
         if not self.sh.path.exists(source):
-            logger.error('Missing source %s', source)
+            logger.error("Missing source %s", source)
             st.rc = 2
-            st.stderr = 'No such source file or directory : [' + source + ']'
+            st.stderr = "No such source file or directory : [" + source + "]"
             return st
         if not self.sh.filecocoon(destination):
-            raise OSError('Could not cocoon [' + destination + ']')
+            raise OSError("Could not cocoon [" + destination + "]")
         if not self.lfi_rm(destination):
-            raise OSError('Could not clean destination [' + destination + ']')
+            raise OSError("Could not clean destination [" + destination + "]")
         return st
 
     def _std_remove(self, *args):
@@ -366,16 +439,30 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
         st = LFI_Status(result=list())
         for pname in args:
             for objpath in self.sh.glob(pname):
-                rc = self._spawn_wrap('remove', [objpath, ], output=False)
-                st.result.append(dict(path=objpath,
-                                      multi=self.is_xlfi(objpath), rc=rc))
+                rc = self._spawn_wrap(
+                    "remove",
+                    [
+                        objpath,
+                    ],
+                    output=False,
+                )
+                st.result.append(
+                    dict(path=objpath, multi=self.is_xlfi(objpath), rc=rc)
+                )
                 st.rc = rc
         return st
 
     lfi_rm = lfi_remove = fa_rm = fa_remove = _std_remove
 
-    def _std_copy(self, source, destination,
-                  smartcp_threshold=0, intent='in', pack=False, silent=False):
+    def _std_copy(
+        self,
+        source,
+        destination,
+        smartcp_threshold=0,
+        intent="in",
+        pack=False,
+        silent=False,
+    ):
         """Extended copy for (possibly) multi lfi file."""
         st = self._std_prepare(source, destination, intent)
         if st.rc == 0:
@@ -385,23 +472,48 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
             actual_intent = intent
             if ln_cross_users and not self.sh.allow_cross_users_links:
                 actual_pack = True
-                actual_intent = 'inout'
+                actual_intent = "inout"
             try:
-                st.rc = self._spawn_wrap('copy', (['-pack', ] if actual_pack else []) +
-                                         ['-intent={}'.format(actual_intent), source, destination],
-                                         output=False)
+                st.rc = self._spawn_wrap(
+                    "copy",
+                    (
+                        [
+                            "-pack",
+                        ]
+                        if actual_pack
+                        else []
+                    )
+                    + [
+                        "-intent={}".format(actual_intent),
+                        source,
+                        destination,
+                    ],
+                    output=False,
+                )
             except systems.ExecutionError:
                 if self.sh.allow_cross_users_links and ln_cross_users:
                     # This is expected to fail if the fs.protected_hardlinks
                     # Linux kernel setting is 1.
-                    logger.info("Force System's allow_cross_users_links to False")
+                    logger.info(
+                        "Force System's allow_cross_users_links to False"
+                    )
                     self.sh.allow_cross_users_links = False
                     logger.info("Re-running the cp command on this LFI file")
-                    st = self._std_copy(source, destination, intent=intent, pack=pack, silent=silent)
+                    st = self._std_copy(
+                        source,
+                        destination,
+                        intent=intent,
+                        pack=pack,
+                        silent=silent,
+                    )
                 else:
                     raise
             else:
-                if ln_cross_users and not self.sh.allow_cross_users_links and intent == 'in':
+                if (
+                    ln_cross_users
+                    and not self.sh.allow_cross_users_links
+                    and intent == "in"
+                ):
                     self.sh.readonly(destination)
         return st
 
@@ -411,12 +523,23 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
         """Extended mv for (possibly) multi lfi file."""
         if self.is_xlfi(source):
             if intent is None:
-                intent = 'inout' if self.sh.access(source, self.sh.W_OK) else 'in'
+                intent = (
+                    "inout" if self.sh.access(source, self.sh.W_OK) else "in"
+                )
             st = self._std_prepare(source, destination, intent)
             if st.rc == 0:
-                st.rc = self._spawn_wrap('move', (['-pack', ] if pack else []) +
-                                         ['-intent={}'.format(intent), source, destination],
-                                         output=False)
+                st.rc = self._spawn_wrap(
+                    "move",
+                    (
+                        [
+                            "-pack",
+                        ]
+                        if pack
+                        else []
+                    )
+                    + ["-intent={}".format(intent), source, destination],
+                    output=False,
+                )
         else:
             st = LFI_Status()
             st.rc = self.sh.mv(source, destination)
@@ -424,27 +547,35 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
 
     lfi_mv = lfi_move = fa_mv = fa_move = _std_move
 
-    def _std_scpput(self, source, destination, hostname, logname=None, cpipeline=None):
+    def _std_scpput(
+        self, source, destination, hostname, logname=None, cpipeline=None
+    ):
         """On the fly packing and scp."""
         if not self.is_xlfi(source):
-            rc = self.sh.scpput(source, destination, hostname, logname, cpipeline)
+            rc = self.sh.scpput(
+                source, destination, hostname, logname, cpipeline
+            )
         else:
             if cpipeline is not None:
                 raise OSError("It's not allowed to compress xlfi files.")
-            logname = self.sh.fix_ftuser(hostname, logname, fatal=False, defaults_to_user=False)
+            logname = self.sh.fix_ftuser(
+                hostname, logname, fatal=False, defaults_to_user=False
+            )
             ssh = self.sh.ssh(hostname, logname)
             permissions = ssh.get_permissions(source)
             # remove the .d companion directory (scp_stream removes the destination)
             # go on on failure : the .d lingers on, but the lfi will be self-contained
-            ssh.remove(destination + '.d')
+            ssh.remove(destination + ".d")
             p = self._pack_stream(source)
-            rc = ssh.scpput_stream(p.stdout, destination, permissions=permissions)
+            rc = ssh.scpput_stream(
+                p.stdout, destination, permissions=permissions
+            )
             self.sh.pclose(p)
         return rc
 
     fa_scpput = lfi_scpput = _std_scpput
 
-    @addons.require_external_addon('ecfs')
+    @addons.require_external_addon("ecfs")
     def _std_ecfsput(self, source, target, cpipeline=None, options=None):
         """
         :param source: source file
@@ -459,29 +590,38 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
             psource = self.sh.safe_fileaddsuffix(source)
             rc = LFI_Status()
             try:
-                st = self._std_copy(source=source,
-                                    destination=psource,
-                                    pack=True)
+                st = self._std_copy(
+                    source=source, destination=psource, pack=True
+                )
                 rc = rc and st.rc
                 dict_args = dict()
                 if rc:
-                    rc, dict_args = self.sh.ecfsput(source=psource,
-                                                    target=target,
-                                                    options=options)
+                    rc, dict_args = self.sh.ecfsput(
+                        source=psource, target=target, options=options
+                    )
             finally:
                 self.sh.rm(psource)
             return rc, dict_args
         else:
-            return self.sh.ecfsput(source=source,
-                                   target=target,
-                                   options=options,
-                                   cpipeline=cpipeline)
+            return self.sh.ecfsput(
+                source=source,
+                target=target,
+                options=options,
+                cpipeline=cpipeline,
+            )
 
     fa_ecfsput = lfi_ecfsput = _std_ecfsput
 
-    @addons.require_external_addon('ectrans')
-    def _std_ectransput(self, source, target, gateway=None, remote=None,
-                        cpipeline=None, sync=False):
+    @addons.require_external_addon("ectrans")
+    def _std_ectransput(
+        self,
+        source,
+        target,
+        gateway=None,
+        remote=None,
+        cpipeline=None,
+        sync=False,
+    ):
         """
         :param source: source file
         :param target: target file
@@ -497,27 +637,31 @@ class LFI_Tool_Raw(addons.FtrawEnableAddon):
             psource = self.sh.safe_fileaddsuffix(source)
             rc = LFI_Status()
             try:
-                st = self._std_copy(source=source,
-                                    destination=psource,
-                                    pack=True)
+                st = self._std_copy(
+                    source=source, destination=psource, pack=True
+                )
                 rc = rc and st.rc
                 dict_args = dict()
                 if rc:
-                    rc, dict_args = self.sh.raw_ectransput(source=psource,
-                                                           target=target,
-                                                           gateway=gateway,
-                                                           remote=remote,
-                                                           sync=sync)
+                    rc, dict_args = self.sh.raw_ectransput(
+                        source=psource,
+                        target=target,
+                        gateway=gateway,
+                        remote=remote,
+                        sync=sync,
+                    )
             finally:
                 self.sh.rm(psource)
             return rc, dict_args
         else:
-            return self.sh.ectransput(source=source,
-                                      target=target,
-                                      gateway=gateway,
-                                      remote=remote,
-                                      cpipeline=cpipeline,
-                                      sync=sync)
+            return self.sh.ectransput(
+                source=source,
+                target=target,
+                gateway=gateway,
+                remote=remote,
+                cpipeline=cpipeline,
+                sync=sync,
+            )
 
     fa_ectransput = lfi_ectransput = _std_ectransput
 
@@ -530,20 +674,23 @@ class LFI_Tool_Py(LFI_Tool_Raw):
     """
 
     _footprint = dict(
-        info = 'Default LFI system interface (Python)',
-        attr = dict(
-            wraplanguage = dict(
-                values   = ['python', ],
+        info="Default LFI system interface (Python)",
+        attr=dict(
+            wraplanguage=dict(
+                values=[
+                    "python",
+                ],
             ),
-        )
+        ),
     )
 
     def _pack_stream(self, source):
-        return self._spawn(['lfi_alt_pack', '--lfi-file-in', source,
-                            '--lfi-file-out', '-'],
-                           output=False,
-                           inpipe=True,
-                           bufsize=8192)
+        return self._spawn(
+            ["lfi_alt_pack", "--lfi-file-in", source, "--lfi-file-out", "-"],
+            output=False,
+            inpipe=True,
+            bufsize=8192,
+        )
 
     def _std_remove(self, *args):
         """Remove (possibly) multi lfi files."""
@@ -552,12 +699,14 @@ class LFI_Tool_Py(LFI_Tool_Raw):
             for objpath in self.sh.glob(pname):
                 xlfi = self.is_xlfi(objpath)
                 if xlfi:
-                    rc = self._spawn(['lfi_alt_remv', '--lfi-file', objpath], output=False)
+                    rc = self._spawn(
+                        ["lfi_alt_remv", "--lfi-file", objpath], output=False
+                    )
                 else:
                     rc = self.sh.remove(objpath)
                 st.result.append(dict(path=objpath, multi=xlfi, rc=rc))
                 st.rc = rc
-            for dirpath in self.sh.glob(pname + '.d'):
+            for dirpath in self.sh.glob(pname + ".d"):
                 if self.sh.path.exists(dirpath):
                     rc = self.sh.remove(dirpath)
                     st.result.append(dict(path=dirpath, multi=True, rc=rc))
@@ -568,29 +717,61 @@ class LFI_Tool_Py(LFI_Tool_Raw):
 
     def _cp_pack_read(self, source, destination):
         if self.warnpack:
-            logger.warning('Suspicious packing <%s>', source)
-        rc = self._spawn(['lfi_alt_pack', '--lfi-file-in', source, '--lfi-file-out', destination],
-                         output=False)
+            logger.warning("Suspicious packing <%s>", source)
+        rc = self._spawn(
+            [
+                "lfi_alt_pack",
+                "--lfi-file-in",
+                source,
+                "--lfi-file-out",
+                destination,
+            ],
+            output=False,
+        )
         self.sh.chmod(destination, 0o444)
         return rc
 
     def _cp_pack_write(self, source, destination):
         if self.warnpack:
-            logger.warning('Suspicious packing <%s>', source)
-        rc = self._spawn(['lfi_alt_pack', '--lfi-file-in', source, '--lfi-file-out', destination],
-                         output=False)
+            logger.warning("Suspicious packing <%s>", source)
+        rc = self._spawn(
+            [
+                "lfi_alt_pack",
+                "--lfi-file-in",
+                source,
+                "--lfi-file-out",
+                destination,
+            ],
+            output=False,
+        )
         self.sh.chmod(destination, 0o644)
         return rc
 
     def _cp_copy_read(self, source, destination):
-        rc = self._spawn(['lfi_alt_copy', '--lfi-file-in', source, '--lfi-file-out', destination],
-                         output=False)
+        rc = self._spawn(
+            [
+                "lfi_alt_copy",
+                "--lfi-file-in",
+                source,
+                "--lfi-file-out",
+                destination,
+            ],
+            output=False,
+        )
         self.sh.chmod(destination, 0o444)
         return rc
 
     def _cp_copy_write(self, source, destination):
-        rc = self._spawn(['lfi_alt_copy', '--lfi-file-in', source, '--lfi-file-out', destination],
-                         output=False)
+        rc = self._spawn(
+            [
+                "lfi_alt_copy",
+                "--lfi-file-in",
+                source,
+                "--lfi-file-out",
+                destination,
+            ],
+            output=False,
+        )
         self.sh.chmod(destination, 0o644)
         return rc
 
@@ -604,38 +785,55 @@ class LFI_Tool_Py(LFI_Tool_Raw):
     _cp_nopack_fsko_read = _cp_pack_read
     _cp_nopack_fsko_write = _cp_pack_write
 
-    def _multicpmethod(self, pack=False, intent='in', samefs=False):
-        return '_cp_{:s}_{:s}_{:s}'.format(
-            'aspack' if pack else 'nopack',
-            'fsok' if samefs else 'fsko',
-            'read' if intent == 'in' else 'write',
+    def _multicpmethod(self, pack=False, intent="in", samefs=False):
+        return "_cp_{:s}_{:s}_{:s}".format(
+            "aspack" if pack else "nopack",
+            "fsok" if samefs else "fsko",
+            "read" if intent == "in" else "write",
         )
 
-    def _std_copy(self, source, destination,
-                  smartcp_threshold=0, intent='in', pack=False, silent=False):
+    def _std_copy(
+        self,
+        source,
+        destination,
+        smartcp_threshold=0,
+        intent="in",
+        pack=False,
+        silent=False,
+    ):
         """Extended copy for (possibly) multi lfi file."""
         st = LFI_Status()
         if not self.sh.path.exists(source):
-            logger.error('Missing source %s', source)
+            logger.error("Missing source %s", source)
             st.rc = 2
-            st.stderr = 'No such source file or directory : [' + source + ']'
+            st.stderr = "No such source file or directory : [" + source + "]"
             return st
         if self.is_xlfi(source):
             if not self.sh.filecocoon(destination):
-                raise OSError('Could not cocoon [' + destination + ']')
+                raise OSError("Could not cocoon [" + destination + "]")
             if not self.lfi_rm(destination):
-                raise OSError('Could not clean destination [' + destination + ']')
-            xcp = self._multicpmethod(pack=pack, intent=intent, samefs=self.sh.is_samefs(source, destination))
+                raise OSError(
+                    "Could not clean destination [" + destination + "]"
+                )
+            xcp = self._multicpmethod(
+                pack=pack,
+                intent=intent,
+                samefs=self.sh.is_samefs(source, destination),
+            )
             actualcp = getattr(self, xcp, None)
             if actualcp is None:
-                raise AttributeError('No actual LFI cp command ' + xcp)
+                raise AttributeError("No actual LFI cp command " + xcp)
             else:
                 st.rc = actualcp(source, self.sh.path.realpath(destination))
         else:
-            if intent == 'in':
-                st.rc = self.sh.smartcp(source, destination, smartcp_threshold=smartcp_threshold)
+            if intent == "in":
+                st.rc = self.sh.smartcp(
+                    source, destination, smartcp_threshold=smartcp_threshold
+                )
             else:
-                st.rc = self.sh.cp(source, destination, smartcp_threshold=smartcp_threshold)
+                st.rc = self.sh.cp(
+                    source, destination, smartcp_threshold=smartcp_threshold
+                )
         return st
 
     lfi_cp = lfi_copy = fa_cp = fa_copy = _std_copy
@@ -644,7 +842,9 @@ class LFI_Tool_Py(LFI_Tool_Raw):
         """Extended mv for (possibly) multi lfi file."""
         if self.is_xlfi(source):
             if intent is None:
-                intent = 'inout' if self.sh.access(source, self.sh.W_OK) else 'in'
+                intent = (
+                    "inout" if self.sh.access(source, self.sh.W_OK) else "in"
+                )
             st = self.lfi_cp(source, destination, intent=intent, pack=pack)
             if st:
                 st = self.lfi_rm(source)
@@ -662,72 +862,79 @@ class IO_Poll(addons.Addon):
     This addon is in charge of multi-file reshaping after IFS-ARPEGE execution.
     """
 
-    LFI_HNDL_SPEC = ':1'
+    LFI_HNDL_SPEC = ":1"
     DR_HOOK_SILENT = 1
     DR_HOOK_NOT_MPI = 1
     DR_HOOK_ASSERT_MPI_INITIALIZED = 0
-    OMP_STACKSIZE = '32M'
-    KMP_STACKSIZE = '32M'
-    KMP_MONITOR_STACKSIZE = '32M'
+    OMP_STACKSIZE = "32M"
+    KMP_STACKSIZE = "32M"
+    KMP_MONITOR_STACKSIZE = "32M"
 
     _footprint = dict(
-        info = 'Default io_poll system interface',
-        attr = dict(
-            kind = dict(
-                values  = ['iopoll', 'io_poll'],
-                remap   = dict(
-                    io_poll = 'iopoll',
-                )
+        info="Default io_poll system interface",
+        attr=dict(
+            kind=dict(
+                values=["iopoll", "io_poll"],
+                remap=dict(
+                    io_poll="iopoll",
+                ),
             ),
-            cfginfo = dict(
-                default = 'lfi',
+            cfginfo=dict(
+                default="lfi",
             ),
-            cmd = dict(
-                alias   = ('iopollcmd', 'io_pollcmd', 'io_poll_cmd'),
-                default = 'io_poll',
+            cmd=dict(
+                alias=("iopollcmd", "io_pollcmd", "io_poll_cmd"),
+                default="io_poll",
             ),
-            path = dict(
-                alias   = ('iopollpath', 'io_pollpath', 'io_poll_path', 'iopath'),
+            path=dict(
+                alias=("iopollpath", "io_pollpath", "io_poll_path", "iopath"),
             ),
-            interpreter = dict(
-                values  = ['perl', 'none', 'None'],
-                remap   = dict({'None': 'none', }),
-                default = 'perl',
-                optional = True,
+            interpreter=dict(
+                values=["perl", "none", "None"],
+                remap=dict(
+                    {
+                        "None": "none",
+                    }
+                ),
+                default="perl",
+                optional=True,
             ),
-            toolkind = dict(
-                default = 'iopoll'
-            )
-        )
+            toolkind=dict(default="iopoll"),
+        ),
     )
 
     def __init__(self, *args, **kw):
         """Abstract Addon initialisation."""
-        logger.debug('IO_Poll init %s', self.__class__)
+        logger.debug("IO_Poll init %s", self.__class__)
         super().__init__(*args, **kw)
         self._polled = set()
 
     def _spawn(self, cmd, **kw):
         """Tube to set LFITOOLS env variable."""
-        if 'LFITOOLS' not in self.env:
-            active_lfi = (LFI_Tool_Raw.in_shell(self.sh) or
-                          LFI_Tool_Py.in_shell(self.sh))
+        if "LFITOOLS" not in self.env:
+            active_lfi = LFI_Tool_Raw.in_shell(
+                self.sh
+            ) or LFI_Tool_Py.in_shell(self.sh)
             if active_lfi is None:
-                raise RuntimeError('Could not find any active LFI Tool')
-            self.env.LFITOOLS = active_lfi.actual_path + '/' + active_lfi.actual_cmd
+                raise RuntimeError("Could not find any active LFI Tool")
+            self.env.LFITOOLS = (
+                active_lfi.actual_path + "/" + active_lfi.actual_cmd
+            )
         # Is there a need for an interpreter ?
-        if self.interpreter != 'none':
-            kw['interpreter'] = self.interpreter
+        if self.interpreter != "none":
+            kw["interpreter"] = self.interpreter
         return super()._spawn(cmd, **kw)
 
     def io_poll(self, prefix, nproc_io=None):
         """Do the actual job of polling files prefixed by ``prefix``."""
-        cmd = ['--prefix', prefix]
+        cmd = ["--prefix", prefix]
         if nproc_io is None:
-            if not self.sh.path.exists('fort.4'):
-                raise OSError('The proc_io option or a fort.4 file should be provided.')
+            if not self.sh.path.exists("fort.4"):
+                raise OSError(
+                    "The proc_io option or a fort.4 file should be provided."
+                )
         else:
-            cmd.extend(['--nproc_io', str(nproc_io)])
+            cmd.extend(["--nproc_io", str(nproc_io)])
 
         # Catch the file processed
         rawout = self._spawn(cmd)