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

vortex/nwp/data/ctpini.py

@@ -22,15 +22,15 @@ class CtpiniDirectiveFile(GeoFlowResource):
     """
 
     _footprint = dict(
-        info = "Ctpini directive file",
-        attr = dict(
-            kind = dict(
-                values = ["ctpini_directives_file", ],
+        info="Ctpini directive file",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "ctpini_directives_file",
+                ],
             ),
-            nativefmt = dict(
-                default = "ascii"
-            )
-        )
+            nativefmt=dict(default="ascii"),
+        ),
     )
 
     @property
@@ -47,8 +47,8 @@ class AsciiFiles(StaticResource):
     _footprint = [
         gvar,
         dict(
-            info = 'Abstract class for ascii files from genv.',
-        )
+            info="Abstract class for ascii files from genv.",
+        ),
     ]
 
 
@@ -59,21 +59,19 @@ class CtpiniAsciiFiles(AsciiFiles):
 
     _footprint = [
         dict(
-            info = "Ctpini Genv ascii files.",
-            attr = dict(
-                kind = dict(
-                    values = ["ctpini_ascii_file"],
-                ),
-                source = dict(
-                    values = ["levels", "covano", "fort61", "coor", "cov46"],
+            info="Ctpini Genv ascii files.",
+            attr=dict(
+                kind=dict(
+                    values=["ctpini_ascii_file"],
                 ),
-                gvar = dict(
-                    default = "tsr_misc_[source]",
+                source=dict(
+                    values=["levels", "covano", "fort61", "coor", "cov46"],
                 ),
-                clscontents=dict(
-                    default = DataTemplate
+                gvar=dict(
+                    default="tsr_misc_[source]",
                 ),
-            )
+                clscontents=dict(default=DataTemplate),
+            ),
         )
     ]
 
@@ -88,31 +86,49 @@ class GridPointCtpini(GridPoint):
     """
 
     _footprint = dict(
-        info = 'Ctpini Gridpoint Fields',
-        attr = dict(
-            kind = dict(
-                values = ['ctpini_gridpoint', ],
+        info="Ctpini Gridpoint Fields",
+        attr=dict(
+            kind=dict(
+                values=[
+                    "ctpini_gridpoint",
+                ],
             ),
-            origin = dict(
-                values = ['oper', 'PS', 'dble', 'PX', 'ctpini', 'PTSR', ],
-                remap = dict(
-                    PS = 'oper',
-                    PX = 'dble',
-                    PTSR = 'ctpini',
+            origin=dict(
+                values=[
+                    "oper",
+                    "PS",
+                    "dble",
+                    "PX",
+                    "ctpini",
+                    "PTSR",
+                ],
+                remap=dict(
+                    PS="oper",
+                    PX="dble",
+                    PTSR="ctpini",
                 ),
             ),
-            parameter = dict(
-                values = ['PMERSOL', 'T850HPA', 'Z15PVU', 'Z20PVU', 'Z07PVU', 'TROPO'],
+            parameter=dict(
+                values=[
+                    "PMERSOL",
+                    "T850HPA",
+                    "Z15PVU",
+                    "Z20PVU",
+                    "Z07PVU",
+                    "TROPO",
+                ],
             ),
-            run_ctpini = dict(
-                optional = True,
-                default = None,
+            run_ctpini=dict(
+                optional=True,
+                default=None,
             ),
-            nativefmt = dict(
-                values = ['geo', ],
-                default = 'geo',
+            nativefmt=dict(
+                values=[
+                    "geo",
+                ],
+                default="geo",
             ),
-        )
+        ),
     )
 
     @property
@@ -122,12 +138,12 @@ class GridPointCtpini(GridPoint):
     def namebuilding_info(self):
         """Generic information, radical = ``grid``."""
         ninfo = super().namebuilding_info()
-        if self.origin == 'ctpini' and self.run_ctpini is not None:
+        if self.origin == "ctpini" and self.run_ctpini is not None:
             source = [self.model, self.origin, self.parameter, self.run_ctpini]
         else:
             source = [self.model, self.origin, self.parameter]
         ninfo.update(
-            radical='ctpini-grid',
+            radical="ctpini-grid",
             src=source,
         )
         return ninfo

vortex/nwp/data/diagnostics.py

@@ -6,7 +6,11 @@ import footprints
 
 from vortex.data.flow import GeoFlowResource, GeoPeriodFlowResource
 from vortex.syntax.stdattrs import term_deco
-from vortex.syntax.stddeco import namebuilding_append, namebuilding_insert, overwrite_realkind
+from vortex.syntax.stddeco import (
+    namebuilding_append,
+    namebuilding_insert,
+    overwrite_realkind,
+)
 
 #: No automatic export
 __all__ = []
@@ -16,51 +20,49 @@ class ISP(GeoFlowResource):
     """Class for Forecasted Satellite Image resource. Obsolete."""
 
     _footprint = dict(
-        info = 'Forecasted Satellite Image',
-        attr = dict(
-            kind = dict(
-                values = ['isp', 'fsi']
-            ),
-            nativefmt = dict(
-                values = ['foo', ],
-                default = 'foo',
+        info="Forecasted Satellite Image",
+        attr=dict(
+            kind=dict(values=["isp", "fsi"]),
+            nativefmt=dict(
+                values=[
+                    "foo",
+                ],
+                default="foo",
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'isp'
+        return "isp"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'anim0'
+        return "anim0"
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        return 'ISP' + self.model[:4].upper()
+        return "ISP" + self.model[:4].upper()
 
 
-@namebuilding_insert('radical', lambda s: 'ddh')
-@namebuilding_append('src', lambda s: s.scope)
+@namebuilding_insert("radical", lambda s: "ddh")
+@namebuilding_append("src", lambda s: s.scope)
 class _DDHcommon(GeoFlowResource):
     """
     Abstract class for Horizontal Diagnostics.
     """
+
     _abstract = True
     _footprint = dict(
-        info = 'Diagnostic on Horizontal Domains',
-        attr = dict(
-            kind = dict(
-                values = ['ddh', 'dhf'],
-                remap = dict(dhf='ddh')
-            ),
-            nativefmt = dict(),
-            scope = dict(
-                values = ['limited', 'dlimited', 'global', 'zonal'],
-                remap = dict(limited='dlimited')
+        info="Diagnostic on Horizontal Domains",
+        attr=dict(
+            kind=dict(values=["ddh", "dhf"], remap=dict(dhf="ddh")),
+            nativefmt=dict(),
+            scope=dict(
+                values=["limited", "dlimited", "global", "zonal"],
+                remap=dict(limited="dlimited"),
             ),
-        )
+        ),
     )
 
 
@@ -69,30 +71,35 @@ class DDH(_DDHcommon):
     Class for Horizontal Diagnostics.
     Used to be a ``dhf`` !
     """
+
     _footprint = [
         term_deco,
         dict(
-            info = 'Diagnostic on Horizontal Domains',
-            attr = dict(
-                nativefmt = dict(
-                    values = ['lfi', 'lfa'],
-                    default = 'lfi',
+            info="Diagnostic on Horizontal Domains",
+            attr=dict(
+                nativefmt=dict(
+                    values=["lfi", "lfa"],
+                    default="lfi",
                 ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'ddh'
+        return "ddh"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'dhf{:s}{:s}+{:s}'.format(self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth)
+        return "dhf{:s}{:s}+{:s}".format(
+            self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth
+        )
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        return 'DHF{:s}{:s}+{:s}'.format(self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth)
+        return "DHF{:s}{:s}+{:s}".format(
+            self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth
+        )
 
 
 class DDHpack(_DDHcommon):
@@ -100,43 +107,56 @@ class DDHpack(_DDHcommon):
     Class for Horizontal Diagnostics with all terms packed in a single directory.
     Used to be a ``dhf`` !
     """
+
     _footprint = dict(
-        info = 'Diagnostic on Horizontal Domains packed in a single directory',
-        attr = dict(
-            nativefmt = dict(
-                values = ['ddhpack', ],
+        info="Diagnostic on Horizontal Domains packed in a single directory",
+        attr=dict(
+            nativefmt=dict(
+                values=[
+                    "ddhpack",
+                ],
             ),
-        )
+        ),
     )
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        return 'DHF{:s}{:s}.tar'.format(self.scope[:2].upper(), self.model[:4].upper())
+        return "DHF{:s}{:s}.tar".format(
+            self.scope[:2].upper(), self.model[:4].upper()
+        )
 
     @property
     def realkind(self):
-        return 'ddhpack'
+        return "ddhpack"
 
 
 _surfex_diag_decofp = footprints.DecorativeFootprint(
-    info='Diagnostic files outputed by surfex during a model run',
+    info="Diagnostic files outputed by surfex during a model run",
     attr=dict(
         kind=dict(
-            values=['diagnostics', ]
-        ),
-        scope=dict(
+            values=[
+                "diagnostics",
+            ]
         ),
+        scope=dict(),
         model=dict(
-            values=['surfex', ]
+            values=[
+                "surfex",
+            ]
         ),
         nativefmt=dict(
-            values=['netcdf', 'grib', ],
-            default='netcdf',
-            optional=True
+            values=[
+                "netcdf",
+                "grib",
+            ],
+            default="netcdf",
+            optional=True,
         ),
     ),
-    decorator=[namebuilding_append('src', lambda s: s.scope),
-               overwrite_realkind('diagnostics')]
+    decorator=[
+        namebuilding_append("src", lambda s: s.scope),
+        overwrite_realkind("diagnostics"),
+    ],
 )
 
 
@@ -149,33 +169,41 @@ class SurfexDiagnostics(GeoFlowResource):
 class SurfexPeriodDiagnostics(GeoPeriodFlowResource):
     """Diagnostic files outputed by surfex during a model run (period version)."""
 
-    _footprint = [_surfex_diag_decofp, ]
+    _footprint = [
+        _surfex_diag_decofp,
+    ]
 
 
 class ObjTrack(GeoFlowResource):
     """Class for Object Tracks."""
 
     _footprint = dict(
-        info = 'Object Tracks json file',
-        attr = dict(
-            kind = dict(
-                values = ['objtrack']
-            ),
-            nativefmt = dict(
-                values = ['json', 'hdf5', 'foo', ],
-                default = 'foo',
+        info="Object Tracks json file",
+        attr=dict(
+            kind=dict(values=["objtrack"]),
+            nativefmt=dict(
+                values=[
+                    "json",
+                    "hdf5",
+                    "foo",
+                ],
+                default="foo",
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'objtrack'
+        return "objtrack"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'track{:s}{:s}+{:s}'.format(self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth)
+        return "track{:s}{:s}+{:s}".format(
+            self.scope[:2].lower(), self.model[:4].lower(), self.term.fmth
+        )
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
-        return 'track{:s}{:s}+{:s}'.format(self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth)
+        return "track{:s}{:s}+{:s}".format(
+            self.scope[:2].upper(), self.model[:4].upper(), self.term.fmth
+        )

vortex/nwp/data/eda.py

@@ -16,7 +16,9 @@ __all__ = []
 logger = loggers.getLogger(__name__)
 
 
-@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+@namebuilding_insert(
+    "geo", lambda s: s._geo2basename_info(add_stretching=False)
+)
 class RawFiles(GeoFlowResource):
     """Input files for wavelet covariances estimation. To be removed soon."""
 
@@ -24,23 +26,21 @@ class RawFiles(GeoFlowResource):
         term_deco,
         gvar,
         dict(
-            info = 'Input files for wavelet covariances estimation',
-            attr = dict(
-                kind = dict(
-                    values   = ['rawfiles'],
+            info="Input files for wavelet covariances estimation",
+            attr=dict(
+                kind=dict(
+                    values=["rawfiles"],
                 ),
-                nativefmt   = dict(
-                    values  = ['rawfiles', 'unknown'],
+                nativefmt=dict(
+                    values=["rawfiles", "unknown"],
                 ),
-                gvar = dict(
-                    default = 'aearp_rawfiles_t[geometry:truncation]'
+                gvar=dict(default="aearp_rawfiles_t[geometry:truncation]"),
+                ipert=dict(
+                    type=int,
+                    optional=True,
                 ),
-                ipert = dict(
-                    type = int,
-                    optional = True,
-                ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
@@ -49,7 +49,9 @@ class RawFiles(GeoFlowResource):
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'RAWFILEP(memberfix:member)+{:s}.{:d}'.format(self.term.fmthour, self.geometry.truncation)
+        return "RAWFILEP(memberfix:member)+{:s}.{:d}".format(
+            self.term.fmthour, self.geometry.truncation
+        )
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
@@ -58,11 +60,13 @@ class RawFiles(GeoFlowResource):
     def gget_basename(self):
         """GGET specific naming convention."""
         if self.ipert is None:
-            raise ValueError('ipert is mandatory with the GCO provider')
-        return dict(suffix='.{:03d}.tar'.format(self.ipert))
+            raise ValueError("ipert is mandatory with the GCO provider")
+        return dict(suffix=".{:03d}.tar".format(self.ipert))
 
 
-@namebuilding_insert('geo', lambda s: s._geo2basename_info(add_stretching=False))
+@namebuilding_insert(
+    "geo", lambda s: s._geo2basename_info(add_stretching=False)
+)
 class RandBFiles(GeoFlowResource):
     """Input files for wavelet covariances estimation."""
 
@@ -70,33 +74,33 @@ class RandBFiles(GeoFlowResource):
         term_deco,
         gvar,
         dict(
-            info = 'Input files for wavelet covariances estimation',
-            attr = dict(
-                kind = dict(
-                    values   = ['randbfiles', 'famembers'],
-                    remap    = dict(autoremap = 'first')
-                ),
-                nativefmt   = dict(
-                    values  = ['fa', 'unknown'],
+            info="Input files for wavelet covariances estimation",
+            attr=dict(
+                kind=dict(
+                    values=["randbfiles", "famembers"],
+                    remap=dict(autoremap="first"),
                 ),
-                gvar = dict(
-                    default = 'aearp_randb_t[geometry:truncation]'
+                nativefmt=dict(
+                    values=["fa", "unknown"],
                 ),
-                ipert = dict(
-                    type = int,
-                    optional = True,
+                gvar=dict(default="aearp_randb_t[geometry:truncation]"),
+                ipert=dict(
+                    type=int,
+                    optional=True,
                 ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'randbfiles'
+        return "randbfiles"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""
-        return 'famember(memberfix:member)+{:s}.{:d}'.format(self.term.fmthour, self.geometry.truncation)
+        return "famember(memberfix:member)+{:s}.{:d}".format(
+            self.term.fmthour, self.geometry.truncation
+        )
 
     def olive_basename(self):
         """OLIVE specific naming convention."""
@@ -105,8 +109,8 @@ class RandBFiles(GeoFlowResource):
     def gget_basename(self):
         """GGET specific naming convention."""
         if self.ipert is None:
-            raise ValueError('ipert is mandatory with the GCO provider')
-        return dict(suffix='.{:03d}.{}'.format(self.ipert, 'fa'))
+            raise ValueError("ipert is mandatory with the GCO provider")
+        return dict(suffix=".{:03d}.{}".format(self.ipert, "fa"))
 
 
 class InflationFactor(_BackgroundErrorInfo):
@@ -115,29 +119,24 @@ class InflationFactor(_BackgroundErrorInfo):
     """
 
     _footprint = dict(
-        info='Inflation factor profiles',
+        info="Inflation factor profiles",
         attr=dict(
             kind=dict(
-                values=['infl_factor', 'infl', 'inflation_factor'],
-                remap=dict(autoremap='first'),
-            ),
-            gvar = dict(
-                default = 'inflation_factor'
+                values=["infl_factor", "infl", "inflation_factor"],
+                remap=dict(autoremap="first"),
             ),
+            gvar=dict(default="inflation_factor"),
             nativefmt=dict(
-                values=['ascii'],
-                default='ascii',
-            ),
-            term=dict(
-                optional=True,
-                default=3
+                values=["ascii"],
+                default="ascii",
             ),
+            term=dict(optional=True, default=3),
         ),
     )
 
     @property
     def realkind(self):
-        return 'inflation_factor'
+        return "inflation_factor"
 
     def archive_basename(self):
         """OP ARCHIVE specific naming convention."""