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

vortex/nwp/algo/coupling.py

@@ -12,7 +12,10 @@ from bronx.stdtypes import date
 from .ifsroot import IFSParallel
 from ..tools.drhook import DrHookDecoMixin
 from vortex.algo.components import AlgoComponentError, BlindRun, Parallel
-from vortex.algo.components import AlgoComponentDecoMixin, algo_component_deco_mixin_autodoc
+from vortex.algo.components import (
+    AlgoComponentDecoMixin,
+    algo_component_deco_mixin_autodoc,
+)
 from vortex.layout.dataflow import intent
 from vortex.tools.grib import EcGribDecoMixin
 
@@ -29,7 +32,7 @@ coupling_basedate_fp = footprints.Footprint(
         basedate=dict(
             info="The run date of the coupling generating process",
             type=date.Date,
-            optional=True
+            optional=True,
         )
     )
 )
@@ -39,25 +42,31 @@ coupling_basedate_fp = footprints.Footprint(
 class CouplingBaseDateNamMixin(AlgoComponentDecoMixin):
     """Add a basedate attribute and make namelist substitution."""
 
-    _MIXIN_EXTRA_FOOTPRINTS = (coupling_basedate_fp, )
+    _MIXIN_EXTRA_FOOTPRINTS = (coupling_basedate_fp,)
 
     def _prepare_basedate_hook(self, rh, opts):
         """Update the namelist with date information."""
 
         def set_nam_macro(namrh, macro, value):
             namrh.contents.setmacro(macro, value)
-            logger.info('Setup macro %s=%s in %s', macro, str(value),
-                        namrh.container.actualpath())
+            logger.info(
+                "Setup macro %s=%s in %s",
+                macro,
+                str(value),
+                namrh.container.actualpath(),
+            )
 
-        for namsec in self.context.sequence.effective_inputs(kind=('namelist',)):
+        for namsec in self.context.sequence.effective_inputs(
+            kind=("namelist",)
+        ):
             if self.basedate is not None:
-                set_nam_macro(namsec.rh, 'YYYY', int(self.basedate.year))
-                set_nam_macro(namsec.rh, 'MM', int(self.basedate.month))
-                set_nam_macro(namsec.rh, 'DD', int(self.basedate.day))
+                set_nam_macro(namsec.rh, "YYYY", int(self.basedate.year))
+                set_nam_macro(namsec.rh, "MM", int(self.basedate.month))
+                set_nam_macro(namsec.rh, "DD", int(self.basedate.day))
                 if namsec.rh.contents.dumps_needs_update:
                     namsec.rh.save()
 
-    _MIXIN_PREPARE_HOOKS = (_prepare_basedate_hook, )
+    _MIXIN_PREPARE_HOOKS = (_prepare_basedate_hook,)
 
 
 class Coupling(FullPos):
@@ -69,26 +78,28 @@ class Coupling(FullPos):
     _footprint = [
         coupling_basedate_fp,
         dict(
-            info = "Create coupling files for a Limited Area Model.",
-            attr = dict(
-                kind = dict(
-                    values   = ['coupling'],
+            info="Create coupling files for a Limited Area Model.",
+            attr=dict(
+                kind=dict(
+                    values=["coupling"],
                 ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'coupling'
+        return "coupling"
 
     def prepare(self, rh, opts):
         """Default pre-link for namelist file and domain change."""
         super().prepare(rh, opts)
-        namsec = self.setlink(initrole='Namelist', initkind='namelist', initname='fort.4')
-        for nam in [x.rh for x in namsec if 'NAMFPC' in x.rh.contents]:
+        namsec = self.setlink(
+            initrole="Namelist", initkind="namelist", initname="fort.4"
+        )
+        for nam in [x.rh for x in namsec if "NAMFPC" in x.rh.contents]:
             logger.info('Substitute "AREA" to CFPDOM namelist entry')
-            nam.contents['NAMFPC']['CFPDOM(1)'] = 'AREA'
+            nam.contents["NAMFPC"]["CFPDOM(1)"] = "AREA"
             nam.save()
 
     def execute(self, rh, opts):
@@ -97,142 +108,202 @@ class Coupling(FullPos):
         sh = self.system
 
         cplsec = self.context.sequence.effective_inputs(
-            role=('InitialCondition', 'CouplingSource'),
-            kind=('historic', 'analysis')
+            role=("InitialCondition", "CouplingSource"),
+            kind=("historic", "analysis"),
         )
         cplsec.sort(key=lambda s: s.rh.resource.term)
-        ininc = self.naming_convention('ic', rh)
+        ininc = self.naming_convention("ic", rh)
         infile = ininc()
         isMany = len(cplsec) > 1
-        outprefix = 'PF{:s}AREA'.format(self.xpname)
+        outprefix = "PF{:s}AREA".format(self.xpname)
 
-        cplguess = self.context.sequence.effective_inputs(role='Guess')
+        cplguess = self.context.sequence.effective_inputs(role="Guess")
         cplguess.sort(key=lambda s: s.rh.resource.term)
         guessing = bool(cplguess)
 
-        cplsurf = self.context.sequence.effective_inputs(role=('SurfaceInitialCondition',
-                                                               'SurfaceCouplingSource'))
+        cplsurf = self.context.sequence.effective_inputs(
+            role=("SurfaceInitialCondition", "SurfaceCouplingSource")
+        )
         cplsurf.sort(key=lambda s: s.rh.resource.term)
         surfacing = bool(cplsurf)
-        inisurfnc = self.naming_convention('ic', rh, model='surfex')
+        inisurfnc = self.naming_convention("ic", rh, model="surfex")
         infilesurf = inisurfnc()
         if surfacing:
             # Link in the Surfex's PGD
-            sclimnc = self.naming_convention(kind='targetclim', rh=rh, model='surfex')
+            sclimnc = self.naming_convention(
+                kind="targetclim", rh=rh, model="surfex"
+            )
             self.setlink(
-                initrole=('ClimPGD',),
-                initkind=('pgdfa', 'pgdlfi'),
-                initname=sclimnc(area='AREA')
+                initrole=("ClimPGD",),
+                initkind=("pgdfa", "pgdlfi"),
+                initname=sclimnc(area="AREA"),
             )
 
         for sec in cplsec:
             r = sec.rh
-            sh.subtitle('Loop on {!s}'.format(r.resource))
+            sh.subtitle("Loop on {!s}".format(r.resource))
 
             # First attempt to set actual date as the one of the source model
             actualdate = r.resource.date + r.resource.term
 
             # Expect the coupling source to be there...
-            self.grab(sec, comment='coupling source')
+            self.grab(sec, comment="coupling source")
 
             # Set the actual init file
             if sh.path.exists(infile):
                 if isMany:
-                    logger.critical('Cannot process multiple Historic files if %s exists.', infile)
+                    logger.critical(
+                        "Cannot process multiple Historic files if %s exists.",
+                        infile,
+                    )
             else:
-                sh.cp(r.container.localpath(), infile, fmt=r.container.actualfmt, intent=intent.IN)
+                sh.cp(
+                    r.container.localpath(),
+                    infile,
+                    fmt=r.container.actualfmt,
+                    intent=intent.IN,
+                )
 
             # If the surface file is needed, set the actual initsurf file
             if cplsurf:
                 # Expecting the coupling surface source to be there...
                 cplsurf_in = cplsurf.pop(0)
-                self.grab(cplsurf_in, comment='coupling surface source')
+                self.grab(cplsurf_in, comment="coupling surface source")
                 if sh.path.exists(infilesurf):
                     if isMany:
-                        logger.critical('Cannot process multiple surface historic files if %s exists.',
-                                        infilesurf)
+                        logger.critical(
+                            "Cannot process multiple surface historic files if %s exists.",
+                            infilesurf,
+                        )
                 else:
-                    sh.cp(cplsurf_in.rh.container.localpath(), infilesurf,
-                          fmt=cplsurf_in.rh.container.actualfmt, intent=intent.IN)
+                    sh.cp(
+                        cplsurf_in.rh.container.localpath(),
+                        infilesurf,
+                        fmt=cplsurf_in.rh.container.actualfmt,
+                        intent=intent.IN,
+                    )
             elif surfacing:
-                logger.error('No more surface source to loop on for coupling')
+                logger.error("No more surface source to loop on for coupling")
 
             # The output could be an input as well
             if cplguess:
                 cplout = cplguess.pop(0)
                 cplpath = cplout.rh.container.localpath()
                 if sh.path.exists(cplpath):
-                    actualdateguess = cplout.rh.resource.date + cplout.rh.resource.term
-                    if (actualdate == actualdateguess):
-                        logger.error('The guess date, %s, is different from the source date %s, !',
-                                     actualdateguess.reallynice(), actualdate.reallynice())
+                    actualdateguess = (
+                        cplout.rh.resource.date + cplout.rh.resource.term
+                    )
+                    if actualdate == actualdateguess:
+                        logger.error(
+                            "The guess date, %s, is different from the source date %s, !",
+                            actualdateguess.reallynice(),
+                            actualdate.reallynice(),
+                        )
                     # Expect the coupling guess to be there...
-                    self.grab(cplout, comment='coupling guess')
-                    logger.info('Coupling with existing guess <%s>', cplpath)
-                    inoutfile = outprefix + '+0000'
+                    self.grab(cplout, comment="coupling guess")
+                    logger.info("Coupling with existing guess <%s>", cplpath)
+                    inoutfile = outprefix + "+0000"
                     if cplpath != inoutfile:
                         sh.remove(inoutfile, fmt=cplout.rh.container.actualfmt)
-                        sh.move(cplpath, inoutfile,
-                                fmt=cplout.rh.container.actualfmt,
-                                intent=intent.INOUT)
+                        sh.move(
+                            cplpath,
+                            inoutfile,
+                            fmt=cplout.rh.container.actualfmt,
+                            intent=intent.INOUT,
+                        )
                 else:
-                    logger.warning('Missing guess input for coupling <%s>', cplpath)
+                    logger.warning(
+                        "Missing guess input for coupling <%s>", cplpath
+                    )
             elif guessing:
-                logger.error('No more guess to loop on for coupling')
+                logger.error("No more guess to loop on for coupling")
 
             # Find out actual monthly climatological resource
             actualmonth = date.Month(actualdate)
-            self.climfile_fixer(rh, convkind='modelclim', month=actualmonth,
-                                inputrole=('GlobalClim', 'InitialClim'),
-                                inputkind='clim_model')
-            self.climfile_fixer(rh, convkind='targetclim', month=actualmonth,
-                                inputrole=('LocalClim', 'TargetClim'),
-                                inputkind='clim_model', area='AREA')
+            self.climfile_fixer(
+                rh,
+                convkind="modelclim",
+                month=actualmonth,
+                inputrole=("GlobalClim", "InitialClim"),
+                inputkind="clim_model",
+            )
+            self.climfile_fixer(
+                rh,
+                convkind="targetclim",
+                month=actualmonth,
+                inputrole=("LocalClim", "TargetClim"),
+                inputkind="clim_model",
+                area="AREA",
+            )
 
             # Standard execution
             super().execute(rh, opts)
 
             # Set a local appropriate file
-            posfile = [x for x in sh.glob(outprefix + '+*')
-                       if re.match(outprefix + r'\+\d+(?:\:\d+)?(?:\.sfx)?$', x)]
-            if (len(posfile) > 1):
-                logger.critical('Many ' + outprefix + ' files, do not know how to adress that')
+            posfile = [
+                x
+                for x in sh.glob(outprefix + "+*")
+                if re.match(outprefix + r"\+\d+(?:\:\d+)?(?:\.sfx)?$", x)
+            ]
+            if len(posfile) > 1:
+                logger.critical(
+                    "Many "
+                    + outprefix
+                    + " files, do not know how to adress that"
+                )
             posfile = posfile[0]
             if self.basedate is None:
                 actualterm = r.resource.term
             else:
                 actualterm = (actualdate - self.basedate).time()
-            actualname = (re.sub(r'^.+?((?:_\d+)?)(?:\+[:\d]+)?$', r'CPLOUT\1+', r.container.localpath()) +
-                          actualterm.fmthm)
+            actualname = (
+                re.sub(
+                    r"^.+?((?:_\d+)?)(?:\+[:\d]+)?$",
+                    r"CPLOUT\1+",
+                    r.container.localpath(),
+                )
+                + actualterm.fmthm
+            )
             if isMany:
-                sh.move(sh.path.realpath(posfile), actualname,
-                        fmt=r.container.actualfmt)
+                sh.move(
+                    sh.path.realpath(posfile),
+                    actualname,
+                    fmt=r.container.actualfmt,
+                )
                 if sh.path.exists(posfile):
                     sh.rm(posfile)
             else:
                 # This is here because of legacy with .sfx files
-                sh.cp(sh.path.realpath(posfile), actualname,
-                      fmt=r.container.actualfmt, intent=intent.IN)
+                sh.cp(
+                    sh.path.realpath(posfile),
+                    actualname,
+                    fmt=r.container.actualfmt,
+                    intent=intent.IN,
+                )
 
             # promises management
-            expected = [x for x in self.promises if x.rh.container.localpath() == actualname]
+            expected = [
+                x
+                for x in self.promises
+                if x.rh.container.localpath() == actualname
+            ]
             if expected:
                 for thispromise in expected:
                     thispromise.put(incache=True)
 
             # The only one listing
             if not self.server_run:
-                sh.cat('NODE.001_01', output='NODE.all')
+                sh.cat("NODE.001_01", output="NODE.all")
 
             # prepares the next execution
             if isMany:
                 # Some cleaning
-                sh.rmall('PXFPOS*', fmt=r.container.actualfmt)
+                sh.rmall("PXFPOS*", fmt=r.container.actualfmt)
                 sh.remove(infile, fmt=r.container.actualfmt)
                 if cplsurf:
                     sh.remove(infilesurf, fmt=r.container.actualfmt)
                 if not self.server_run:
-                    sh.rmall('ncf927', 'dirlst', 'NODE.[0123456789]*', 'std*')
+                    sh.rmall("ncf927", "dirlst", "NODE.[0123456789]*", "std*")
 
 
 class CouplingLAM(Coupling):
@@ -242,18 +313,18 @@ class CouplingLAM(Coupling):
     """
 
     _footprint = dict(
-        info = "Create coupling files for a Limited Area Model (useless beyond cy40).",
-        attr = dict(
-            kind = dict(
-                values   = ['lamcoupling'],
+        info="Create coupling files for a Limited Area Model (useless beyond cy40).",
+        attr=dict(
+            kind=dict(
+                values=["lamcoupling"],
             ),
-        )
+        ),
     )
 
     def spawn_command_options(self):
         """Dictionary provided for command line factory."""
         opts = super().spawn_command_options()
-        opts['model'] = 'aladin'
+        opts["model"] = "aladin"
         return opts
 
 
@@ -261,157 +332,219 @@ class CouplingLAM(Coupling):
 class PrepMixin(AlgoComponentDecoMixin):
     """Coupling/Interpolation of Surfex files."""
 
-    _MIXIN_EXTRA_FOOTPRINTS = (footprints.Footprint(
-        info="Coupling/Interpolation of Surfex files.",
-        attr=dict(
-            kind=dict(
-                values=['prep'],
-            ),
-            underlyingformat=dict(
-                info="The format of input data (as expected by the PREP executable).",
-                values=['fa', 'lfi', 'netcdf'],
-                optional=True,
-                default='fa'
-            ),
-            underlyingoutputformat=dict(
-                info=("The format of output data (as expected by the PREP executable)." +
-                      "If omited, *underlyingformat* is used."),
-                values=['fa', 'lfi', 'netcdf', 'txt'],
-                optional=True,
-            ),
-            outputformat=dict(
-                info=("The format of output data (as expected by the user)." +
-                      "If omited, same as input data."),
-                values=['fa', 'lfi', 'netcdf', 'txt'],
-                optional=True,
+    _MIXIN_EXTRA_FOOTPRINTS = (
+        footprints.Footprint(
+            info="Coupling/Interpolation of Surfex files.",
+            attr=dict(
+                kind=dict(
+                    values=["prep"],
+                ),
+                underlyingformat=dict(
+                    info="The format of input data (as expected by the PREP executable).",
+                    values=["fa", "lfi", "netcdf"],
+                    optional=True,
+                    default="fa",
+                ),
+                underlyingoutputformat=dict(
+                    info=(
+                        "The format of output data (as expected by the PREP executable)."
+                        + "If omited, *underlyingformat* is used."
+                    ),
+                    values=["fa", "lfi", "netcdf", "txt"],
+                    optional=True,
+                ),
+                outputformat=dict(
+                    info=(
+                        "The format of output data (as expected by the user)."
+                        + "If omited, same as input data."
+                    ),
+                    values=["fa", "lfi", "netcdf", "txt"],
+                    optional=True,
+                ),
             ),
-        )
-    ), )
+        ),
+    )
 
     @cached_property
     def _actual_u_output_format(self):
-        return (self.underlyingoutputformat
-                if self.underlyingoutputformat is not None else
-                self.underlyingformat)
+        return (
+            self.underlyingoutputformat
+            if self.underlyingoutputformat is not None
+            else self.underlyingformat
+        )
 
     def _actual_output_format(self, in_format):
-        return (self.outputformat if self.outputformat is not None
-                else in_format)
+        return (
+            self.outputformat if self.outputformat is not None else in_format
+        )
 
     @staticmethod
     def _sfx_fmt_remap(fmt):
-        return dict(netcdf='nc').get(fmt, fmt)
+        return dict(netcdf="nc").get(fmt, fmt)
 
     @cached_property
     def _has_sfx_lfi(self):
-        addon_checked = ('sfx' in self.system.loaded_addons() and
-                         'lfi' in self.system.loaded_addons())
+        addon_checked = (
+            "sfx" in self.system.loaded_addons()
+            and "lfi" in self.system.loaded_addons()
+        )
         if not addon_checked:
             raise RuntimeError("The sfx addon is needed... please load it.")
         return addon_checked
 
     def _do_input_format_change(self, section, output_name, output_fmt):
-        (localpath, infmt) = (section.rh.container.localpath(),
-                              section.rh.container.actualfmt)
+        (localpath, infmt) = (
+            section.rh.container.localpath(),
+            section.rh.container.actualfmt,
+        )
         self.system.subtitle("Processing inputs/climatologies")
         if section.rh.container.actualfmt != output_fmt:
-            if infmt == 'fa' and output_fmt == 'lfi' and self._has_sfx_lfi:
+            if infmt == "fa" and output_fmt == "lfi" and self._has_sfx_lfi:
                 if self.system.path.exists(output_name):
-                    raise OSError("The file {!r} already exists.".format(output_name))
-                logger.info("Calling sfxtools' fa2lfi from %s to %s.", localpath, output_name)
+                    raise OSError(
+                        "The file {!r} already exists.".format(output_name)
+                    )
+                logger.info(
+                    "Calling sfxtools' fa2lfi from %s to %s.",
+                    localpath,
+                    output_name,
+                )
                 self.system.sfx_fa2lfi(localpath, output_name)
             else:
-                raise RuntimeError("Format conversion from {!r} to {!r} is not possible".format(
-                                   infmt, output_fmt))
+                raise RuntimeError(
+                    "Format conversion from {!r} to {!r} is not possible".format(
+                        infmt, output_fmt
+                    )
+                )
         else:
             if not self.system.path.exists(output_name):
                 logger.info("Linking %s to %s", localpath, output_name)
-                self.system.cp(localpath, output_name, intent=intent.IN, fmt=infmt)
+                self.system.cp(
+                    localpath, output_name, intent=intent.IN, fmt=infmt
+                )
 
     def _process_outputs(self, binrh, section, output_clim, output_name):
-        (radical, outfmt) = (self.system.path.splitext(section.rh.container.localpath())[0],
-                             self._actual_output_format(section.rh.container.actualfmt))
-        finaloutput = '{:s}_interpolated.{:s}'.format(radical, outfmt)
-        finallisting = '{:s}_listing'.format(radical)
+        (radical, outfmt) = (
+            self.system.path.splitext(section.rh.container.localpath())[0],
+            self._actual_output_format(section.rh.container.actualfmt),
+        )
+        finaloutput = "{:s}_interpolated.{:s}".format(radical, outfmt)
+        finallisting = "{:s}_listing".format(radical)
         self.system.subtitle("Processing outputs")
         if outfmt != self._actual_u_output_format:
             # There is a need for a format change
-            if outfmt == 'fa' and self._actual_u_output_format == 'lfi' and self._has_sfx_lfi:
-                logger.info("Calling lfitools' faempty from %s to %s.", output_clim, finaloutput)
+            if (
+                outfmt == "fa"
+                and self._actual_u_output_format == "lfi"
+                and self._has_sfx_lfi
+            ):
+                logger.info(
+                    "Calling lfitools' faempty from %s to %s.",
+                    output_clim,
+                    finaloutput,
+                )
                 self.system.fa_empty(output_clim, finaloutput)
-                logger.info("Calling sfxtools' lfi2fa from %s to %s.", output_name, finaloutput)
+                logger.info(
+                    "Calling sfxtools' lfi2fa from %s to %s.",
+                    output_name,
+                    finaloutput,
+                )
                 self.system.sfx_lfi2fa(output_name, finaloutput)
-                finallfi = '{:s}_interpolated.{:s}'.format(radical, self._actual_u_output_format)
+                finallfi = "{:s}_interpolated.{:s}".format(
+                    radical, self._actual_u_output_format
+                )
                 self.system.mv(output_name, finallfi)
             else:
-                raise RuntimeError("Format conversion from {!r} to {!r} is not possible".format(
-                                   self._actual_u_output_format, outfmt))
+                raise RuntimeError(
+                    "Format conversion from {!r} to {!r} is not possible".format(
+                        self._actual_u_output_format, outfmt
+                    )
+                )
         else:
             # No format change needed
             logger.info("Moving %s to %s", output_name, finaloutput)
             self.system.mv(output_name, finaloutput, fmt=outfmt)
         # Also rename the listing :-)
-        if binrh.resource.cycle < 'cy48t1':
+        if binrh.resource.cycle < "cy48t1":
             try:
-                self.system.mv('LISTING_PREP.txt', finallisting)
+                self.system.mv("LISTING_PREP.txt", finallisting)
             except OSError:
-                self.system.mv('LISTING_PREP0.txt', finallisting)
+                self.system.mv("LISTING_PREP0.txt", finallisting)
         else:
-            self.system.mv('LISTING_PREP0.txt', finallisting)
+            self.system.mv("LISTING_PREP0.txt", finallisting)
         return finaloutput
 
     def _prepare_prep_hook(self, rh, opts):
         """Default pre-link for namelist file and domain change."""
         # Convert the initial clim if needed...
-        iniclim = self.context.sequence.effective_inputs(role=('InitialClim',))
+        iniclim = self.context.sequence.effective_inputs(role=("InitialClim",))
         if not (len(iniclim) == 1):
             raise AlgoComponentError("One Initial clim have to be provided")
-        self._do_input_format_change(iniclim[0],
-                                     'PGD1.' + self._sfx_fmt_remap(self.underlyingformat),
-                                     self.underlyingformat)
+        self._do_input_format_change(
+            iniclim[0],
+            "PGD1." + self._sfx_fmt_remap(self.underlyingformat),
+            self.underlyingformat,
+        )
         # Convert the target clim if needed...
-        targetclim = self.context.sequence.effective_inputs(role=('TargetClim',))
+        targetclim = self.context.sequence.effective_inputs(
+            role=("TargetClim",)
+        )
         if not (len(targetclim) == 1):
             raise AlgoComponentError("One Target clim have to be provided")
-        self._do_input_format_change(targetclim[0],
-                                     'PGD2.' + self._sfx_fmt_remap(self._actual_u_output_format),
-                                     self._actual_u_output_format)
+        self._do_input_format_change(
+            targetclim[0],
+            "PGD2." + self._sfx_fmt_remap(self._actual_u_output_format),
+            self._actual_u_output_format,
+        )
 
-    _MIXIN_PREPARE_HOOKS = (_prepare_prep_hook, )
+    _MIXIN_PREPARE_HOOKS = (_prepare_prep_hook,)
 
     def _spawn_hook_prep_hook(self):
         """Dump the namelists."""
-        for namsec in self.context.sequence.effective_inputs(kind=('namelist', )):
-            self.system.subtitle("Here is the content of the {:s} namelist"
-                                 .format(namsec.rh.container.actualpath()))
+        for namsec in self.context.sequence.effective_inputs(
+            kind=("namelist",)
+        ):
+            self.system.subtitle(
+                "Here is the content of the {:s} namelist".format(
+                    namsec.rh.container.actualpath()
+                )
+            )
             namsec.rh.container.cat()
 
-    _MIXIN_SPAWN_HOOKS = (_spawn_hook_prep_hook, )
+    _MIXIN_SPAWN_HOOKS = (_spawn_hook_prep_hook,)
 
     def _execute_prep_common(self, rh, opts):
         """Loop on the various initial conditions provided."""
         sh = self.system
 
         cplsec = self.context.sequence.effective_inputs(
-            role=('InitialCondition', 'CouplingSource'),
-            kind=('historic', 'analysis')
+            role=("InitialCondition", "CouplingSource"),
+            kind=("historic", "analysis"),
         )
         cplsec.sort(key=lambda s: s.rh.resource.term)
-        infile = 'PREP1.{:s}'.format(self._sfx_fmt_remap(self.underlyingformat))
-        outfile = 'PREP2.{:s}'.format(self._sfx_fmt_remap(self._actual_u_output_format))
-        targetclim = self.context.sequence.effective_inputs(role=('TargetClim',))
+        infile = "PREP1.{:s}".format(
+            self._sfx_fmt_remap(self.underlyingformat)
+        )
+        outfile = "PREP2.{:s}".format(
+            self._sfx_fmt_remap(self._actual_u_output_format)
+        )
+        targetclim = self.context.sequence.effective_inputs(
+            role=("TargetClim",)
+        )
         targetclim = targetclim[0].rh.container.localpath()
 
         for sec in cplsec:
             r = sec.rh
-            sh.header('Loop on {:s}'.format(r.container.localpath()))
+            sh.header("Loop on {:s}".format(r.container.localpath()))
 
             # Expect the coupling source to be there...
-            self.grab(sec, comment='coupling source')
+            self.grab(sec, comment="coupling source")
 
             # Set the actual init file
             if sh.path.exists(infile):
-                logger.critical('Cannot process input files if %s exists.', infile)
+                logger.critical(
+                    "Cannot process input files if %s exists.", infile
+                )
             self._do_input_format_change(sec, infile, self.underlyingformat)
 
             # Standard execution
@@ -423,27 +556,43 @@ class PrepMixin(AlgoComponentDecoMixin):
             actualname = self._process_outputs(rh, sec, targetclim, outfile)
 
             # promises management
-            expected = [x for x in self.promises if x.rh.container.localpath() == actualname]
+            expected = [
+                x
+                for x in self.promises
+                if x.rh.container.localpath() == actualname
+            ]
             if expected:
                 for thispromise in expected:
                     thispromise.put(incache=True)
 
             # Some cleaning
-            sh.rmall('*.des')
-            sh.rmall('PREP1.*')
+            sh.rmall("*.des")
+            sh.rmall("PREP1.*")
 
     _MIXIN_EXECUTE_OVERWRITE = _execute_prep_common
 
 
-class Prep(BlindRun, PrepMixin, CouplingBaseDateNamMixin,
-           DrHookDecoMixin, EcGribDecoMixin):
+class Prep(
+    BlindRun,
+    PrepMixin,
+    CouplingBaseDateNamMixin,
+    DrHookDecoMixin,
+    EcGribDecoMixin,
+):
     """Coupling/Interpolation of Surfex files (non-MPI version)."""
+
     pass
 
 
-class ParallelPrep(Parallel, PrepMixin, CouplingBaseDateNamMixin,
-                   DrHookDecoMixin, EcGribDecoMixin):
+class ParallelPrep(
+    Parallel,
+    PrepMixin,
+    CouplingBaseDateNamMixin,
+    DrHookDecoMixin,
+    EcGribDecoMixin,
+):
     """Coupling/Interpolation of Surfex files (MPI version)."""
+
     pass
 
 
@@ -451,18 +600,16 @@ class C901(IFSParallel):
     """Run of C901 configuration."""
 
     _footprint = dict(
-        info = "Run C901 configuration",
-        attr = dict(
-            kind = dict(
-                values = ["c901", ]
-            ),
-            clim = dict(
-                type = bool
+        info="Run C901 configuration",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "c901",
+                ]
             ),
-            xpname = dict(
-                default = 'a001'
-            )
-        )
+            clim=dict(type=bool),
+            xpname=dict(default="a001"),
+        ),
     )
 
     SPECTRAL_FILE_SH = "ICMSH{prefix}INIT{suffix}"
@@ -470,12 +617,16 @@ class C901(IFSParallel):
     GRIDPOINT_FILE_GG = "ICMGG{prefix}INIT{suffix}"
     OUTPUT_FILE_NAME = "CN90x{}INIT"
     OUTPUT_LISTING_NAME = "NODE.001_01"
-    LIST_INPUT_FILES = [("SpectralFileSH", SPECTRAL_FILE_SH),
-                        ("GridpointFileUA", GRIDPOINT_FILE_UA),
-                        ("GridpointFileGG", GRIDPOINT_FILE_GG)]
-    LIST_CST_INPUT_FILES = [("ConstantSpectralFileSH", SPECTRAL_FILE_SH),
-                            ("ConstantGridpointFileUA", GRIDPOINT_FILE_UA),
-                            ("ConstantGridpointFileGG", GRIDPOINT_FILE_GG)]
+    LIST_INPUT_FILES = [
+        ("SpectralFileSH", SPECTRAL_FILE_SH),
+        ("GridpointFileUA", GRIDPOINT_FILE_UA),
+        ("GridpointFileGG", GRIDPOINT_FILE_GG),
+    ]
+    LIST_CST_INPUT_FILES = [
+        ("ConstantSpectralFileSH", SPECTRAL_FILE_SH),
+        ("ConstantGridpointFileUA", GRIDPOINT_FILE_UA),
+        ("ConstantGridpointFileGG", GRIDPOINT_FILE_GG),
+    ]
 
     @property
     def realkind(self):
@@ -484,30 +635,47 @@ class C901(IFSParallel):
     def sort_files_per_prefix(self, list_types, unique=False):
         """Function used to sort the files according to their prefix in a given type"""
         result = dict()
-        for (file_role, file_template) in list_types:
+        for file_role, file_template in list_types:
             result[file_role] = dict()
             input_files = self.context.sequence.effective_inputs(
                 role=file_role
             )
-            template = file_template.format(prefix=r"(?P<prefix>\S{4})", suffix=r"(?P<suffix>\S*)")
+            template = file_template.format(
+                prefix=r"(?P<prefix>\S{4})", suffix=r"(?P<suffix>\S*)"
+            )
             for file_s in input_files:
                 file_name = file_s.rh.container.filename
                 find_elements = re.search(template, file_name)
                 if find_elements is None:
-                    logger.error("The name of the file %s do not follow the template %s.",
-                                 file_name, template)
-                    raise ValueError("The name of the file do not follow the template.")
+                    logger.error(
+                        "The name of the file %s do not follow the template %s.",
+                        file_name,
+                        template,
+                    )
+                    raise ValueError(
+                        "The name of the file do not follow the template."
+                    )
                 else:
                     if find_elements.group("prefix") not in result[file_role]:
-                        result[file_role][find_elements.group("prefix")] = list()
+                        result[file_role][find_elements.group("prefix")] = (
+                            list()
+                        )
                     else:
                         if unique:
-                            logger.error("Only one file should be present for each type and each suffix.")
-                            raise ValueError("Only one file should be present for each suffix.")
-                    result[file_role][find_elements.group("prefix")].append(file_s)
+                            logger.error(
+                                "Only one file should be present for each type and each suffix."
+                            )
+                            raise ValueError(
+                                "Only one file should be present for each suffix."
+                            )
+                    result[file_role][find_elements.group("prefix")].append(
+                        file_s
+                    )
             if result[file_role]:
                 for file_prefix in result[file_role]:
-                    result[file_role][file_prefix].sort(key=lambda s: s.rh.resource.date + s.rh.resource.term)
+                    result[file_role][file_prefix].sort(
+                        key=lambda s: s.rh.resource.date + s.rh.resource.term
+                    )
             else:
                 del result[file_role]
         return result
@@ -518,13 +686,21 @@ class C901(IFSParallel):
         sh = self.system
 
         # Create the template for files to be removed at each validity date and for the outputname
-        deleted_spectral_file_SH = self.SPECTRAL_FILE_SH.format(prefix="*", suffix="")
-        deleted_gridpoint_file_UA = self.GRIDPOINT_FILE_UA.format(prefix="*", suffix="")
-        deleted_gridpoint_file_GG = self.GRIDPOINT_FILE_GG.format(prefix="*", suffix="")
+        deleted_spectral_file_SH = self.SPECTRAL_FILE_SH.format(
+            prefix="*", suffix=""
+        )
+        deleted_gridpoint_file_UA = self.GRIDPOINT_FILE_UA.format(
+            prefix="*", suffix=""
+        )
+        deleted_gridpoint_file_GG = self.GRIDPOINT_FILE_GG.format(
+            prefix="*", suffix=""
+        )
         output_name = self.OUTPUT_FILE_NAME.format(self.xpname.upper())
 
         # Sort input files
-        sorted_cst_input_files = self.sort_files_per_prefix(self.LIST_CST_INPUT_FILES, unique=True)
+        sorted_cst_input_files = self.sort_files_per_prefix(
+            self.LIST_CST_INPUT_FILES, unique=True
+        )
         sorted_input_files = self.sort_files_per_prefix(self.LIST_INPUT_FILES)
 
         # Determine the validity present for each non constant input files,
@@ -533,77 +709,123 @@ class C901(IFSParallel):
         input_validity = list()
         for file_role in sorted_input_files:
             for file_prefix in sorted_input_files[file_role]:
-                input_validity.append([s.rh.resource.date + s.rh.resource.term
-                                       for s in sorted_input_files[file_role][file_prefix]])
+                input_validity.append(
+                    [
+                        s.rh.resource.date + s.rh.resource.term
+                        for s in sorted_input_files[file_role][file_prefix]
+                    ]
+                )
         test_wrong_input_validity = True
         for i in range(1, len(input_validity)):
-            test_wrong_input_validity = test_wrong_input_validity and (input_validity[0] == input_validity[i])
-        self.algoassert(test_wrong_input_validity,
-                        "The files of each type must have the same validity dates.")
+            test_wrong_input_validity = test_wrong_input_validity and (
+                input_validity[0] == input_validity[i]
+            )
+        self.algoassert(
+            test_wrong_input_validity,
+            "The files of each type must have the same validity dates.",
+        )
 
         # Modify namelist
         input_namelist = self.context.sequence.effective_inputs(
-            role="Namelist",
-            kind="namelist"
+            role="Namelist", kind="namelist"
         )
         for namelist in input_namelist:
             namcontents = namelist.rh.contents
-            self._set_nam_macro(namcontents, namelist.rh.container.actualpath(),
-                                'LLCLIM', self.clim)
+            self._set_nam_macro(
+                namcontents,
+                namelist.rh.container.actualpath(),
+                "LLCLIM",
+                self.clim,
+            )
             if namcontents.dumps_needs_update:
                 namcontents.rewrite(namelist.rh.container)
 
         for current_validity in input_validity[0]:
             # Deal with constant input files (gridpoint and spectral)
-            for (file_role, file_template) in self.LIST_CST_INPUT_FILES:
+            for file_role, file_template in self.LIST_CST_INPUT_FILES:
                 if file_role in sorted_cst_input_files:
                     for file_prefix in sorted_cst_input_files[file_role]:
-                        file_name = file_template.format(prefix=file_prefix, suffix="")
-                        current_file_input = sorted_cst_input_files[file_role][file_prefix][0]
-                        self.algoassert(not sh.path.exists(file_name),
-                                        "The file {} already exists. It should not.".format(file_name))
-                        sh.cp(current_file_input.rh.container.iotarget(), file_name, intent="in")
+                        file_name = file_template.format(
+                            prefix=file_prefix, suffix=""
+                        )
+                        current_file_input = sorted_cst_input_files[file_role][
+                            file_prefix
+                        ][0]
+                        self.algoassert(
+                            not sh.path.exists(file_name),
+                            "The file {} already exists. It should not.".format(
+                                file_name
+                            ),
+                        )
+                        sh.cp(
+                            current_file_input.rh.container.iotarget(),
+                            file_name,
+                            intent="in",
+                        )
 
             # Deal with other input files (gridpoint and spectral)
-            for (file_role, file_template) in self.LIST_INPUT_FILES:
+            for file_role, file_template in self.LIST_INPUT_FILES:
                 if file_role in sorted_input_files:
                     for file_prefix in sorted_input_files[file_role]:
-                        file_name = file_template.format(prefix=file_prefix, suffix="")
-                        current_file_input = sorted_input_files[file_role][file_prefix].pop()
-                        self.algoassert(not sh.path.exists(file_name),
-                                        "The file {} already exists. It should not.".format(file_name))
-                        sh.cp(current_file_input.rh.container.iotarget(), file_name, intent="in")
+                        file_name = file_template.format(
+                            prefix=file_prefix, suffix=""
+                        )
+                        current_file_input = sorted_input_files[file_role][
+                            file_prefix
+                        ].pop()
+                        self.algoassert(
+                            not sh.path.exists(file_name),
+                            "The file {} already exists. It should not.".format(
+                                file_name
+                            ),
+                        )
+                        sh.cp(
+                            current_file_input.rh.container.iotarget(),
+                            file_name,
+                            intent="in",
+                        )
 
             if self.clim:
                 # Find the right climatology file
                 current_month = date.Month(current_validity)
-                self.climfile_fixer(rh, convkind='modelclim', month=current_month,
-                                    inputrole=('GlobalClim', 'InitialClim'),
-                                    inputkind='clim_model')
+                self.climfile_fixer(
+                    rh,
+                    convkind="modelclim",
+                    month=current_month,
+                    inputrole=("GlobalClim", "InitialClim"),
+                    inputkind="clim_model",
+                )
 
             # Standard execution
             super().execute(rh, opts)
             # Move the output file
             current_term = current_file_input.rh.resource.term
-            sh.move(output_name, output_name + "+{}".format(current_term.fmthm))
+            sh.move(
+                output_name, output_name + "+{}".format(current_term.fmthm)
+            )
             # Cat all the listings into a single one
-            sh.cat(self.OUTPUT_LISTING_NAME, output='NODE.all')
+            sh.cat(self.OUTPUT_LISTING_NAME, output="NODE.all")
             # Remove unneeded files
-            sh.rmall(deleted_spectral_file_SH, deleted_gridpoint_file_GG, deleted_gridpoint_file_UA,
-                     'std*', self.OUTPUT_LISTING_NAME)
+            sh.rmall(
+                deleted_spectral_file_SH,
+                deleted_gridpoint_file_GG,
+                deleted_gridpoint_file_UA,
+                "std*",
+                self.OUTPUT_LISTING_NAME,
+            )
 
 
 class DomeoForcingAtmo(BlindRun, CouplingBaseDateNamMixin):
     """Correct the Domeo forcing file."""
 
     _footprint = dict(
-        info='Domeo Forcing Atmo',
+        info="Domeo Forcing Atmo",
         attr=dict(
             kind=dict(
-                values=['domeo_forcing'],
+                values=["domeo_forcing"],
             ),
             basedate=dict(
                 optional=False,
             ),
-        )
+        ),
     )