vortex-nwp 2.0.0b1__py3-none-any.whl → 2.1.0__py3-none-any.whl

vortex/toolbox.py

@@ -16,18 +16,24 @@ from bronx.syntax import mktuple
 
 import footprints
 
-from vortex import sessions, data, proxy, VortexForceComplete
+from vortex import sessions, data, proxy
 from vortex.layout.dataflow import stripargs_section, intent, ixo, Section
 
 #: Automatic export of superstar interface.
-__all__ = ['rload', 'rget', 'rput']
+__all__ = ["rload", "rget", "rput"]
 
 logger = loggers.getLogger(__name__)
 
 #: Shortcut to footprint env defaults
 defaults = footprints.setup.defaults
 
-sectionmap = {'input': 'get', 'output': 'put', 'executable': 'get'}
+sectionmap = {"input": "get", "output": "put", "executable": "get"}
+
+
+class VortexForceComplete(Exception):
+    """Exception for handling fast exit mecanisms."""
+
+    pass
 
 
 # Toolbox defaults
@@ -55,34 +61,44 @@ active_incache = False
 active_batchinputs = True
 
 #: History recording
-history = History(tag='rload')
+history = History(tag="rload")
 
 
 # Most commonly used functions
 
+
 def show_toolbox_settings(ljust=24):
     """Print the current settings of the toolbox."""
-    for key in ['active_{}'.format(act) for act in
-                ('now', 'insitu', 'verbose', 'promise', 'clear',
-                 'metadatacheck', 'incache')]:
+    for key in [
+        "active_{}".format(act)
+        for act in (
+            "now",
+            "insitu",
+            "verbose",
+            "promise",
+            "clear",
+            "metadatacheck",
+            "incache",
+        )
+    ]:
         kval = globals().get(key, None)
         if kval is not None:
-            print('+', key.ljust(ljust), '=', kval)
+            print("+", key.ljust(ljust), "=", kval)
 
 
 def quickview(args, nb=0, indent=0):
     """Recursive call to any quick view of objects specified as arguments."""
     if not isinstance(args, list) and not isinstance(args, tuple):
-        args = (args, )
+        args = (args,)
     for x in args:
         if nb:
             print()
         nb += 1
-        quickview = getattr(x, 'quickview', None)
+        quickview = getattr(x, "quickview", None)
         if quickview:
             quickview(nb, indent)
         else:
-            print('{:02d}. {:s}'.format(nb, x))
+            print("{:02d}. {:s}".format(nb, x))
 
 
 class VortexToolboxDescError(Exception):
@@ -118,18 +134,18 @@ def rload(*args, **kw):
         if isinstance(a, dict):
             rd.update(a)
         else:
-            logger.warning('Discard rload argument <%s>', a)
+            logger.warning("Discard rload argument <%s>", a)
     rd.update(kw)
     if rd:
         history.append(rd.copy())
     rhx = []
     for x in footprints.util.expand(rd):
         picked_up = proxy.containers.pickup(  # @UndefinedVariable
-            * proxy.providers.pickup_and_cache(  # @UndefinedVariable
-                * proxy.resources.pickup_and_cache(x)  # @UndefinedVariable
+            *proxy.providers.pickup_and_cache(  # @UndefinedVariable
+                *proxy.resources.pickup_and_cache(x)  # @UndefinedVariable
             )
         )
-        logger.debug('Resource desc %s', picked_up)
+        logger.debug("Resource desc %s", picked_up)
         picked_rh = data.handlers.Handler(picked_up)
         if not picked_rh.complete:
             raise VortexToolboxDescError("The ResourceHandler is incomplete")
@@ -151,7 +167,7 @@ def rget(*args, **kw):
     This function calls the :meth:`get` method on any resource handler returned
     by the :func:`rload` function.
     """
-    loc_incache = kw.pop('incache', active_incache)
+    loc_incache = kw.pop("incache", active_incache)
     rl = rload(*args, **kw)
     for rh in rl:
         rh.get(incache=loc_incache)
@@ -163,7 +179,7 @@ def rput(*args, **kw):
     This function calls the :meth:`put` method on any resource handler returned
     by the :func:`rload` function.
     """
-    loc_incache = kw.pop('incache', active_incache)
+    loc_incache = kw.pop("incache", active_incache)
     rl = rload(*args, **kw)
     for rh in rl:
         rh.put(incache=loc_incache)
@@ -172,9 +188,9 @@ def rput(*args, **kw):
 
 def nicedump(msg, **kw):
     """Simple dump the **kw** dict content with ``msg`` as header."""
-    print('#', msg, ':')
+    print("#", msg, ":")
     for k, v in sorted(kw.items()):
-        print('+', k.ljust(12), '=', str(v))
+        print("+", k.ljust(12), "=", str(v))
     print()
 
 
@@ -238,32 +254,33 @@ def add_section(section, args, kw):
     t = sessions.current()
 
     # First, retrieve arguments of the toolbox command itself
-    now = kw.pop('now', active_now)
-    loglevel = kw.pop('loglevel', None)
-    talkative = kw.pop('verbose', active_verbose)
-    complete = kw.pop('complete', False)
-    insitu = kw.get('insitu', False)
-    batch = kw.pop('batch', False)
-    lastfatal = kw.pop('lastfatal', None)
+    now = kw.pop("now", active_now)
+    loglevel = kw.pop("loglevel", None)
+    talkative = kw.pop("verbose", active_verbose)
+    complete = kw.pop("complete", False)
+    insitu = kw.get("insitu", False)
+    batch = kw.pop("batch", False)
+    lastfatal = kw.pop("lastfatal", None)
 
     if complete:
-        kw['fatal'] = False
+        kw["fatal"] = False
 
     if batch:
-        if section not in ('input', 'excutable'):
-            logger.info("batch=True is not implemented for section=%s. overwriting to batch=Fase.",
-                        section)
+        if section not in ("input", "excutable"):
+            logger.info(
+                "batch=True is not implemented for section=%s. overwriting to batch=Fase.",
+                section,
+            )
             batch = False
 
     # Second, retrieve arguments that could be used by the now command
     cmdopts = dict(
-        incache=kw.pop('incache', active_incache),
-        force=kw.pop('force', False)
+        incache=kw.pop("incache", active_incache), force=kw.pop("force", False)
     )
 
     # Third, collect arguments for triggering some hook
     hooks = dict()
-    for ahook in [x for x in kw.keys() if x.startswith('hook_')]:
+    for ahook in [x for x in kw.keys() if x.startswith("hook_")]:
         cbhook = mktuple(kw.pop(ahook))
         cbfunc = cbhook[0]
         if not callable(cbfunc):
@@ -272,29 +289,30 @@ def add_section(section, args, kw):
 
     # Print the user inputs
     def print_user_inputs():
-        nicedump('New {:s} section with options'.format(section), **opts)
-        nicedump('Resource handler description', **kwclean)
+        nicedump("New {:s} section with options".format(section), **opts)
+        nicedump("Resource handler description", **kwclean)
         nicedump(
-            'This command options',
+            "This command options",
             complete=complete,
             loglevel=loglevel,
             now=now,
             verbose=talkative,
         )
         if hooks:
-            nicedump('Hooks triggered', **hooks)
+            nicedump("Hooks triggered", **hooks)
 
     with _tb_isolate(t, loglevel):
-
         # Distinguish between section arguments, and resource loader arguments
         opts, kwclean = stripargs_section(**kw)
 
         # Strip the metadatacheck option depending on active_metadatacheck
         if not active_metadatacheck and not insitu:
-            if kwclean.get('metadatacheck', False):
-                logger.info("The metadatacheck option is forced to False since " +
-                            "active_metadatacheck=False.")
-                kwclean['metadatacheck'] = False
+            if kwclean.get("metadatacheck", False):
+                logger.info(
+                    "The metadatacheck option is forced to False since "
+                    + "active_metadatacheck=False."
+                )
+                kwclean["metadatacheck"] = False
 
         # Show the actual set of arguments
         if talkative and not insitu:
@@ -311,23 +329,32 @@ def add_section(section, args, kw):
 
         # Create a section for each resource handler
         if rl and lastfatal is not None:
-            newsections = [push(rh=rhandler, **opts)[0] for rhandler in rl[:-1]]
+            newsections = [
+                push(rh=rhandler, **opts)[0] for rhandler in rl[:-1]
+            ]
             tmpopts = opts.copy()
-            tmpopts['fatal'] = lastfatal
+            tmpopts["fatal"] = lastfatal
             newsections.append(push(rh=rl[-1], **tmpopts)[0])
         else:
             newsections = [push(rh=rhandler, **opts)[0] for rhandler in rl]
 
         # If insitu and now, try a quiet get...
-        do_quick_insitu = section in ('input', 'executable') and insitu and now
+        do_quick_insitu = section in ("input", "executable") and insitu and now
         if do_quick_insitu:
-            quickget = [sec.rh.insitu_quickget(alternate=sec.alternate, **cmdopts) for sec in newsections]
+            quickget = [
+                sec.rh.insitu_quickget(alternate=sec.alternate, **cmdopts)
+                for sec in newsections
+            ]
             if all(quickget):
                 if len(quickget) > 1:
-                    logger.info("The insitu get succeeded for all of the %d resource handlers.",
-                                len(rl))
+                    logger.info(
+                        "The insitu get succeeded for all of the %d resource handlers.",
+                        len(rl),
+                    )
                 else:
-                    logger.info("The insitu get succeeded for this resource handler.")
+                    logger.info(
+                        "The insitu get succeeded for this resource handler."
+                    )
                 rlok = [sec.rh for sec in newsections]
             else:
                 # Start again with the usual get sequence
@@ -338,64 +365,118 @@ def add_section(section, args, kw):
             if now:
                 with t.sh.ftppool():
                     # Create a section for each resource handler, and perform action on demand
-                    batchflags = [None, ] * len(newsections)
+                    batchflags = [
+                        None,
+                    ] * len(newsections)
                     if batch:
                         if talkative:
-                            t.sh.subtitle('Early-{:s} for all resources.'.format(doitmethod))
+                            t.sh.subtitle(
+                                "Early-{:s} for all resources.".format(
+                                    doitmethod
+                                )
+                            )
                         for ir, newsection in enumerate(newsections):
                             rhandler = newsection.rh
-                            batchflags[ir] = getattr(newsection, 'early' + doitmethod)(**cmdopts)
+                            batchflags[ir] = getattr(
+                                newsection, "early" + doitmethod
+                            )(**cmdopts)
                         if talkative:
                             if any(batchflags):
                                 for ir, newsection in enumerate(newsections):
                                     if talkative and batchflags[ir]:
-                                        logger.info('Resource no %02d/%02d: Early-%s registered with id: %s.',
-                                                    ir + 1, len(rl), doitmethod, str(batchflags[ir]))
+                                        logger.info(
+                                            "Resource no %02d/%02d: Early-%s registered with id: %s.",
+                                            ir + 1,
+                                            len(rl),
+                                            doitmethod,
+                                            str(batchflags[ir]),
+                                        )
                                     else:
-                                        logger.debug('Resource no %02d/%02d: Early-%s registered with id: %s.',
-                                                     ir + 1, len(rl), doitmethod, str(batchflags[ir]))
+                                        logger.debug(
+                                            "Resource no %02d/%02d: Early-%s registered with id: %s.",
+                                            ir + 1,
+                                            len(rl),
+                                            doitmethod,
+                                            str(batchflags[ir]),
+                                        )
                             else:
-                                logger.info('Early-%s was unavailable for all of the resources.',
-                                            doitmethod)
+                                logger.info(
+                                    "Early-%s was unavailable for all of the resources.",
+                                    doitmethod,
+                                )
                         # trigger finalise for all of the DelayedActions
-                        tofinalise = [r_id for r_id in batchflags if r_id and r_id is not True]
+                        tofinalise = [
+                            r_id
+                            for r_id in batchflags
+                            if r_id and r_id is not True
+                        ]
                         if tofinalise:
                             if talkative:
-                                t.sh.subtitle('Finalising all of the delayed actions...')
-                            t.context.delayedactions_hub.finalise(* tofinalise)
+                                t.sh.subtitle(
+                                    "Finalising all of the delayed actions..."
+                                )
+                            t.context.delayedactions_hub.finalise(*tofinalise)
                     secok = list()
                     for ir, newsection in enumerate(newsections):
                         rhandler = newsection.rh
                         # If quick get was ok for this resource don't call get again...
                         if talkative:
-                            t.sh.subtitle('Resource no {:02d}/{:02d}'.format(ir + 1, len(rl)))
+                            t.sh.subtitle(
+                                "Resource no {:02d}/{:02d}".format(
+                                    ir + 1, len(rl)
+                                )
+                            )
                             rhandler.quickview(nb=ir + 1, indent=0)
-                            if batchflags[ir] is not True or (do_quick_insitu and quickget[ir]):
-                                t.sh.highlight('Action {:s} on {:s}'.format(doitmethod.upper(),
-                                                                            rhandler.location(fatal=False)))
+                            if batchflags[ir] is not True or (
+                                do_quick_insitu and quickget[ir]
+                            ):
+                                t.sh.highlight(
+                                    "Action {:s} on {:s}".format(
+                                        doitmethod.upper(),
+                                        rhandler.location(fatal=False),
+                                    )
+                                )
                         ok = do_quick_insitu and quickget[ir]
                         if batchflags[ir]:
-                            actual_doitmethod = 'finalise' + doitmethod
+                            actual_doitmethod = "finalise" + doitmethod
                             ok = ok or getattr(newsection, actual_doitmethod)()
                         else:
                             actual_doitmethod = doitmethod
-                            ok = ok or getattr(newsection, actual_doitmethod)(**cmdopts)
+                            ok = ok or getattr(newsection, actual_doitmethod)(
+                                **cmdopts
+                            )
                         if talkative:
-                            t.sh.highlight('Result from {:s}: [{!s}]'.format(actual_doitmethod, ok))
+                            t.sh.highlight(
+                                "Result from {:s}: [{!s}]".format(
+                                    actual_doitmethod, ok
+                                )
+                            )
                         if talkative and not ok:
-                            logger.error('Could not %s resource %s',
-                                         doitmethod, rhandler.container.localpath())
+                            logger.error(
+                                "Could not %s resource %s",
+                                doitmethod,
+                                rhandler.container.localpath(),
+                            )
                         if not ok:
                             if complete:
-                                logger.warning('Force complete for %s',
-                                               rhandler.location(fatal=False))
-                                raise VortexForceComplete('Force task complete on resource error')
+                                logger.warning(
+                                    "Force complete for %s",
+                                    rhandler.location(fatal=False),
+                                )
+                                raise VortexForceComplete(
+                                    "Force task complete on resource error"
+                                )
                         else:
                             secok.append(newsection)
                         if t.sh.trace:
                             print()
-                    rlok.extend([newsection.rh for newsection in secok
-                                 if newsection.any_coherentgroup_opened])
+                    rlok.extend(
+                        [
+                            newsection.rh
+                            for newsection in secok
+                            if newsection.any_coherentgroup_opened
+                        ]
+                    )
             else:
                 rlok.extend([newsection.rh for newsection in newsections])
 
@@ -414,9 +495,9 @@ def input(*args, **kw):  # @ReservedAssignment
     :return: A list of :class:`vortex.data.handlers.Handler` objects (associated
         with the newly created class:`~vortex.layout.dataflow.Section` objects).
     """
-    kw.setdefault('insitu', active_insitu)
-    kw.setdefault('batch', active_batchinputs)
-    return add_section('input', args, kw)
+    kw.setdefault("insitu", active_insitu)
+    kw.setdefault("batch", active_batchinputs)
+    return add_section("input", args, kw)
 
 
 def inputs(ticket=None, context=None):
@@ -445,7 +526,7 @@ def show_inputs(context=None):
     """
     t = sessions.current()
     for csi in inputs(ticket=t):
-        t.sh.header('Input ' + str(csi))
+        t.sh.header("Input " + str(csi))
         csi.show(ticket=t, context=context)
         print()
 
@@ -462,11 +543,14 @@ def output(*args, **kw):
     """
     # Strip the metadatacheck option depending on active_metadatacheck
     if not active_promise:
-        for target in ('promised', 'expected'):
+        for target in ("promised", "expected"):
             if target in kw and kw[target]:
-                logger.info("The %s argument is removed since active_promise=False.", target)
+                logger.info(
+                    "The %s argument is removed since active_promise=False.",
+                    target,
+                )
                 del kw[target]
-    return add_section('output', args, kw)
+    return add_section("output", args, kw)
 
 
 def outputs(ticket=None, context=None):
@@ -493,7 +577,7 @@ def show_outputs(context=None):
     """
     t = sessions.current()
     for cso in outputs(ticket=t):
-        t.sh.header('Output ' + str(cso))
+        t.sh.header("Output " + str(cso))
         cso.show(ticket=t, context=context)
         print()
 
@@ -517,9 +601,9 @@ def promise(*args, **kw):
         now=active_promise,
     )
     if not active_promise:
-        kw.setdefault('verbose', False)
-        logger.warning('Promise flag is <%s> in that context', active_promise)
-    return add_section('output', args, kw)
+        kw.setdefault("verbose", False)
+        logger.warning("Promise flag is <%s> in that context", active_promise)
+    return add_section("output", args, kw)
 
 
 def executable(*args, **kw):
@@ -533,8 +617,8 @@ def executable(*args, **kw):
     :return: A list of :class:`vortex.data.handlers.Handler` objects (associated
         with the newly created class:`~vortex.layout.dataflow.Section` objects).
     """
-    kw.setdefault('insitu', active_insitu)
-    return add_section('executable', args, kw)
+    kw.setdefault("insitu", active_insitu)
+    return add_section("executable", args, kw)
 
 
 def algo(*args, **kw):
@@ -559,13 +643,12 @@ def algo(*args, **kw):
     t = sessions.current()
 
     # First, retrieve arguments of the toolbox command itself
-    loglevel = kw.pop('loglevel', None)
-    talkative = kw.pop('verbose', active_verbose)
+    loglevel = kw.pop("loglevel", None)
+    talkative = kw.pop("verbose", active_verbose)
 
     with _tb_isolate(t, loglevel):
-
         if talkative:
-            nicedump('Loading algo component with description:', **kw)
+            nicedump("Loading algo component with description:", **kw)
 
         ok = proxy.component(**kw)  # @UndefinedVariable
         if ok and talkative:
@@ -606,34 +689,36 @@ def diff(*args, **kw):
     """
 
     # First, retrieve arguments of the toolbox command itself
-    fatal = kw.pop('fatal', True)
-    loglevel = kw.pop('loglevel', None)
-    talkative = kw.pop('verbose', active_verbose)
-    batch = kw.pop('batch', active_batchinputs)
+    fatal = kw.pop("fatal", True)
+    loglevel = kw.pop("loglevel", None)
+    talkative = kw.pop("verbose", active_verbose)
+    batch = kw.pop("batch", active_batchinputs)
 
     # Distinguish between section arguments, and resource loader arguments
     opts, kwclean = stripargs_section(**kw)
 
     # Show the actual set of arguments
     if talkative:
-        nicedump('Discard section options', **opts)
-        nicedump('Resource handler description', **kwclean)
+        nicedump("Discard section options", **opts)
+        nicedump("Resource handler description", **kwclean)
 
     # Fast exit in case of undefined value
     rlok = list()
-    none_skip = {k for k, v in kwclean.items()
-                 if v is None and k in ('experiment', 'namespace')}
+    none_skip = {
+        k
+        for k, v in kwclean.items()
+        if v is None and k in ("experiment", "namespace")
+    }
     if none_skip:
-        logger.warning('Skip diff because of undefined argument(s)')
+        logger.warning("Skip diff because of undefined argument(s)")
         return rlok
 
     t = sessions.current()
 
     # Swich off autorecording of the current context + deal with loggging
     with _tb_isolate(t, loglevel):
-
         # Do not track the reference files
-        kwclean['storetrack'] = False
+        kwclean["storetrack"] = False
 
         rhandlers = rload(*args, **kwclean)
         sections = list()
@@ -647,12 +732,17 @@ def diff(*args, **kw):
             for ir, rhandler in enumerate(rhandlers):
                 source_container.append(rhandler.container)
                 # Create a new container to hold the reference file
-                lazzy_container.append(footprints.proxy.container(shouldfly=True,
-                                                                  actualfmt=rhandler.container.actualfmt))
+                lazzy_container.append(
+                    footprints.proxy.container(
+                        shouldfly=True, actualfmt=rhandler.container.actualfmt
+                    )
+                )
                 # Swapp the original container with the lazzy one
                 rhandler.container = lazzy_container[-1]
                 # Create a new section
-                sec = Section(rh=rhandler, kind=ixo.INPUT, intent=intent.IN, fatal=False)
+                sec = Section(
+                    rh=rhandler, kind=ixo.INPUT, intent=intent.IN, fatal=False
+                )
                 sections.append(sec)
                 # Early-get
                 if rhandler.complete:
@@ -661,9 +751,14 @@ def diff(*args, **kw):
                     earlyget_id.append(None)
             # Finalising
             if any([r_id and r_id is not True for r_id in earlyget_id]):
-                t.sh.highlight('Finalising Early-gets')
-                t.context.delayedactions_hub.finalise(* [r_id for r_id in earlyget_id
-                                                         if r_id and r_id is not True])
+                t.sh.highlight("Finalising Early-gets")
+                t.context.delayedactions_hub.finalise(
+                    *[
+                        r_id
+                        for r_id in earlyget_id
+                        if r_id and r_id is not True
+                    ]
+                )
 
         for ir, rhandler in enumerate(rhandlers):
             if talkative:
@@ -671,9 +766,11 @@ def diff(*args, **kw):
                 rhandler.quickview(nb=ir + 1, indent=0)
                 print(t.line)
             if not rhandler.complete:
-                logger.error('Incomplete Resource Handler for diff [%s]', rhandler)
+                logger.error(
+                    "Incomplete Resource Handler for diff [%s]", rhandler
+                )
                 if fatal:
-                    raise ValueError('Incomplete Resource Handler for diff')
+                    raise ValueError("Incomplete Resource Handler for diff")
                 else:
                     rlok.append(False)
                     continue
@@ -686,52 +783,65 @@ def diff(*args, **kw):
                 rc = sections[ir].get()
             if not rc:
                 try:
-                    logger.error('Cannot get the reference resource: %s',
-                                 rhandler.locate())
+                    logger.error(
+                        "Cannot get the reference resource: %s",
+                        rhandler.locate(),
+                    )
                 except Exception:
-                    logger.error('Cannot get the reference resource: ???')
+                    logger.error("Cannot get the reference resource: ???")
                 if fatal:
-                    raise ValueError('Cannot get the reference resource')
+                    raise ValueError("Cannot get the reference resource")
             else:
-                logger.info('The reference file is stored under: %s',
-                            rhandler.container.localpath())
+                logger.info(
+                    "The reference file is stored under: %s",
+                    rhandler.container.localpath(),
+                )
 
             # What are the differences ?
             if rc:
                 # priority is given to the diff implemented in the DataContent
                 if rhandler.resource.clscontents.is_diffable():
                     source_contents = rhandler.resource.contents_handler(
-                        datafmt=source_container[ir].actualfmt)
+                        datafmt=source_container[ir].actualfmt
+                    )
                     source_contents.slurp(source_container[ir])
                     ref_contents = rhandler.contents
                     rc = source_contents.diff(ref_contents)
                 else:
-                    rc = t.sh.diff(source_container[ir].localpath(),
-                                   rhandler.container.localpath(),
-                                   fmt=rhandler.container.actualfmt)
+                    rc = t.sh.diff(
+                        source_container[ir].localpath(),
+                        rhandler.container.localpath(),
+                        fmt=rhandler.container.actualfmt,
+                    )
 
             # Delete the reference file
             lazzy_container[ir].clear()
 
             # Now proceed with the result
-            logger.info('Diff return %s', str(rc))
-            t.context.diff_history.append_record(rc, source_container[ir], rhandler)
+            logger.info("Diff return %s", str(rc))
+            t.context.diff_history.append_record(
+                rc, source_container[ir], rhandler
+            )
             try:
-                logger.info('Diff result %s', str(rc.result))
+                logger.info("Diff result %s", str(rc.result))
             except AttributeError:
                 pass
             if not rc:
                 try:
-                    logger.warning('Some diff occurred with %s', rhandler.locate())
+                    logger.warning(
+                        "Some diff occurred with %s", rhandler.locate()
+                    )
                 except Exception:
-                    logger.warning('Some diff occurred with ???')
+                    logger.warning("Some diff occurred with ???")
                 try:
                     rc.result.differences()
                 except Exception:
                     pass
                 if fatal:
-                    logger.critical('Difference in resource comparison is fatal')
-                    raise ValueError('Fatal diff')
+                    logger.critical(
+                        "Difference in resource comparison is fatal"
+                    )
+                    raise ValueError("Fatal diff")
             if t.sh.trace:
                 print()
             rlok.append(rc)
@@ -746,7 +856,7 @@ def magic(localpath, **kw):
     """
     kw.update(
         unknown=True,
-        magic='magic://localhost/' + localpath,
+        magic="magic://localhost/" + localpath,
         filename=localpath,
     )
     rhmagic = rh(**kw)
@@ -770,22 +880,24 @@ def archive_refill(*args, **kw):
     t = sessions.current()
 
     # First, retrieve arguments of the toolbox command itself
-    loglevel = kw.pop('loglevel', None)
-    talkative = kw.pop('verbose', active_verbose)
+    loglevel = kw.pop("loglevel", None)
+    talkative = kw.pop("verbose", active_verbose)
 
     with _tb_isolate(t, loglevel):
-
         # Distinguish between section arguments, and resource loader arguments
         opts, kwclean = stripargs_section(**kw)
-        fatal = opts.get('fatal', True)
+        fatal = opts.get("fatal", True)
 
         # Print the user inputs
         if talkative:
-            nicedump('Archive Refill Ressource+Provider description', **kwclean)
+            nicedump(
+                "Archive Refill Ressource+Provider description", **kwclean
+            )
 
         # Create the resource handlers
-        kwclean['container'] = footprints.proxy.container(uuid4fly=True,
-                                                          uuid4flydir="archive_refills")
+        kwclean["container"] = footprints.proxy.container(
+            uuid4fly=True, uuid4flydir="archive_refills"
+        )
         rl = rload(*args, **kwclean)
 
         @contextmanager
@@ -795,36 +907,56 @@ def archive_refill(*args, **kw):
             try:
                 yield wrap_rc
             except Exception as e:
-                logger.error('Something wrong (action %s): %s. %s',
-                             action, str(e), traceback.format_exc())
-                wrap_rc['rc'] = False
-                wrap_rc['exc'] = e
-            if fatal and not wrap_rc['rc']:
-                logger.critical('Fatal error with action %s.', action)
-                raise RuntimeError('Could not {:s} resource: {!s}'.format(action,
-                                                                          wrap_rc['rc']))
+                logger.error(
+                    "Something wrong (action %s): %s. %s",
+                    action,
+                    str(e),
+                    traceback.format_exc(),
+                )
+                wrap_rc["rc"] = False
+                wrap_rc["exc"] = e
+            if fatal and not wrap_rc["rc"]:
+                logger.critical("Fatal error with action %s.", action)
+                raise RuntimeError(
+                    "Could not {:s} resource: {!s}".format(
+                        action, wrap_rc["rc"]
+                    )
+                )
 
         with t.sh.ftppool():
             for ir, rhandler in enumerate(rl):
                 if talkative:
-                    t.sh.subtitle('Resource no {:02d}/{:02d}'.format(ir + 1, len(rl)))
+                    t.sh.subtitle(
+                        "Resource no {:02d}/{:02d}".format(ir + 1, len(rl))
+                    )
                     rhandler.quickview(nb=ir + 1, indent=0)
-                if not (rhandler.store.use_cache() and rhandler.store.use_archive()):
-                    logger.info('The requested store does not have both the cache and archive capabilities. ' +
-                                'Skipping this ressource handler.')
+                if not (
+                    rhandler.store.use_cache() and rhandler.store.use_archive()
+                ):
+                    logger.info(
+                        "The requested store does not have both the cache and archive capabilities. "
+                        + "Skipping this ressource handler."
+                    )
                     continue
-                with _fatal_wrap('get') as get_status:
-                    get_status['rc'] = rhandler.get(incache=True, intent=intent.IN,
-                                                    fmt=rhandler.resource.nativefmt)
+                with _fatal_wrap("get") as get_status:
+                    get_status["rc"] = rhandler.get(
+                        incache=True,
+                        intent=intent.IN,
+                        fmt=rhandler.resource.nativefmt,
+                    )
                 put_status = dict(rc=False)
-                if get_status['rc']:
-                    with _fatal_wrap('put') as put_status:
-                        put_status['rc'] = rhandler.put(inarchive=True,
-                                                        fmt=rhandler.resource.nativefmt)
+                if get_status["rc"]:
+                    with _fatal_wrap("put") as put_status:
+                        put_status["rc"] = rhandler.put(
+                            inarchive=True, fmt=rhandler.resource.nativefmt
+                        )
                     rhandler.container.clear()
                 if talkative:
-                    t.sh.highlight('Result from get: [{!s}], from put: [{!s}]'
-                                   .format(get_status['rc'], put_status['rc']))
+                    t.sh.highlight(
+                        "Result from get: [{!s}], from put: [{!s}]".format(
+                            get_status["rc"], put_status["rc"]
+                        )
+                    )
 
     return rl
 
@@ -842,7 +974,7 @@ def stack_archive_refill(*args, **kw):
 
     :return: A list of :class:`vortex.data.handlers.Handler` objects.
     """
-    kw['block'] = 'stacks'
+    kw["block"] = "stacks"
     return archive_refill(*args, **kw)
 
 
@@ -852,21 +984,24 @@ def namespaces(**kw):
     used. By default tracks ``stores`` and ``providers`` but one could give an
     ``only`` argument.
     """
-    rematch = re.compile('|'.join(kw.get('match', '.').split(',')),
-                         re.IGNORECASE)
-    if 'only' in kw:
-        usedcat = kw['only'].split(',')
+    rematch = re.compile(
+        "|".join(kw.get("match", ".").split(",")), re.IGNORECASE
+    )
+    if "only" in kw:
+        usedcat = kw["only"].split(",")
     else:
-        usedcat = ('provider', 'store')
+        usedcat = ("provider", "store")
     nameseen = dict()
     for cat in [footprints.collectors.get(tag=x) for x in usedcat]:
         for cls in cat():
             fp = cls.footprint_retrieve().attr
-            netattr = fp.get('namespace', None)
+            netattr = fp.get("namespace", None)
             if not netattr:
-                netattr = fp.get('netloc', None)
-            if netattr and 'values' in netattr:
-                for netname in filter(lambda x: rematch.search(x), netattr['values']):
+                netattr = fp.get("netloc", None)
+            if netattr and "values" in netattr:
+                for netname in filter(
+                    lambda x: rematch.search(x), netattr["values"]
+                ):
                     if netname not in nameseen:
                         nameseen[netname] = list()
                     nameseen[netname].append(cls.fullname())
@@ -875,17 +1010,18 @@ def namespaces(**kw):
 
 def print_namespaces(**kw):
     """Formatted print of current namespaces."""
-    prefix = kw.pop('prefix', '+ ')
+    prefix = kw.pop("prefix", "+ ")
     nd = namespaces(**kw)
     justify = max([len(x) for x in nd.keys()])
-    linesep = ",\n" + ' ' * (justify + len(prefix) + 2)
+    linesep = ",\n" + " " * (justify + len(prefix) + 2)
     for k, v in sorted(nd.items()):
         nice_v = linesep.join(v) if len(v) > 1 else v[0]
-        print(prefix + k.ljust(justify), '[' + nice_v + ']')
+        print(prefix + k.ljust(justify), "[" + nice_v + "]")
 
 
-def clear_promises(clear=None, netloc='promise.cache.fr', scheme='vortex',
-                   storeoptions=None):
+def clear_promises(
+    clear=None, netloc="promise.cache.fr", scheme="vortex", storeoptions=None
+):
     """Remove all promises that have been made in the current session.
 
     :param netloc: Netloc of the promise's cache store to clean up
@@ -913,50 +1049,49 @@ def rescue(*files, **opts):
 
     # Summarise diffs...
     if len(t.context.diff_history):
-        sh.header('Summary of automatic toolbox diffs')
+        sh.header("Summary of automatic toolbox diffs")
         t.context.diff_history.show()
 
     # Force clearing of all promises
     clear_promises(clear=True)
 
-    sh.header('Rescuing current dir')
+    sh.header("Rescuing current dir")
     sh.dir(output=False, fatal=False)
 
-    logger.info('Rescue files %s', files)
+    logger.info("Rescue files %s", files)
 
-    if 'VORTEX_RESCUE' in env and env.false('VORTEX_RESCUE'):
-        logger.warning('Skip rescue <VORTEX_RESCUE=%s>', env.VORTEX_RESCUE)
+    if "VORTEX_RESCUE" in env and env.false("VORTEX_RESCUE"):
+        logger.warning("Skip rescue <VORTEX_RESCUE=%s>", env.VORTEX_RESCUE)
         return False
 
     if files:
         items = list(files)
     else:
-        items = sh.glob('*')
+        items = sh.glob("*")
 
-    rfilter = opts.get('filter', env.VORTEX_RESCUE_FILTER)
+    rfilter = opts.get("filter", env.VORTEX_RESCUE_FILTER)
     if rfilter is not None:
-        logger.warning('Rescue filter <%s>', rfilter)
-        select = '|'.join(re.split(r'[,;:]+', rfilter))
+        logger.warning("Rescue filter <%s>", rfilter)
+        select = "|".join(re.split(r"[,;:]+", rfilter))
         items = [x for x in items if re.search(select, x, re.IGNORECASE)]
-        logger.info('Rescue filter [%s]', select)
+        logger.info("Rescue filter [%s]", select)
 
-    rdiscard = opts.get('discard', env.VORTEX_RESCUE_DISCARD)
+    rdiscard = opts.get("discard", env.VORTEX_RESCUE_DISCARD)
     if rdiscard is not None:
-        logger.warning('Rescue discard <%s>', rdiscard)
-        select = '|'.join(re.split(r'[,;:]+', rdiscard))
+        logger.warning("Rescue discard <%s>", rdiscard)
+        select = "|".join(re.split(r"[,;:]+", rdiscard))
         items = [x for x in items if not re.search(select, x, re.IGNORECASE)]
-        logger.info('Rescue discard [%s]', select)
+        logger.info("Rescue discard [%s]", select)
 
     if items:
-
-        bkupdir = opts.get('bkupdir', env.VORTEX_RESCUE_PATH)
+        bkupdir = opts.get("bkupdir", env.VORTEX_RESCUE_PATH)
 
         if bkupdir is None:
-            logger.error('No rescue directory defined.')
+            logger.error("No rescue directory defined.")
         else:
-            logger.info('Backup directory defined by user < %s >', bkupdir)
+            logger.info("Backup directory defined by user < %s >", bkupdir)
             items.sort()
-            logger.info('Rescue items %s', str(items))
+            logger.info("Rescue items %s", str(items))
             sh.mkdir(bkupdir)
             mkmove = False
             st1 = sh.stat(sh.getcwd())
@@ -977,6 +1112,6 @@ def rescue(*files, **opts):
                         thisrescue(ritem, rtarget)
 
     else:
-        logger.warning('No item to rescue.')
+        logger.warning("No item to rescue.")
 
     return bool(items)