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

vortex/data/outflow.py

@@ -17,13 +17,12 @@ __all__ = []
 
 
 class StaticResource(Resource):
-
     _abstract = True
     _footprint = dict(
-        attr = dict(
-            kind = dict(
-                info        = "The resource's kind.",
-                doc_zorder  = 90,
+        attr=dict(
+            kind=dict(
+                info="The resource's kind.",
+                doc_zorder=90,
             ),
         )
     )
@@ -36,19 +35,20 @@ class StaticGeoResource(StaticResource):
     _footprint = [
         hgeometry_deco,
         dict(
-            attr = dict(
-                clscontents = dict(
-                    default = FormatAdapter,
+            attr=dict(
+                clscontents=dict(
+                    default=FormatAdapter,
                 ),
             )
-        )
+        ),
     ]
 
 
 class ModelResource(StaticResource):
-
     _abstract = True
-    _footprint = [model_deco, ]
+    _footprint = [
+        model_deco,
+    ]
 
 
 class ModelGeoResource(ModelResource):
@@ -58,10 +58,10 @@ class ModelGeoResource(ModelResource):
     _footprint = [
         hgeometry_deco,
         dict(
-            attr = dict(
-                clscontents = dict(
-                    default = FormatAdapter,
+            attr=dict(
+                clscontents=dict(
+                    default=FormatAdapter,
                 ),
             )
-        )
+        ),
     ]

vortex/data/providers.py

@@ -6,30 +6,26 @@ Of course, the :class:`Vortex` abstract provider is a must see. It has three
 declinations depending on the experiment indentifier type.
 """
 
-import collections
-import operator
 import os.path
-import re
 from urllib import parse as urlparse
 import warnings
 
 from bronx.fancies import loggers
-from bronx.syntax.parsing import StringDecoder
 import footprints
 from footprints import proxy as fpx
-from footprints.stdtypes import FPDict
 
-from vortex import sessions
 from vortex import config
-from vortex.syntax.stdattrs import xpid, legacy_xpid, free_xpid, opsuites, \
-    demosuites, scenario, member, block
-from vortex.syntax.stdattrs import LegacyXPid, any_vortex_xpid
-from vortex.syntax.stdattrs import namespacefp, Namespace, FmtInt
+from vortex.syntax.stdattrs import (
+    xpid,
+    scenario,
+    member,
+    block,
+)
+from vortex.syntax.stdattrs import namespacefp, FmtInt
 from vortex.tools import net, names
-from vortex.util.config import GenericConfigParser
 
 #: No automatic export
-__all__ = ['Provider']
+__all__ = ["Provider"]
 
 logger = loggers.getLogger(__name__)
 
@@ -38,48 +34,48 @@ class Provider(footprints.FootprintBase):
     """Abstract class for any Provider."""
 
     _abstract = True
-    _collector = ('provider',)
+    _collector = ("provider",)
     _footprint = dict(
-        info = 'Abstract root provider',
-        attr = dict(
-            vapp = dict(
-                info        = "The application's identifier.",
-                alias       = ('application',),
-                optional    = True,
-                default     = '[glove::vapp]',
-                doc_zorder  = -10
+        info="Abstract root provider",
+        attr=dict(
+            vapp=dict(
+                info="The application's identifier.",
+                alias=("application",),
+                optional=True,
+                default="[glove::vapp]",
+                doc_zorder=-10,
             ),
-            vconf = dict(
-                info        = "The configuration's identifier.",
-                alias       = ('configuration',),
-                optional    = True,
-                default     = '[glove::vconf]',
-                doc_zorder  = -10
+            vconf=dict(
+                info="The configuration's identifier.",
+                alias=("configuration",),
+                optional=True,
+                default="[glove::vconf]",
+                doc_zorder=-10,
             ),
-            username = dict(
-                info     = "The username that will be used whenever necessary.",
-                optional = True,
-                default  = None,
-                alias    = ('user', 'logname')
+            username=dict(
+                info="The username that will be used whenever necessary.",
+                optional=True,
+                default=None,
+                alias=("user", "logname"),
             ),
         ),
-        fastkeys = {'namespace'},
+        fastkeys={"namespace"},
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Abstract provider init %s', self.__class__)
+        logger.debug("Abstract provider init %s", self.__class__)
         super().__init__(*args, **kw)
 
     def _str_more(self):
         """Additional information to print representation."""
         try:
-            return 'namespace=\'{:s}\''.format(self.namespace)
+            return "namespace='{:s}'".format(self.namespace)
         except AttributeError:
             return super()._str_more()
 
     @property
     def realkind(self):
-        return 'provider'
+        return "provider"
 
     def scheme(self, resource):
         """Abstract method."""
@@ -123,61 +119,67 @@ class Provider(footprints.FootprintBase):
         The different operations of the algorithm can be redefined by subclasses.
         """
         username = self.netuser_name(resource)
-        fullnetloc = ('{:s}@{:s}'.format(username, self.netloc(resource)) if username
-                      else self.netloc(resource))
+        fullnetloc = (
+            "{:s}@{:s}".format(username, self.netloc(resource))
+            if username
+            else self.netloc(resource)
+        )
         logger.debug(
-            'scheme %s netloc %s normpath %s urlquery %s',
+            "scheme %s netloc %s normpath %s urlquery %s",
             self.scheme(resource),
             fullnetloc,
-            os.path.normpath(self.pathname(resource) + '/' + self.basename(resource)),
-            self.urlquery(resource)
+            os.path.normpath(
+                self.pathname(resource) + "/" + self.basename(resource)
+            ),
+            self.urlquery(resource),
         )
 
-        return net.uriunparse((
-            self.scheme(resource),
-            fullnetloc,
-            os.path.normpath(self.pathname(resource) + '/' + self.basename(resource)),
-            None,
-            self.urlquery(resource),
-            None
-        ))
+        return net.uriunparse(
+            (
+                self.scheme(resource),
+                fullnetloc,
+                os.path.normpath(
+                    self.pathname(resource) + "/" + self.basename(resource)
+                ),
+                None,
+                self.urlquery(resource),
+                None,
+            )
+        )
 
 
 class Magic(Provider):
-
     _footprint = [
         xpid,
         dict(
-            info = 'Magic provider that always returns the same URI.',
-            attr = dict(
-                fake = dict(
-                    info     = "Enable this magic provider.",
-                    alias    = ('nowhere', 'noprovider'),
-                    type     = bool,
-                    optional = True,
-                    default  = True,
+            info="Magic provider that always returns the same URI.",
+            attr=dict(
+                fake=dict(
+                    info="Enable this magic provider.",
+                    alias=("nowhere", "noprovider"),
+                    type=bool,
+                    optional=True,
+                    default=True,
                 ),
-                magic = dict(
-                    info     = "The URI returned by this provider."
+                magic=dict(info="The URI returned by this provider."),
+                experiment=dict(
+                    optional=True,
+                    doc_visibility=footprints.doc.visibility.ADVANCED,
                 ),
-                experiment = dict(
-                    optional = True,
-                    doc_visibility  = footprints.doc.visibility.ADVANCED,
+                vapp=dict(
+                    doc_visibility=footprints.doc.visibility.GURU,
                 ),
-                vapp = dict(
-                    doc_visibility  = footprints.doc.visibility.GURU,
-                ),
-                vconf = dict(
-                    doc_visibility  = footprints.doc.visibility.GURU,
+                vconf=dict(
+                    doc_visibility=footprints.doc.visibility.GURU,
                 ),
             ),
-            fastkeys = {'magic'},
-        )
+            fastkeys={"magic"},
+        ),
     ]
 
     @property
     def realkind(self):
-        return 'magic'
+        return "magic"
 
     def uri(self, resource):
         """URI is supposed to be the magic value !"""
@@ -185,47 +187,46 @@ class Magic(Provider):
 
 
 class Remote(Provider):
-
     _footprint = dict(
-        info = 'Provider that manipulates data given a real path',
-        attr = dict(
-            remote = dict(
-                info        = 'The path to the data.',
-                alias       = ('remfile', 'rempath'),
-                doc_zorder  = 50
+        info="Provider that manipulates data given a real path",
+        attr=dict(
+            remote=dict(
+                info="The path to the data.",
+                alias=("remfile", "rempath"),
+                doc_zorder=50,
             ),
-            hostname = dict(
-                info     = 'The hostname that holds the data.',
-                optional = True,
-                default  = 'localhost'
+            hostname=dict(
+                info="The hostname that holds the data.",
+                optional=True,
+                default="localhost",
             ),
-            tube = dict(
-                info     = "The protocol used to access the data.",
-                optional = True,
-                values   = ['scp', 'ftp', 'rcp', 'file', 'symlink'],
-                default  = 'file',
+            tube=dict(
+                info="The protocol used to access the data.",
+                optional=True,
+                values=["scp", "ftp", "rcp", "file", "symlink"],
+                default="file",
             ),
-            vapp = dict(
-                doc_visibility  = footprints.doc.visibility.GURU,
+            vapp=dict(
+                doc_visibility=footprints.doc.visibility.GURU,
             ),
-            vconf = dict(
-                doc_visibility  = footprints.doc.visibility.GURU,
+            vconf=dict(
+                doc_visibility=footprints.doc.visibility.GURU,
             ),
         ),
-        fastkeys = {'remote'},
+        fastkeys={"remote"},
     )
 
     def __init__(self, *args, **kw):
-        logger.debug('Remote provider init %s', self.__class__)
+        logger.debug("Remote provider init %s", self.__class__)
         super().__init__(*args, **kw)
 
     @property
     def realkind(self):
-        return 'remote'
+        return "remote"
 
     def _str_more(self):
         """Additional information to print representation."""
-        return 'path=\'{:s}\''.format(self.remote)
+        return "path='{:s}'".format(self.remote)
 
     def scheme(self, resource):
         """The Remote scheme is its tube."""
@@ -245,10 +246,10 @@ class Remote(Provider):
 
     def urlquery(self, resource):
         """Check for relative path or not."""
-        if self.remote.startswith('/'):
+        if self.remote.startswith("/"):
             return None
         else:
-            return 'relative=1'
+            return "relative=1"
 
 
 def set_namespace_from_cache_settings(usecache, usearchive):
@@ -285,72 +286,81 @@ class Vortex(Provider):
         scenario,
         namespacefp,
         dict(
-            info = 'Vortex provider',
-            attr = dict(
-                experiment = dict(
-                    info = "Provider experiment id",
-                    type = str,
-                    optional = False,
-                    access = "rwx",
+            info="Vortex provider",
+            attr=dict(
+                experiment=dict(
+                    info="Provider experiment id",
+                    type=str,
+                    optional=False,
+                    access="rwx",
                 ),
-                member = dict(
-                    type    = FmtInt,
-                    args    = dict(fmt = '03'),
+                member=dict(
+                    type=FmtInt,
+                    args=dict(fmt="03"),
                 ),
-                namespace = dict(
-                    values   = [
-                        'vortex.cache.fr', 'vortex.archive.fr', 'vortex.multi.fr', 'vortex.stack.fr',
-                        'open.cache.fr', 'open.archive.fr', 'open.multi.fr', 'open.stack.fr',
+                namespace=dict(
+                    values=[
+                        "vortex.cache.fr",
+                        "vortex.archive.fr",
+                        "vortex.multi.fr",
+                        "vortex.stack.fr",
+                        "open.cache.fr",
+                        "open.archive.fr",
+                        "open.multi.fr",
+                        "open.stack.fr",
                     ],
-                    remap    = {
-                        'open.cache.fr': 'vortex.cache.fr',
-                        'open.archive.fr': 'vortex.archive.fr',
-                        'open.multi.fr': 'vortex.multi.fr',
-                        'open.stack.fr': 'vortex.stack.fr',
+                    remap={
+                        "open.cache.fr": "vortex.cache.fr",
+                        "open.archive.fr": "vortex.archive.fr",
+                        "open.multi.fr": "vortex.multi.fr",
+                        "open.stack.fr": "vortex.stack.fr",
                     },
-                    optional = True,
-                    default = None,
-                    access = "rwx",
+                    optional=True,
+                    default=None,
+                    access="rwx",
                 ),
-                cache = dict(
-                    info = "Whether or not to use the cache",
-                    type = bool,
-                    optional = True,
-                    default = None,
+                cache=dict(
+                    info="Whether or not to use the cache",
+                    type=bool,
+                    optional=True,
+                    default=None,
                 ),
-                archive = dict(
-                    info = "Whether or not to use the archive",
-                    type = bool,
-                    optional = True,
-                    default = None,
+                archive=dict(
+                    info="Whether or not to use the archive",
+                    type=bool,
+                    optional=True,
+                    default=None,
                 ),
-                namebuild = dict(
-                    info           = "The object responsible for building filenames.",
-                    optional       = True,
-                    doc_visibility = footprints.doc.visibility.ADVANCED,
+                namebuild=dict(
+                    info="The object responsible for building filenames.",
+                    optional=True,
+                    doc_visibility=footprints.doc.visibility.ADVANCED,
                 ),
-                expected = dict(
-                    info        = "Is the resource expected ?",
-                    alias       = ('promised',),
-                    type        = bool,
-                    optional    = True,
-                    default     = False,
-                    doc_zorder  = -5,
+                expected=dict(
+                    info="Is the resource expected ?",
+                    alias=("promised",),
+                    type=bool,
+                    optional=True,
+                    default=False,
+                    doc_zorder=-5,
                 ),
             ),
-            fastkeys = {'block', 'experiment'},
-        )
+            fastkeys={"block", "experiment"},
+        ),
     ]
 
     def __init__(self, *args, **kw):
-        logger.debug('Vortex experiment provider init %s', self.__class__)
+        logger.debug("Vortex experiment provider init %s", self.__class__)
         super().__init__(*args, **kw)
         if self.namebuild is not None:
             if self.namebuild not in self._CUSTOM_NAME_BUILDERS:
                 builder = fpx.vortexnamebuilder(name=self.namebuild)
                 if builder is None:
-                    raise ValueError("The << {:s} >> name builder does not exists."
-                                     .format(self.namebuild))
+                    raise ValueError(
+                        "The << {:s} >> name builder does not exists.".format(
+                            self.namebuild
+                        )
+                    )
                 self._CUSTOM_NAME_BUILDERS[self.namebuild] = builder
             self._namebuilder = self._CUSTOM_NAME_BUILDERS[self.namebuild]
         else:
@@ -368,23 +378,26 @@ class Vortex(Provider):
         # are specified, 'namespace' is ignored
         if self.namespace and (self.cache or self.archive):
             logger.warning(
-                f"Ignoring attribute \"namespace\" set to {self.namespace} "
+                f'Ignoring attribute "namespace" set to {self.namespace} '
                 "as attribute(s) cache and/or archive are specified"
             )
-        if self.namespace and ((self.cache is None) and (self.archive is None)):
+        if self.namespace and (
+            (self.cache is None) and (self.archive is None)
+        ):
             warnings.warn(
-                "Using attribute \"namespace\" is deprecated, use \"cache\""
-                "and/or \"archive\" instead.",
+                'Using attribute "namespace" is deprecated, use "cache"'
+                'and/or "archive" instead.',
                 category=DeprecationWarning,
             )
         else:
             self.namespace = set_namespace_from_cache_settings(
-                self.cache, self.archive,
-        )
+                self.cache,
+                self.archive,
+            )
             if not self.namespace:
                 raise ValueError(
-                    "Attributes \"cache\" and \"archive\" cannot be "
-                    "both specified as \"False\"."
+                    'Attributes "cache" and "archive" cannot be '
+                    'both specified as "False".'
                 )
 
     @property
@@ -393,7 +406,7 @@ class Vortex(Provider):
 
     @property
     def realkind(self):
-        return 'vortex'
+        return "vortex"
 
     def actual_experiment(self, resource):
         return self.experiment
@@ -401,13 +414,15 @@ class Vortex(Provider):
     def _str_more(self):
         """Additional information to print representation."""
         try:
-            return 'namespace=\'{:s}\' block=\'{:s}\''.format(self.namespace, self.block)
+            return "namespace='{:s}' block='{:s}'".format(
+                self.namespace, self.block
+            )
         except AttributeError:
             return super()._str_more()
 
     def scheme(self, resource):
         """Default: ``vortex``."""
-        return 'x' + self.realkind if self.expected else self.realkind
+        return "x" + self.realkind if self.expected else self.realkind
 
     def netloc(self, resource):
         """Returns the current ``namespace``."""
@@ -450,16 +465,23 @@ class Vortex(Provider):
         stackres, keepmember = resource.stackedstorage_resource()
         if stackres:
             stackpathinfo = self._pathname_info(stackres)
-            stackpathinfo['block'] = 'stacks'
+            stackpathinfo["block"] = "stacks"
             if not keepmember:
-                stackpathinfo['member'] = None
-            uqs['stackpath'] = [(self.namebuilder.pack_pathname(stackpathinfo) + '/' +
-                                 self.basename(stackres)), ]
-            uqs['stackfmt'] = [stackres.nativefmt, ]
+                stackpathinfo["member"] = None
+            uqs["stackpath"] = [
+                (
+                    self.namebuilder.pack_pathname(stackpathinfo)
+                    + "/"
+                    + self.basename(stackres)
+                ),
+            ]
+            uqs["stackfmt"] = [
+                stackres.nativefmt,
+            ]
         return urlparse.urlencode(sorted(uqs.items()), doseq=True)
 
 
 # Activate the footprint's fasttrack on the resources collector
-fcollect = footprints.collectors.get(tag='provider')
-fcollect.fasttrack = ('namespace', )
+fcollect = footprints.collectors.get(tag="provider")
+fcollect.fasttrack = ("namespace",)
 del fcollect