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

vortex/nwp/data/oopsexec.py

@@ -11,7 +11,7 @@ from vortex.syntax.stddeco import namebuilding_append
 __all__ = []
 
 
-@namebuilding_append('src', lambda self: self.run)
+@namebuilding_append("src", lambda self: self.run)
 class OOPSBinary(NWPModel):
     """Yet an other OOPS Binary."""
 
@@ -21,30 +21,32 @@ class OOPSBinary(NWPModel):
         oops_run,
         executable_flavour_deco,
         dict(
-            info = 'OOPS Binary: an OOPS binary, dedicated to a task (a run in OOPS namespace).',
-            attr = dict(
-                kind = dict(
-                    values = ['oopsbinary', ],
+            info="OOPS Binary: an OOPS binary, dedicated to a task (a run in OOPS namespace).",
+            attr=dict(
+                kind=dict(
+                    values=[
+                        "oopsbinary",
+                    ],
                 ),
-                gvar = dict(
-                    default = 'master_[run]',
+                gvar=dict(
+                    default="master_[run]",
                 ),
-                run = dict(
-                    outcast = known_oops_testcomponent_runs,
+                run=dict(
+                    outcast=known_oops_testcomponent_runs,
                 ),
-            )
-        )
+            ),
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'oopsbinary'
+        return "oopsbinary"
 
     def command_line(self, configfile):
         """
         Build command line for execution as a single string.
         """
-        cmdline = '{}'.format(configfile)
+        cmdline = "{}".format(configfile)
         return cmdline
 
 
@@ -52,11 +54,11 @@ class OOPSTestComponent(OOPSBinary):
     """Binary for OOPS Tests of components."""
 
     _footprint = dict(
-        info = 'OOPS Component Test: can run a sub-test or a family of sub-tests',
-        attr = dict(
-            run = dict(
-                values   = known_oops_testcomponent_runs,
-                outcast  = [],
+        info="OOPS Component Test: can run a sub-test or a family of sub-tests",
+        attr=dict(
+            run=dict(
+                values=known_oops_testcomponent_runs,
+                outcast=[],
             ),
         ),
     )
@@ -65,8 +67,8 @@ class OOPSTestComponent(OOPSBinary):
         """
         Build command line for execution as a single string.
         """
-        cmdline = ''
+        cmdline = ""
         if test_type is not None:
-            cmdline += '-t {} '.format(test_type)
+            cmdline += "-t {} ".format(test_type)
         cmdline += super().command_line(configfile)
         return cmdline

vortex/nwp/data/providers.py

@@ -20,16 +20,19 @@ logger = loggers.getLogger(__name__)
 
 class BdpeError(Exception):
     """Base for Bdpe errors."""
+
     pass
 
 
 class BdpeConfigurationError(BdpeError):
     """Missing BDPE product description."""
+
     pass
 
 
 class BdpeMismatchError(BdpeError):
     """BDPE product description does not match ressource description."""
+
     pass
 
 
@@ -58,71 +61,84 @@ class BdpeProvider(Provider):
     _footprint = [
         namespacefp,
         dict(
-            info = 'BDPE provider',
-            attr = dict(
-                namespace = dict(
-                    default  = Namespace('bdpe.archive.fr'),
-                    values   = ['bdpe.archive.fr'],
+            info="BDPE provider",
+            attr=dict(
+                namespace=dict(
+                    default=Namespace("bdpe.archive.fr"),
+                    values=["bdpe.archive.fr"],
                 ),
-                bdpeid = dict(
+                bdpeid=dict(),
+                preferred_target=dict(
+                    info="The database we'd like to get the data from - See the BDPE documentation.",
+                    optional=True,
+                    default=DelayedEnvValue("BDPE_CIBLE_PREFEREE", "SEC"),
+                    values=[
+                        "OPER",
+                        "INT",
+                        "SEC",
+                        "oper",
+                        "int",
+                        "sec",
+                    ],
                 ),
-                preferred_target = dict(
-                    info     = "The database we'd like to get the data from - See the BDPE documentation.",
-                    optional = True,
-                    default  = DelayedEnvValue('BDPE_CIBLE_PREFEREE', 'SEC'),
-                    values   = ['OPER', 'INT', 'SEC',
-                                'oper', 'int', 'sec', ],
+                forbidden_target=dict(
+                    info="The database we don't want to access - See the BDPE documentation.",
+                    optional=True,
+                    default=DelayedEnvValue("BDPE_CIBLE_INTERDITE", "OPER"),
+                    values=[
+                        "OPER",
+                        "INT",
+                        "SEC",
+                        "oper",
+                        "int",
+                        "sec",
+                    ],
                 ),
-                forbidden_target = dict(
-                    info     = "The database we don't want to access - See the BDPE documentation.",
-                    optional = True,
-                    default  = DelayedEnvValue('BDPE_CIBLE_INTERDITE', 'OPER'),
-                    values   = ['OPER', 'INT', 'SEC',
-                                'oper', 'int', 'sec', ],
+                soprano_domain=dict(
+                    info="Databases priorities profile - See the BDPE documentation.",
+                    optional=True,
+                    default=DelayedEnvValue("DOMAINE_SOPRA", "dev"),
+                    values=["oper", "int", "dev"],
                 ),
-                soprano_domain = dict(
-                    info     = 'Databases priorities profile - See the BDPE documentation.',
-                    optional = True,
-                    default  = DelayedEnvValue('DOMAINE_SOPRA', 'dev'),
-                    values   = ['oper', 'int', 'dev'],
+                allow_archive=dict(
+                    info="Allow the use of the archive version of the BDPE databases.",
+                    optional=True,
+                    type=bool,
+                    default=False,
                 ),
-                allow_archive = dict(
-                    info     = 'Allow the use of the archive version of the BDPE databases.',
-                    optional = True,
-                    type     = bool,
-                    default  = False,
+                bdpe_timeout=dict(
+                    info="Seconds before abandoning a request.",
+                    optional=True,
+                    type=int,
+                    default=10,
                 ),
-                bdpe_timeout = dict(
-                    info     = 'Seconds before abandoning a request.',
-                    optional = True,
-                    type     = int,
-                    default  = 10,
+                bdpe_retries=dict(
+                    info="Number of retries when a request fails.",
+                    optional=True,
+                    type=int,
+                    default=3,
                 ),
-                bdpe_retries = dict(
-                    info     = 'Number of retries when a request fails.',
-                    optional = True,
-                    type     = int,
-                    default  = 3,
+                config=dict(
+                    info="A ready to use configuration file object for this storage place.",
+                    type=GenericConfigParser,
+                    optional=True,
+                    default=None,
                 ),
-                config = dict(
-                    info     = 'A ready to use configuration file object for this storage place.',
-                    type     = GenericConfigParser,
-                    optional = True,
-                    default  = None,
-                ),
-                inifile = dict(
-                    info     = ('The name of the configuration file that will be used (if ' +
-                                '**config** is not provided.'),
-                    optional = True,
-                    default  = '@bdpe-map-resources.ini',
+                inifile=dict(
+                    info=(
+                        "The name of the configuration file that will be used (if "
+                        + "**config** is not provided."
+                    ),
+                    optional=True,
+                    default="@bdpe-map-resources.ini",
                 ),
             ),
-            fastkeys = {'bdpeid'},
-        )
+            fastkeys={"bdpeid"},
+        ),
     ]
 
     def __init__(self, *args, **kw):
-        logger.debug('BDPE provider init %s', self.__class__)
+        logger.debug("BDPE provider init %s", self.__class__)
         super().__init__(*args, **kw)
         self._actual_config = self.config
         if self._actual_config is None:
@@ -130,11 +146,11 @@ class BdpeProvider(Provider):
 
     @property
     def realkind(self):
-        return 'bdpe'
+        return "bdpe"
 
     def scheme(self, resource):
         """A dedicated scheme."""
-        return 'bdpe'
+        return "bdpe"
 
     def netloc(self, resource):
         """The actual netloc is the ``namespace`` attribute of the current provider."""
@@ -142,20 +158,26 @@ class BdpeProvider(Provider):
 
     def basename(self, resource):
         """Something like 'BDPE_num+term'."""
-        myterm = getattr(resource, 'term', Time(0))
+        myterm = getattr(resource, "term", Time(0))
         if int(myterm) < 0:
             myterm = Time(9000) - myterm
-        return 'BDPE_{}+{!s}'.format(self.bdpeid, myterm)
+        return "BDPE_{}+{!s}".format(self.bdpeid, myterm)
 
     def pathname(self, resource):
         """Something like 'PREFERRED_FORBIDDEN_DOMAIN_ARCHIVE_TIMEOUT_RETRIES/date/'."""
         try:
             requested_date = resource.date.vortex()
         except AttributeError:
-            requested_date = 'most_recent'
-        return '{}_{}_{}_{}_{}_{}/{}'.format(
-            self.preferred_target, self.forbidden_target, self.soprano_domain,
-            self.allow_archive, self.bdpe_timeout, self.bdpe_retries, requested_date)
+            requested_date = "most_recent"
+        return "{}_{}_{}_{}_{}_{}/{}".format(
+            self.preferred_target,
+            self.forbidden_target,
+            self.soprano_domain,
+            self.allow_archive,
+            self.bdpe_timeout,
+            self.bdpe_retries,
+            requested_date,
+        )
 
     def uri(self, resource):
         """
@@ -165,16 +187,19 @@ class BdpeProvider(Provider):
         # check that the product is described in the configuration file
         if not self._actual_config.has_section(self.bdpeid):
             fmt = 'Missing product n°{} in BDPE configuration file\n"{}"'
-            raise BdpeConfigurationError(fmt.format(self.bdpeid, self.config.file))
+            raise BdpeConfigurationError(
+                fmt.format(self.bdpeid, self.config.file)
+            )
 
         # resource description: rely on the footprint_export (also used to JSONise resources).
-        rsrcdict = {k: str(v)
-                    for k, v in resource.footprint_export().items()}
+        rsrcdict = {k: str(v) for k, v in resource.footprint_export().items()}
 
         # check the BDPE pairs against the resource's
-        for (k, v) in self._actual_config.items(self.bdpeid):
+        for k, v in self._actual_config.items(self.bdpeid):
             if k not in rsrcdict:
-                raise BdpeMismatchError('Missing key "{}" in resource'.format(k))
+                raise BdpeMismatchError(
+                    'Missing key "{}" in resource'.format(k)
+                )
             if rsrcdict[k] != v:
                 fmt = 'Bad value for key "{}": rsrc="{}" bdpe="{}"'
                 raise BdpeMismatchError(fmt.format(k, rsrcdict[k], v))

vortex/nwp/data/query.py

@@ -23,84 +23,66 @@ class Query(StaticResource):
     _footprint = [
         gvar,
         dict(
-            info = 'Abstract class for queries.',
-            attr = dict(
-                gvar = dict(
-                    values  = ['extract_stuff'],
-                    default = 'extract_stuff'
-                ),
-                source = dict(),
-                origin = dict(),
+            info="Abstract class for queries.",
+            attr=dict(
+                gvar=dict(values=["extract_stuff"], default="extract_stuff"),
+                source=dict(),
+                origin=dict(),
             ),
-        )
+        ),
     ]
 
     def gget_urlquery(self):
         """GGET specific query : ``extract``."""
-        return 'extract=' + self.source
+        return "extract=" + self.source
 
 
 class BDAPQuery(Query):
     """Class to deal with BDAP queries."""
+
     _footprint = dict(
-        info = 'BDAP query',
-        attr = dict(
-            kind = dict(
-                values = ['bdap_query']
-            ),
-            origin = dict(
-                default = 'bdap',
-                values = ['bdap'],
-                optional = True
-            )
-        )
+        info="BDAP query",
+        attr=dict(
+            kind=dict(values=["bdap_query"]),
+            origin=dict(default="bdap", values=["bdap"], optional=True),
+        ),
     )
 
     @property
     def realkind(self):
-        return 'bdap_query'
+        return "bdap_query"
 
 
 class BDMPQuery(Query):
     """Class to deal with BDMP queries."""
+
     _footprint = dict(
-        info = 'BDMP query',
-        attr = dict(
-            kind = dict(
-                values = ['bdmp_query']
-            ),
-            origin = dict(
-                default = 'bdmp',
-                values = ['bdmp'],
-                optional = True
-            )
-        )
+        info="BDMP query",
+        attr=dict(
+            kind=dict(values=["bdmp_query"]),
+            origin=dict(default="bdmp", values=["bdmp"], optional=True),
+        ),
     )
 
     @property
     def realkind(self):
-        return 'bdmp_query'
+        return "bdmp_query"
 
 
 class BDCPQuery(Query):
     """Class to deal with BDCP queries."""
+
     _footprint = dict(
-        info = 'BDCP query',
-        attr = dict(
-            kind = dict(
-                values = ['bdcp_query']
-            ),
-            origin = dict(
-                default = 'bdcp',
-                values = ['bdcp'],
-                optional = True
-            ),
-        )
+        info="BDCP query",
+        attr=dict(
+            kind=dict(values=["bdcp_query"]),
+            origin=dict(default="bdcp", values=["bdcp"], optional=True),
+        ),
     )
 
     @property
     def realkind(self):
-        return 'bdcp_query'
+        return "bdcp_query"
 
 
 class StaticCutoffDispenser:
@@ -116,8 +98,9 @@ class StaticCutoffDispenser:
     def __init__(self, default_cutoff, obstype_cutoffs=None):
         self._default_cutoff = default_cutoff
         if obstype_cutoffs:
-            self._cutoffs = {k: {o.lower() for o in v}
-                             for k, v in obstype_cutoffs.items()}
+            self._cutoffs = {
+                k: {o.lower() for o in v} for k, v in obstype_cutoffs.items()
+            }
         else:
             self._cutoffs = {}
 
@@ -150,66 +133,72 @@ class BDMQueryContent(AlmostListContent):
         information in the BDM query.
         """
         if cutoffs_dispenser.max_cutoff is None:
-            logger.warning("The cutoffs_dispenser is empty. No cutoff data can be retrieved")
+            logger.warning(
+                "The cutoffs_dispenser is empty. No cutoff data can be retrieved"
+            )
         else:
             xdata = list()
             for line in self:
                 xdata.append(line)
                 l_match = self._RE_OBSTYPE.match(line)
                 if l_match:
-                    cutoff_fmt = '{0:s}{1:<' + str(len(l_match.group(2))) + 's}:{2:s}{3.ymdhms:s}\n'
+                    cutoff_fmt = (
+                        "{0:s}{1:<"
+                        + str(len(l_match.group(2)))
+                        + "s}:{2:s}{3.ymdhms:s}\n"
+                    )
                     cutoff_date = cutoffs_dispenser(l_match.group(4))
-                    xdata.append(cutoff_fmt.format(l_match.group(1),
-                                                   'CUTOFF',
-                                                   l_match.group(3),
-                                                   cutoff_date))
-                    logger.info('CUTOFF=%s added for obstype < %s >.',
-                                cutoff_date.ymdhms, l_match.group(4))
+                    xdata.append(
+                        cutoff_fmt.format(
+                            l_match.group(1),
+                            "CUTOFF",
+                            l_match.group(3),
+                            cutoff_date,
+                        )
+                    )
+                    logger.info(
+                        "CUTOFF=%s added for obstype < %s >.",
+                        cutoff_date.ymdhms,
+                        l_match.group(4),
+                    )
             self._data = xdata
 
 
 class BDMQuery(Query):
     """Class to deal with BDM queries."""
+
     _footprint = dict(
-        info = 'BDM query',
-        attr = dict(
-            kind = dict(
-                values = ['bdm_query']
-            ),
-            origin = dict(
-                default = 'bdm',
-                values = ['bdm'],
-                optional = True
-            ),
+        info="BDM query",
+        attr=dict(
+            kind=dict(values=["bdm_query"]),
+            origin=dict(default="bdm", values=["bdm"], optional=True),
             clscontents=dict(
-                default = BDMQueryContent,
+                default=BDMQueryContent,
             ),
-        )
+        ),
     )
 
     @property
     def realkind(self):
-        return 'bdm_query'
+        return "bdm_query"
 
 
 class MarsQuery(Query):
     """Class to deal with Mars queries"""
 
     _footprint = dict(
-        info = 'Mars query',
-        attr = dict(
-            kind = dict(
-                values = ['mars_query']
-            ),
-            origin = dict(
-                default = "mars",
-                values = ["mars", ],
-                optional = True
-            ),
-            clscontents=dict(
-                default = DataTemplate
+        info="Mars query",
+        attr=dict(
+            kind=dict(values=["mars_query"]),
+            origin=dict(
+                default="mars",
+                values=[
+                    "mars",
+                ],
+                optional=True,
             ),
-        )
+            clscontents=dict(default=DataTemplate),
+        ),
     )
 
     @property